Public

Creates a CRSPair for the specified source and target CRS.

<init>

Returns the name of the GeoAPI interface implemented by the specified object. In
the GeographicCRS o

label

Returns a string representation of this key.

toString

DateTime

Creating JSON documents from java classes using gson

A specialized Reader that reads from a file in the file system. All read
requests made by calling me

java.io.FileReader

 Locale represents a language/country/variant combination. Locales are used to
alter the presentatio

java.util.Locale

TreeSet is an implementation of SortedSet. All optional operations (adding and
removing) are support

java.util.TreeSet

org.hamcrest.core.IsNull

Abstract superclass of object loading (and querying) strategies. This class
implements useful common

org.hibernate.loader.Loader

org.hibernate.mapping.Table

setContentView

getApplicationContext

addToBackStack

/**
     * Returns a name for a transformation between two CRS.
     */

/**
 * Finds or infers operations for conversions or transformations between two coordinate reference systems.
 * {@code CoordinateOperationRegistry} implements the <cite>late-binding</cite> approach (see definition
 * of terms in class javadoc) by extracting the authority codes from the supplied {@code sourceCRS} and
 * {@code targetCRS}, then by submitting those codes to the
 * <code>{@linkplain CoordinateOperationAuthorityFactory#createFromCoordinateReferenceSystemCodes
 * createFromCoordinateReferenceSystemCodes}(sourceCode, targetCode)</code> method.
 *
 * Operations in the returned list are ordered in preference order (preferred operation first).
 * If no operation is found for those codes, then this method returns an empty list.
 * Note that it does not mean that no path exist;
 * it only means that it was not defined explicitly in the registry.
 *
 * @param sourceCRS input coordinate reference system.
 * @param targetCRS output coordinate reference system.
 * @return coordinate operations from {@code sourceCRS} to {@code targetCRS},
 * or an empty list if no such operation is explicitly defined in the underlying database.
 * @throws FactoryException if the operation creation failed.
 */

/*
             * First, try directly the provided (sourceCRS, targetCRS) pair. If that pair does not work,
             * try to use different combinations of user-provided CRS and two-dimensional components of
             * those CRS. The code below assumes that the user-provided CRS are three-dimensional, but
             * actually it works for other kind of CRS too without testing twice the same combinations.
             */

/*
                     * Found an operation. If we had to extract the horizontal part of some 3D CRS, then we
                     * need to modify the coordinate operation in order to match the new number of dimensions.
                     */

/**
 * Finds or infers an operation for conversion or transformation between two coordinate reference systems.
 * {@code CoordinateOperationRegistry} implements the <cite>late-binding</cite> approach (see definition
 * of terms in class javadoc) by extracting the authority codes from the supplied {@code sourceCRS} and
 * {@code targetCRS}, then by submitting those codes to the
 * <code>{@linkplain CoordinateOperationAuthorityFactory#createFromCoordinateReferenceSystemCodes
 * createFromCoordinateReferenceSystemCodes}(sourceCode, targetCode)</code> method.
 * If no operation is found for those codes, then this method returns {@code null}.
 * Note that it does not mean that no path exist;
 * it only means that it was not defined explicitely in the registry.
 *
 * If the subclass implements the <cite>early-binding</cite> approach (which is the fallback if late-binding
 * gave no result), then this method should never return {@code null} since there is no other fallback.
 * Instead, this method may throw an {@link OperationNotFoundException}.
 *
 * @param sourceCRS input coordinate reference system.
 * @param targetCRS output coordinate reference system.
 * @return a coordinate operation from {@code sourceCRS} to {@code targetCRS},
 * or {@code null} if no such operation is explicitly defined in the underlying database.
 * @throws OperationNotFoundException if no operation path was found from {@code sourceCRS} to {@code targetCRS}.
 * @throws FactoryException if the operation creation failed for some other reason.
 */

/**
 * Finds or creates an operation for conversion or transformation between two coordinate reference systems.
 * If an operation exists, it is returned. If more than one operation exists, then the operation having the
 * widest intersection between its {@linkplain AbstractCoordinateOperation#getDomainOfValidity() domain of
 * validity} and the {@linkplain CoordinateOperationContext#getAreaOfInterest() area of interest} is returned.
 *
 * The default implementation performs the following steps:
 * <ul>
 * <li>If a coordinate operation has been previously cached for the given CRS and context, return it.</li>
 * <li>Otherwise:
 * <ol>
 * <li>Invoke {@link #createOperationFinder(CoordinateOperationAuthorityFactory, CoordinateOperationContext)}.</li>
 * <li>Invoke {@link CoordinateOperationFinder#createOperation(CoordinateReferenceSystem, CoordinateReferenceSystem)}
 * on the object returned by the previous step.</li>
 * <li>Cache the result, then return it.</li>
 * </ol>
 * </li>
 * </ul>
 *
 * Subclasses can override {@link #createOperationFinder createOperationFinder(…)} if they need more control on
 * the way coordinate operations are inferred.
 *
 * @param sourceCRS input coordinate reference system.
 * @param targetCRS output coordinate reference system.
 * @param context area of interest and desired accuracy, or {@code null}.
 * @return a coordinate operation from {@code sourceCRS} to {@code targetCRS}.
 * @throws OperationNotFoundException if no operation path was found from {@code sourceCRS} to {@code targetCRS}.
 * @throws FactoryException if the operation creation failed for some other reason.
 *
 * @see CoordinateOperationFinder
 *
 * @since 0.7
 */

// We currently do not cache the operation when the result may depend on the context (see 'this.cache' javadoc).

/**
 * Infers operations for conversions or transformations between two coordinate reference systems.
 * If a non-null authority factory – the <cite>registry</cite> – has been specified at construction time,
 * then this method will first query that factory (<cite>late-binding</cite> approach – see class javadoc).
 * If no operation has been found in the registry or if no registry has been specified to the constructor,
 * this method inspects the given CRS and delegates the work to one or many {@code createOperationStep(…)}
 * methods (<cite>early-binding</cite> approach).
 *
 * At first, this method is invoked with the {@code sourceCRS} and {@code targetCRS} arguments given to the
 * {@link DefaultCoordinateOperationFactory#createOperation(CoordinateReferenceSystem, CoordinateReferenceSystem,
 * CoordinateOperationContext) CoordinateOperationFactory.createOperation(…)} method. But then, this method may
 * be invoked recursively by some {@code createOperationStep(…)} methods with different source or target CRS,
 * for example in order to process the {@linkplain org.apache.sis.referencing.crs.DefaultProjectedCRS#getBaseCRS()
 * base geographic CRS} of a projected CRS.
 *
 * Coordinate operations are returned in preference order: best operations for the area of interest should be first.
 * The returned list is modifiable: callers can add, remove or set elements without impact on this
 * {@code CoordinateOperationFinder} instance.
 *
 * @param sourceCRS input coordinate reference system.
 * @param targetCRS output coordinate reference system.
 * @return coordinate operations from {@code sourceCRS} to {@code targetCRS}.
 * @throws OperationNotFoundException if no operation path was found from {@code sourceCRS} to {@code targetCRS}.
 * @throws FactoryException if the operation creation failed for some other reason.
 *
 * @since 1.0
 */

/*
         * If this method is invoked recursively, verify if the requested operation is already in the cache.
         * We do not perform this verification on the first invocation because it was already verified by
         * DefaultCoordinateOperationFactory.createOperation(…). We do not block if the operation is in
         * process of being computed in another thread because of the risk of deadlock. If the operation
         * is not in the cache, store the key in our internal map for preventing infinite recursivity.
         */

// Must be a modifiable list as per this method contract.

/*
         * If the user did not specified an area of interest, use the domain of validity of the CRS.
         */

/*
         * Verify if some extension module handles this pair of CRS in a special way. For example it may
         * be the "sis-gdal" module checking if the given CRS are wrappers around Proj.4 data structure.
         */

/*
         * Verify in the EPSG dataset if the operation is explicitly defined by an authority.
         */

////////////////////////////////////////////////////////////////////////////////

////                                                                        ////

////                       Derived  →  any Single CRS                       ////

////                       any Single CRS  →  Derived                       ////

////            Geodetic  →  Geocetric, Geographic or Projected             ////

////                         Vertical  →  Vertical                          ////

////                         Temporal  →  Temporal                          ////

/**
 * Infers an operation for conversion or transformation between two coordinate reference systems.
 * If a non-null authority factory – the <cite>registry</cite> – has been specified at construction time,
 * this method will first query that factory (<cite>late-binding</cite> approach – see class javadoc).
 * If no operation has been found in the registry or if no registry has been specified to the constructor,
 * this method inspects the given CRS and delegates the work to one or many {@code createOperationStep(…)}
 * methods (<cite>early-binding</cite> approach).
 *
 * At first, this method is invoked with the {@code sourceCRS} and {@code targetCRS} arguments given to the
 * {@link DefaultCoordinateOperationFactory#createOperation(CoordinateReferenceSystem, CoordinateReferenceSystem,
 * CoordinateOperationContext) CoordinateOperationFactory.createOperation(…)} method. But then, this method may
 * be invoked recursively by some {@code createOperationStep(…)} methods with different source or target CRS,
 * for example in order to process the {@linkplain org.apache.sis.referencing.crs.DefaultProjectedCRS#getBaseCRS()
 * base geographic CRS} of a projected CRS.
 *
 * @param sourceCRS input coordinate reference system.
 * @param targetCRS output coordinate reference system.
 * @return a coordinate operation from {@code sourceCRS} to {@code targetCRS}.
 * @throws OperationNotFoundException if no operation path was found from {@code sourceCRS} to {@code targetCRS}.
 * @throws FactoryException if the operation creation failed for some other reason.
 */

/*
         * If the user did not specified an area of interest, use the domain of validity of the CRS.
         * Then verify in the EPSG dataset if the operation is explicitely defined by an authority.
         */

How to use org.apache.sis.referencing.operation.CRSPairconstructor

Best Java code snippets using org.apache.sis.referencing.operation.CRSPair.<init> (Showing top 8 results out of 315)

How to use
org.apache.sis.referencing.operation.CRSPair
constructor