import org.geotools.referencing.operation.transform.AffineTransform2D; //导入依赖的package包/类
private void initBandGeoCoding(ImageMetadata imageMetadata, Band band, int sceneWidth, int sceneHeight) {
    int bandWidth = imageMetadata.getRasterWidth();
    int bandHeight = imageMetadata.getRasterHeight();
    GeoCoding geoCoding = null;
    ImageMetadata.InsertionPoint insertPoint = imageMetadata.getInsertPoint();
    String crsCode = imageMetadata.getCRSCode();
    try {
        CoordinateReferenceSystem crs = CRS.decode(crsCode);
        if (imageMetadata.hasInsertPoint()) {
                geoCoding = new CrsGeoCoding(crs,
                        bandWidth, bandHeight,
                        insertPoint.x, insertPoint.y,
                        insertPoint.stepX, insertPoint.stepY, 0.0, 0.0);
        } else {
            if (sceneWidth != bandWidth) {
                AffineTransform2D transform2D = new AffineTransform2D((float) sceneWidth / bandWidth, 0.0, 0.0, (float) sceneHeight / bandHeight, 0.0, 0.0);
                band.setImageToModelTransform(transform2D);
            }
        }
    } catch (Exception e) {
        logger.warning(e.getMessage());
    }
    band.setGeoCoding(geoCoding);
}
 

import org.geotools.referencing.operation.transform.AffineTransform2D; //导入依赖的package包/类
@Override
        protected void computeRect(PlanarImage[] sourceImages, WritableRaster tile, Rectangle destRect) {
            final BufferedImage image = new BufferedImage(colorModel,
                    RasterFactory.createWritableRaster(tile.getSampleModel(),
                            tile.getDataBuffer(),
                            new Point(0, 0)), false, null);
            final Graphics2D graphics2D = image.createGraphics();
            graphics2D.translate(-(tile.getMinX() + 0.5), -(tile.getMinY() + 0.5));
            graphics2D.setColor(Color.WHITE);

            FeatureIterator<SimpleFeature> featureIterator = featureCollection.features();
            try {
                AffineTransform transform = AffineTransform.getScaleInstance(1.0 / getScale(), 1.0 / getScale());
//                transform.concatenate(m2iTransform);
                AffineTransform2D transform2D = new AffineTransform2D(transform);

                while (featureIterator.hasNext()) {
                    SimpleFeature feature = featureIterator.next();
                    Object value = feature.getDefaultGeometry();
                    if (value instanceof Geometry) {
                        try {
                            renderGeometry((Geometry) value, graphics2D, transform2D);
                        } catch (Exception ignored) {
                            // ignore
                        }
                    }
                }
            } finally {
                featureIterator.close();
            }

            graphics2D.dispose();

            final byte[] data = ((DataBufferByte) tile.getDataBuffer()).getData();
            for (int i = 0; i < data.length; i++) {
                data[i] = (data[i] != 0) ? TRUE : FALSE;
            }
        }
 

import org.geotools.referencing.operation.transform.AffineTransform2D; //导入依赖的package包/类
/**
 * Scales a {@link Polygon} to have an unitary area.
 * 
 * @param polygon the geometry to scale.
 * @return a copy of the scaled geometry.
 * @throws Exception 
 */
public static Geometry scaleToUnitaryArea( Geometry polygon ) throws Exception {
    double area = polygon.getArea();
    double scale = sqrt(1.0 / area);
    AffineTransform scaleAT = new AffineTransform();
    scaleAT.scale(scale, scale);
    AffineTransform2D scaleTransform = new AffineTransform2D(scaleAT);
    polygon = JTS.transform(polygon, scaleTransform);
    return polygon;
}
 

import org.geotools.referencing.operation.transform.AffineTransform2D; //导入依赖的package包/类
/**
 * Utility method for transforming a geometry ROI into the raster space, using the provided affine transformation.
 * 
 * @param roi a {@link Geometry} in model space.
 * @param mt2d an {@link AffineTransform} that maps from raster to model space. This is already referred to the pixel corner.
 * @return a {@link ROI} suitable for using with JAI.
 * @throws ProcessException in case there are problems with ivnerting the provided {@link AffineTransform}. Very unlikely to happen.
 */
public static ROI prepareROI( Geometry roi, AffineTransform mt2d ) throws Exception {
    // transform the geometry to raster space so that we can use it as a ROI source
    Geometry rasterSpaceGeometry = JTS.transform(roi, new AffineTransform2D(mt2d.createInverse()));

    // simplify the geometry so that it's as precise as the coverage, excess coordinates
    // just make it slower to determine the point in polygon relationship
    Geometry simplifiedGeometry = DouglasPeuckerSimplifier.simplify(rasterSpaceGeometry, 1);

    // build a shape using a fast point in polygon wrapper
    return new ROIShape(new FastLiteShape(simplifiedGeometry));
}
 

import org.geotools.referencing.operation.transform.AffineTransform2D; //导入依赖的package包/类
@Test
public void testGetPatchCoordinates() throws Exception {
    final Rectangle r = new Rectangle(0, 0, 200, 200);
    final MathTransform t = new AffineTransform2D(new AffineTransform());

    final Point patchCoordinates = patchGrid.getPatchCoordinates(r, t);
    assertEquals(90, patchCoordinates.x);
    assertEquals(45, patchCoordinates.y);
}
 

import org.geotools.referencing.operation.transform.AffineTransform2D; //导入依赖的package包/类
private LiteShape2 getSampleShape(Symbolizer symbolizer, int width, int height) {
	MetaBufferEstimator estimator = new MetaBufferEstimator();
	estimator.visit(symbolizer);
	// add an extra pixel to the margin (odd line widths were not always shown)
	int margin = estimator.getBuffer() + 1;
	// we define a shape in WKT of size 1 x 1 and transform it to a rectangle of (width-margin) x (height-margin),
	// to make sure we capture thick strokes
	MathTransform transform = new AffineTransform2D(width - margin, 0, 0, height - margin, 0.5 * margin,
			0.5 * margin);
	try {
		WKTReader wktReader = new WKTReader();
		if (symbolizer instanceof LineSymbolizer) {
			return new LiteShape2(wktReader.read("LINESTRING (0 0, 0.66 0.33, 0.33 0.66, 1 1)"), transform, null,
					false);
		} else if (symbolizer instanceof PolygonSymbolizer) {
			return new LiteShape2(wktReader.read("POLYGON ((0 0, 1 0, 1 1, 0 1, 0 0))"), transform, null, false);
		} else if (symbolizer instanceof PointSymbolizer) {
			return new LiteShape2(wktReader.read("POINT (0.5 0.5)"), transform, null, false);
		} else {
			return null;
		}
	} catch (Exception e) { // NOSONAR
		// should not happen
		log.warn("Could not create sample shapes", e);
		return null;
	}
}