/** * Returns a global scale factor for the specified affine transform. This scale factor will * combines {@link #getScaleX0} and {@link #getScaleY0}. The way to compute such a "global" * scale is somewhat arbitrary and may change in a future version. */ public static double getScale(final AffineTransform tr) { return 0.5 * (getScaleX0(tr) + getScaleY0(tr)); }
/** * Computes the resolutions for the provided "grid to world" transformation The returned * resolution array is of length of 2. * * @param gridToCRS The grid to world transformation. */ public static double[] getResolution(final AffineTransform gridToCRS) { double[] requestedRes = null; if (gridToCRS != null) { requestedRes = new double[2]; requestedRes[0] = XAffineTransform.getScaleX0(gridToCRS); requestedRes[1] = XAffineTransform.getScaleY0(gridToCRS); } return requestedRes; }
double yRes = XAffineTransform.getScaleY0(gridToCRS);
/** * Extends the provided {@link Envelope} in order to add the number of pixels specified by * <code>buffer</code> in every direction. * * @param envelope to extend. * @param worldToScreen by means of which doing the extension. * @param buffer to use for the extension. * @return an extended version of the provided {@link Envelope}. */ private Envelope expandEnvelope(Envelope envelope, AffineTransform worldToScreen, int buffer) { assert buffer > 0; double bufferX = Math.abs(buffer * 1.0 / XAffineTransform.getScaleX0(worldToScreen)); double bufferY = Math.abs(buffer * 1.0 / XAffineTransform.getScaleY0(worldToScreen)); return new Envelope( envelope.getMinX() - bufferX, envelope.getMaxX() + bufferX, envelope.getMinY() - bufferY, envelope.getMaxY() + bufferY); }
/** * Returns an estimation about whatever the specified transform swaps <var>x</var> and * <var>y</var> axis. This method assumes that the specified affine transform is built from * arbitrary translations, scales or rotations, but no shear. It returns {@code +1} if the * (<var>x</var>, <var>y</var>) axis order seems to be preserved, {@code -1} if the transform * seems to swap axis to the (<var>y</var>, <var>x</var>) axis order, or {@code 0} if this * method can not make a decision. */ public static int getSwapXY(final AffineTransform tr) { final int flip = getFlip(tr); if (flip != 0) { final double scaleX = getScaleX0(tr); final double scaleY = getScaleY0(tr) * flip; final double y = Math.abs(tr.getShearY() / scaleY - tr.getShearX() / scaleX); final double x = Math.abs(tr.getScaleY() / scaleY + tr.getScaleX() / scaleX); if (x > y) return +1; if (x < y) return -1; // At this point, we may have (x == y) or some NaN value. } return 0; }
/** * Classic way of computing the requested resolution * * @return */ private double[] computeClassicResolution() { final GridToEnvelopeMapper geMapper = new GridToEnvelopeMapper(new GridEnvelope2D(requestedRasterArea), requestedBBox); final AffineTransform tempTransform = geMapper.createAffineTransform(); return new double[] { XAffineTransform.getScaleX0(tempTransform), XAffineTransform.getScaleY0(tempTransform) }; }
XAffineTransform.getScaleY0(requestedGridToWorld) };
/** * Returns an estimation of the rotation angle in radians. This method assumes that the * specified affine transform is built from arbitrary translations, scales or rotations, but no * shear. If a flip has been applied, then this method assumes that the flipped axis is the * <var>y</var> one in <cite>source CRS</cite> space. For a <cite>grid to world CRS</cite> * transform, this is the row number in grid coordinates. * * @param tr The affine transform to inspect. * @return An estimation of the rotation angle in radians, or {@link Double#NaN NaN} if the * angle can not be estimated. */ public static double getRotation(final AffineTransform tr) { final int flip = getFlip(tr); if (flip != 0) { final double scaleX = getScaleX0(tr); final double scaleY = getScaleY0(tr) * flip; return Math.atan2( tr.getShearY() / scaleY - tr.getShearX() / scaleX, tr.getScaleY() / scaleY + tr.getScaleX() / scaleX); } return Double.NaN; }
new double[] { XAffineTransform.getScaleX0(tempTransform), XAffineTransform.getScaleY0(tempTransform) }; } else { new double[] { XAffineTransform.getScaleX0(requestedGridToWorld), XAffineTransform.getScaleY0(requestedGridToWorld) };
new double[] { XAffineTransform.getScaleX0(tempTransform), XAffineTransform.getScaleY0(tempTransform) }; new double[] { XAffineTransform.getScaleX0(requestedGridToWorld), XAffineTransform.getScaleY0(requestedGridToWorld) };
double deltaMaxY = Math.abs(envelope.getMaxY() - granuleBBOX.getMaxY()); final double resX = XAffineTransform.getScaleX0(baseGridToWorld); final double resY = XAffineTransform.getScaleY0(baseGridToWorld); final double toleranceX = resX / Utils.SAMEBBOX_THRESHOLD_FACTOR; final double toleranceY = resY / Utils.SAMEBBOX_THRESHOLD_FACTOR;
highestRes = new double[2]; highestRes[0] = XAffineTransform.getScaleX0(tempTransform); highestRes[1] = XAffineTransform.getScaleY0(tempTransform); } else {
double resY = XAffineTransform.getScaleY0(requestedGridToWorld); GeneralEnvelope cropBboxTarget = CRS.transform(readBBox, requestedBBox.getCoordinateReferenceSystem()); AffineTransform transform = mapper.createAffineTransform(); fullRes[0] = XAffineTransform.getScaleX0(transform); fullRes[1] = XAffineTransform.getScaleY0(transform);
Math.min( XAffineTransform.getScaleX0(transform), XAffineTransform.getScaleY0(transform)); final GeneralEnvelope tempEnvelope = CRS.transform(tr, toEnvelope(gridRange));
highestRes[1] = XAffineTransform.getScaleY0(tempTransform);
XAffineTransform.getScaleX0(selectedlevel.gridToWorldTransformCorner) / virtualNativeResolution[0], XAffineTransform.getScaleY0(selectedlevel.gridToWorldTransformCorner) / virtualNativeResolution[1]);
/** * Computes the resolutions for the provided "grid to world" transformation * The returned resolution array is of length of 2. * * @param gridToCRS * The grid to world transformation. */ public static double[] getResolution(final AffineTransform gridToCRS) { double[] requestedRes = null; if (gridToCRS != null) { requestedRes = new double[2]; requestedRes[0] = XAffineTransform.getScaleX0(gridToCRS); requestedRes[1] = XAffineTransform.getScaleY0(gridToCRS); } return requestedRes; }
(AffineTransform) ((GridGeometry2D) gc.getGridGeometry()).getGridToCRS2D(); final double dx = XAffineTransform.getScaleX0(gridToWorld); final double dy = XAffineTransform.getScaleY0(gridToWorld); if (AsciiGridsImageWriter.resolutionCheck(dx, dy, AsciiGridsImageWriter.EPS)) { return gc;
tr.setToScale(1, f); assertEquals(1, XAffineTransform.getScaleX0(tr), EPS); assertEquals(1, XAffineTransform.getScaleY0(tr), EPS); assertEquals(0, XAffineTransform.getRotation(tr), EPS); assertEquals(1, XAffineTransform.getSwapXY(tr)); tr.rotate(r); assertEquals(1, XAffineTransform.getScaleX0(tr), EPS); assertEquals(1, XAffineTransform.getScaleY0(tr), EPS); assertEquals(r, XAffineTransform.getRotation(tr), EPS); assertEquals(1, XAffineTransform.getSwapXY(tr)); tr.rotate(Math.toRadians(40)); assertEquals(1, XAffineTransform.getScaleX0(tr), EPS); assertEquals(1, XAffineTransform.getScaleY0(tr), EPS); assertEquals(r, XAffineTransform.getRotation(tr), EPS); assertEquals(-1, XAffineTransform.getSwapXY(tr)); assertEquals(3, XAffineTransform.getScaleY0(tr), EPS); assertEquals(0, XAffineTransform.getRotation(tr), EPS); assertEquals(1, XAffineTransform.getSwapXY(tr)); assertEquals(3, XAffineTransform.getScaleY0(tr), EPS); assertEquals(r, XAffineTransform.getRotation(tr), EPS); assertEquals(-1, XAffineTransform.getSwapXY(tr)); tr.setTransform(0, 1, f, 0, 0, 0); assertEquals(1, XAffineTransform.getScaleX0(tr), EPS); assertEquals(1, XAffineTransform.getScaleY0(tr), EPS);
/** @return the native resolution */ double[] computeNativeResolution() { double[] nativeResolution = new double[2]; MathTransform transform = reader.getOriginalGridToWorld(PixelInCell.CELL_CENTER); AffineTransform af = (AffineTransform) transform; // getting the native resolution nativeResolution[0] = XAffineTransform.getScaleX0(af); nativeResolution[1] = XAffineTransform.getScaleY0(af); return nativeResolution; }