Class WraparoundTransform
Object
FormattableObject
AbstractMathTransform
WraparoundTransform
- All Implemented Interfaces:
- Serializable,- Parameterized,- LenientComparable,- MathTransform
Enforces coordinate values in the range of a wraparound axis (typically longitude).
 For example, this transform can shift longitudes from the [0 … 360]° range to the [-180 … +180]° range.
 The destination range is centered at 0 with a minimal value of −
period/2 and a maximal value
 of period/2. For a range centered on a different value,
 a translation
 can be applied before and after the WraparoundTransform.
 Instantiation
WraparoundTransforms are not created automatically by
 CRS.findOperation(…)
 because they introduce discontinuities in coordinate transformations.
 Such discontinuities are hurtless when transforming only a cloud of points,
 but produce undesirable artifacts when transforming envelopes or geometries.
 Callers need to create WraparoundTransform instances explicitly if discontinuities are acceptable.
 Subclassing
In order to control the discontinuity problem, it may be necessary to subclassWraparoundTransform
 and override the shift(double) method. For example, a subclass may control the wraparounds in a way
 to prevent the lower corner of an envelope
 to become greater than the upper corner.
 Inverse transform
Theinverse() method can return another WraparoundTransform with the same period
 but centered on a different value, which must be specified at construction time.
 For example if this transform is converting from something to [-180 … +180]° range,
 then inverse transform is possible only if "something" has been specified
 (it may be the [0 … 360]° range, but not necessarily).- Since:
- 1.1
- See Also:
Defined in the sis-referencing module
- 
Nested Class SummaryNested classes/interfaces inherited from class AbstractMathTransformAbstractMathTransform.Inverse
- 
Field SummaryFieldsModifier and TypeFieldDescriptionfinal doublePeriod on wraparound axis, always greater than zero.final doubleCoordinate in the wraparound dimension which is at the center of the range of valid source coordinates.final intThe dimension where to apply wraparound.
- 
Constructor SummaryConstructorsModifierConstructorDescriptionprotectedWraparoundTransform(int dimension, int wraparoundDimension, double period, double sourceMedian) Creates a new transform with a wraparound behavior in the given dimension.protectedCreates a new transform with the same parameters than the given transform.
- 
Method SummaryModifier and TypeMethodDescriptionprotected intComputes a hash code value for this transform.static MathTransformcreate(int dimension, int wraparoundDimension, double period, double sourceMedian, double targetMedian) Returns a transform with a wraparound behavior in the given dimension.derivative(DirectPosition point) Gets the derivative of this transform at a point.booleanequals(Object object, ComparisonMode mode) Compares this transform with the given object for equality.Returns the parameter descriptors for this math transform.Returns the parameter values for this math transform.final intGets the dimension of input points.final intGets the dimension of output points.inverse()Returns a wraparound transform producing values in the range of source coordinate values.static MathTransformreplace(MathTransform transform, Function<? super WraparoundTransform, ? extends WraparoundTransform> replacement) Replaces allWraparoundTransforminstances in a chain of transform steps.protected doubleshift(double x) Applies the wraparound on the given coordinate value.transform(double[] srcPts, int srcOff, double[] dstPts, int dstOff, boolean derivate) Applies wraparounds on a single point and optionally computes the transform derivative at that location.voidtransform(double[] srcPts, int srcOff, double[] dstPts, int dstOff, int numPts) Transforms many positions in a list of coordinate values.voidtransform(float[] srcPts, int srcOff, float[] dstPts, int dstOff, int numPts) Transforms many positions in a list of coordinate values.protected MathTransformtryConcatenate(boolean applyOtherFirst, MathTransform other, MathTransformFactory factory) Concatenates in an optimized way this math transform with the given one, if possible.Methods inherited from class AbstractMathTransformequals, formatTo, getContextualParameters, getDomain, hashCode, isIdentity, transform, transform, transformMethods inherited from class FormattableObjectprint, toString, toString, toWKTMethods inherited from class Objectclone, finalize, getClass, notify, notifyAll, wait, wait, waitMethods inherited from interface MathTransformtoWKT
- 
Field Details- 
wraparoundDimensionpublic final int wraparoundDimensionThe dimension where to apply wraparound.
- 
periodpublic final double periodPeriod on wraparound axis, always greater than zero. This is 360° for the longitude axis. Coordinates will be normalized in the [−period/2 … +period/2] range.
- 
sourceMedianpublic final double sourceMedianCoordinate in the wraparound dimension which is at the center of the range of valid source coordinates. For example if this transform wraps coordinates from the [0 … 360]° range to the [-180 … +180]° range, thensourceMedianshould be 180° (the value at the center of [0 … 360]° range). The value may beDouble.NaNif unknown.This field is used for inverse transforms only; it has no effect on the forward transforms. If not NaN, this value is used for building the transform returned by inverse().Note: there is notargetMedianfield because the target median is fixed to 0 inWraparoundTransform. Non-zero target medians are implemented by translations applied before and afterWraparoundTransform. Because of this translation, the value of this field is related to the arguments given to thecreate(…)method bythis.sourceMeridian = sourceMeridian - targetMeridian.
 
- 
- 
Constructor Details- 
WraparoundTransformprotected WraparoundTransform(int dimension, int wraparoundDimension, double period, double sourceMedian) Creates a new transform with a wraparound behavior in the given dimension. Output values in the wraparound dimension will be in the [−p/2 … +p/2] range where p is the period (e.g. 360°).- Parameters:
- dimension- number of dimensions of source and target coordinates.
- wraparoundDimension- the dimension where to apply wraparound.
- period- period on wraparound axis.
- sourceMedian- coordinate at the center of the range of valid source coordinates, or NaN if unknown. This argument is used for inverse transforms only (ignored in forward transforms).
- See Also:
 
- 
WraparoundTransformCreates a new transform with the same parameters than the given transform. This constructor can be used by subclasses applying the same wraparound than an existing transform but with a differentshift(double)implementation.- Parameters:
- other- the other transform from which to copy the parameters.
 
 
- 
- 
Method Details- 
createpublic static MathTransform create(int dimension, int wraparoundDimension, double period, double sourceMedian, double targetMedian) Returns a transform with a wraparound behavior in the given dimension. Output values in the wraparound dimension will be in the [t−p/2 … t+p/2] range where t is the target median and p is the period (typically 360° for longitude axis).The sourceMedianargument is optional (can beDouble.NaNif unknown) and has no effect on the forward transform. This argument is used only for creating the inverse transform.Examples:- Wraparound longitudes in (φ,λ) coordinates from [-180 … +180]° range to [0 … 360]° range:
         create(2, 0, 360, 0, 180).
- Wraparound longitudes in (φ,λ,h) coordinates from unknown range to [-180 … +180]° range:
         create(3, 0, 360, Double.NaN, 0)(non-invertible).
 - Parameters:
- dimension- number of dimensions of the transform to create.
- wraparoundDimension- dimension where wraparound happens.
- period- period on wraparound axis.
- sourceMedian- coordinate at the center of the range of valid source coordinates, or NaN if unknown.
- targetMedian- coordinate at the center of the range of valid target coordinates.
- Returns:
- the wraparound transform.
 
- Wraparound longitudes in (φ,λ) coordinates from [-180 … +180]° range to [0 … 360]° range:
         
- 
replacepublic static MathTransform replace(MathTransform transform, Function<? super WraparoundTransform, ? extends WraparoundTransform> replacement) Replaces allWraparoundTransforminstances in a chain of transform steps. For each instance found in the list of transform steps, the given function is invoked with theWraparoundTransforminstance found. If that function returns a different instance, then this method creates a new chain of transforms with the same steps than the giventransform, except for theWraparoundTransformsteps that are replaced by the steps returned by thereplacementfunction.This method allows injection of a specialized type of WraparoundTransform, for example in order to override theshift(double)method with finer control of wraparound operations.- Parameters:
- transform- the transform in which to replace- WraparoundTransformsteps.
- replacement- function providing replacements for- WraparoundTransformsteps.
- Returns:
- chain of transforms with WraparoundTransformsteps replaced (if any).
 
- 
getSourceDimensionspublic final int getSourceDimensions()Gets the dimension of input points.- Specified by:
- getSourceDimensionsin interface- MathTransform
- Specified by:
- getSourceDimensionsin class- AbstractMathTransform
- Returns:
- the dimension of input points.
- See Also:
 
- 
getTargetDimensionspublic final int getTargetDimensions()Gets the dimension of output points.- Specified by:
- getTargetDimensionsin interface- MathTransform
- Specified by:
- getTargetDimensionsin class- AbstractMathTransform
- Returns:
- the dimension of output points.
- See Also:
 
- 
shiftprotected double shift(double x) Applies the wraparound on the given coordinate value. This method is invoked by default implementation of alltransform(…)methods defined in thisWraparoundTransformclass. It provides a single method to override if a different wraparound strategy is desired. The default implementation is:
 Subclasses may override this method for applying wraparound only under some conditions, in order to reduce discontinuities.return Math.IEEEremainder(x, period); - Parameters:
- x- the value on which to apply wraparound.
- Returns:
- the value after wraparound.
- See Also:
 
- 
transformApplies wraparounds on a single point and optionally computes the transform derivative at that location. The default implementation delegates toshift(double)andderivative(DirectPosition).- Specified by:
- transformin class- AbstractMathTransform
- Parameters:
- srcPts- the array containing the source coordinates (cannot be- null).
- srcOff- the offset to the point to be transformed in the source array.
- dstPts- the array into which the transformed coordinates is returned. May be the same than- srcPts. May be- nullif only the derivative matrix is desired.
- dstOff- the offset to the location of the transformed point that is stored in the destination array.
- derivate-- truefor computing the derivative, or- falseif not needed.
- Returns:
- the matrix of the transform derivative at the given source position,
         or nullif thederivateargument isfalse.
- See Also:
 
- 
transformpublic void transform(double[] srcPts, int srcOff, double[] dstPts, int dstOff, int numPts) Transforms many positions in a list of coordinate values. The default implementation delegates toshift(double)for each point.- Specified by:
- transformin interface- MathTransform
- Overrides:
- transformin class- AbstractMathTransform
- Parameters:
- srcPts- the array containing the source point coordinates.
- srcOff- the offset to the first point to be transformed in the source array.
- dstPts- the array into which the transformed point coordinates are returned. May be the same than- srcPts.
- dstOff- the offset to the location of the first transformed point that is stored in the destination array.
- numPts- the number of point objects to be transformed.
 
- 
transformpublic void transform(float[] srcPts, int srcOff, float[] dstPts, int dstOff, int numPts) Transforms many positions in a list of coordinate values. The default implementation delegates toshift(double)for each point.- Specified by:
- transformin interface- MathTransform
- Overrides:
- transformin class- AbstractMathTransform
- Parameters:
- srcPts- the array containing the source point coordinates.
- srcOff- the offset to the first point to be transformed in the source array.
- dstPts- the array into which the transformed point coordinates are returned. May be the same than- srcPts.
- dstOff- the offset to the location of the first transformed point that is stored in the destination array.
- numPts- the number of point objects to be transformed.
 
- 
derivativeGets the derivative of this transform at a point.Mathematical note: strictly speaking the derivative at (n + 0.5) ×periodwhere n is an integer should be infinite because the coordinate value jumps "instantaneously" from any value to ±period/2. However, in practice we use derivatives as linear approximations around small regions, not for calculations requiring strict mathematical values. An infinite value goes against the approximation goal. Furthermore, whether a source coordinate is an integer value or not is subject to rounding errors, which may cause unpredictable behavior if infinite values were returned.- Specified by:
- derivativein interface- MathTransform
- Overrides:
- derivativein class- AbstractMathTransform
- Parameters:
- point- the position where to evaluate the derivative (ignored in default implementation, may be- null).
- Returns:
- transform derivative (identity matrix in default implementation).
 
- 
inverseReturns a wraparound transform producing values in the range of source coordinate values. Output values in the wraparound dimension will be in the [s−p/2 … s+p/2] range where s issourceMedianand p isperiod.- Specified by:
- inversein interface- MathTransform
- Overrides:
- inversein class- AbstractMathTransform
- Returns:
- wraparound transform producing values in the range of source coordinate values.
- Throws:
- NoninvertibleTransformException- if- sourceMedianis NaN or infinite.
 
- 
tryConcatenateprotected MathTransform tryConcatenate(boolean applyOtherFirst, MathTransform other, MathTransformFactory factory) throws FactoryException Concatenates in an optimized way this math transform with the given one, if possible. If this method detects a chain of operations like below:[wraparound] ⇄ [affine] ⇄ [wraparound or something else] Then this method tries to move some dimensions of the [affine] step before or after the [wraparound] step in order to simplify (or ideally remove) the [affine] step in the middle. This move increases the chances that [affine] step is combined with other affine operations. Only dimensions that do not depend onwraparoundDimensioncan be moved.- Overrides:
- tryConcatenatein class- AbstractMathTransform
- Parameters:
- applyOtherFirst-- trueif the transformation order is- otherfollowed by- this, or- falseif the transformation order is- thisfollowed by- other.
- other- the other math transform to (pre-)concatenate with this transform.
- factory- the factory which is (indirectly) invoking this method, or- nullif none.
- Returns:
- the math transforms combined in an optimized way, or nullif no such optimization is available.
- Throws:
- FactoryException- if an error occurred while combining the transforms.
- See Also:
 
- 
getParameterDescriptorsReturns the parameter descriptors for this math transform.- Specified by:
- getParameterDescriptorsin interface- Parameterized
- Overrides:
- getParameterDescriptorsin class- AbstractMathTransform
- Returns:
- the parameter descriptors for this math transform.
- See Also:
 
- 
getParameterValuesReturns the parameter values for this math transform. The set of parameters include the number of dimensions, the wraparound dimension and the period values. The default implementation does not include the source median because that parameter has no effect on forward transforms (it is used for creating the inverse transform).- Specified by:
- getParameterValuesin interface- Parameterized
- Overrides:
- getParameterValuesin class- AbstractMathTransform
- Returns:
- the parameter values for this math transform.
- See Also:
 
- 
equalsCompares this transform with the given object for equality.- Specified by:
- equalsin interface- LenientComparable
- Overrides:
- equalsin class- AbstractMathTransform
- Parameters:
- object- the object to compare with this transform.
- mode- ignored, can be- null.
- Returns:
- trueif the given object is considered equals to this math transform.
- See Also:
 
- 
computeHashCodeprotected int computeHashCode()Computes a hash code value for this transform.- Overrides:
- computeHashCodein class- AbstractMathTransform
- Returns:
- the hash code value.
 
 
-