import org.opengis.referencing.operation.MathTransformFactory; //导入依赖的package包/类
/**
 * Returns the math transform for the two specified dimensions of the specified transform.
 *
 * @param transform The transform.
 * @param mtFactory The factory to use for extracting the sub-transform.
 *
 * @return The {@link MathTransform2D} part of {@code transform}.
 *
 * @throws FactoryException If {@code transform} is not separable.
 */
private static MathTransform2D toMathTransform2D(final MathTransform transform,
                                                 final MathTransformFactory mtFactory) throws FactoryException {
    final DimensionFilter filter = new DimensionFilter(mtFactory);
    filter.addSourceDimension(DIMENSION_X_INDEX);
    filter.addSourceDimension(DIMENSION_Y_INDEX);
    MathTransform candidate = filter.separate(transform);
    if (candidate instanceof MathTransform2D) {
        return (MathTransform2D) candidate;
    }
    filter.addTargetDimension(DIMENSION_X_INDEX);
    filter.addTargetDimension(DIMENSION_Y_INDEX);
    candidate = filter.separate(transform);
    if (candidate instanceof MathTransform2D) {
        return (MathTransform2D) candidate;
    }
    throw new FactoryException(Errors.format(ErrorKeys.NO_TRANSFORM2D_AVAILABLE));
}
 

import org.opengis.referencing.operation.MathTransformFactory; //导入依赖的package包/类
@Override
public CoordinateReferenceSystem getCRS(final GeoPos referencePos, ParameterValueGroup parameters,
                                        GeodeticDatum datum) throws FactoryException {
    final CRSFactory crsFactory = ReferencingFactoryFinder.getCRSFactory(null);
    // in some cases, depending on the parameters set, the effective transformation can be different
    // from the transformation given by the OperationMethod.
    // So we create a new one
    final MathTransformFactory mtFactory = ReferencingFactoryFinder.getMathTransformFactory(null);
    final MathTransform transform = mtFactory.createParameterizedTransform(parameters);
    final DefaultOperationMethod operationMethod = new DefaultOperationMethod(transform);

    final Conversion conversion = new DefiningConversion(AbstractIdentifiedObject.getProperties(operationMethod),
                                                         operationMethod, transform);

    final HashMap<String, Object> baseCrsProperties = new HashMap<String, Object>();
    baseCrsProperties.put("name", datum.getName().getCode());
    GeographicCRS baseCrs = crsFactory.createGeographicCRS(baseCrsProperties,
                                                           datum,
                                                           DefaultEllipsoidalCS.GEODETIC_2D);

    final HashMap<String, Object> projProperties = new HashMap<String, Object>();
    projProperties.put("name", conversion.getName().getCode() + " / " + datum.getName().getCode());
    return crsFactory.createProjectedCRS(projProperties, baseCrs, conversion, DefaultCartesianCS.PROJECTED);
}
 

import org.opengis.referencing.operation.MathTransformFactory; //导入依赖的package包/类
public static Set<AbstractCrsProvider> createCrsProviderSet() {
    MathTransformFactory factory = ReferencingFactoryFinder.getMathTransformFactory(null);
    Set<OperationMethod> methods = factory.getAvailableMethods(Projection.class);

    TreeSet<AbstractCrsProvider> crsProviderSet = new TreeSet<>(new CrsProviderComparator());
    for (OperationMethod method : methods) {
        crsProviderSet.add(new OperationMethodCrsProvider(method));
    }

    return crsProviderSet;
}
 

import org.opengis.referencing.operation.MathTransformFactory; //导入依赖的package包/类
/**
 * Creates a WGS 84/UTM Zone 10N CRS mostly (uses some premade objects) by hand. Uses the higher
 * level FactoryGroup instead of the lower level MathTransformFactory (commented out).
 * 
 * @throws Exception
 */
void createCRSByHand1() throws Exception {
    System.out.println("------------------------------------------");
    System.out.println("Creating a CRS by hand:");
    // createCRSByHand1 start
    MathTransformFactory mtFactory = ReferencingFactoryFinder.getMathTransformFactory(null);
    CRSFactory crsFactory = ReferencingFactoryFinder.getCRSFactory(null);
    
    GeographicCRS geoCRS = org.geotools.referencing.crs.DefaultGeographicCRS.WGS84;
    CartesianCS cartCS = org.geotools.referencing.cs.DefaultCartesianCS.GENERIC_2D;
    
    ParameterValueGroup parameters = mtFactory.getDefaultParameters("Transverse_Mercator");
    parameters.parameter("central_meridian").setValue(-111.0);
    parameters.parameter("latitude_of_origin").setValue(0.0);
    parameters.parameter("scale_factor").setValue(0.9996);
    parameters.parameter("false_easting").setValue(500000.0);
    parameters.parameter("false_northing").setValue(0.0);
    Conversion conversion = new DefiningConversion("Transverse_Mercator", parameters);
    
    Map<String, ?> properties = Collections.singletonMap("name", "WGS 84 / UTM Zone 12N");
    ProjectedCRS projCRS = crsFactory.createProjectedCRS(properties, geoCRS, conversion, cartCS);
    // createCRSByHand1 end
    
    // parameters.parameter("semi_major").setValue(((GeodeticDatum)geoCRS.getDatum()).getEllipsoid().getSemiMajorAxis());
    // parameters.parameter("semi_minor").setValue(((GeodeticDatum)geoCRS.getDatum()).getEllipsoid().getSemiMinorAxis());
    
    // MathTransform trans = mtFactory.createParameterizedTransform(parameters);
    // ProjectedCRS projCRS = crsFactory.createProjectedCRS(
    // Collections.singletonMap("name", "WGS 84 / UTM Zone 12N"),
    // new org.geotools.referencing.operation.OperationMethod(trans),
    // geoCRS, trans, cartCS);
    System.out.println("  Projected CRS: " + projCRS.toWKT());
    System.out.println("------------------------------------------");
    
    // save for later use in createMathTransformBetweenCRSs()
    this.utm10NCRS = projCRS;
}