Class WraparoundTransform

All Implemented Interfaces:
Serializable, Parameterized, Lenient­Comparable, Math­Transform

public class WraparoundTransform extends AbstractMathTransform implements Serializable
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 Wraparound­Transform.

Instantiation

Wraparound­Transforms are not created automatically by CRS​.find­Operation(…) 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 Wraparound­Transform instances explicitly if discontinuities are acceptable.

Subclassing

In order to control the discontinuity problem, it may be necessary to subclass Wraparound­Transform 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

The inverse() method can return another Wraparound­Transform 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

  • Field Details

    • wraparoundDimension

      public final int wraparoundDimension
      The dimension where to apply wraparound.
    • period

      public final double period
      Period 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.
    • sourceMedian

      public final double sourceMedian
      Coordinate 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, then source­Median should be 180° (the value at the center of [0 … 360]° range). The value may be Double​.Na­N if 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 no target­Median field because the target median is fixed to 0 in Wraparound­Transform. Non-zero target medians are implemented by translations applied before and after Wraparound­Transform. Because of this translation, the value of this field is related to the arguments given to the create(…) method by this​.source­Meridian = source­Meridian - target­Meridian.
  • Constructor Details

    • WraparoundTransform

      protected 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.
      wraparound­Dimension - the dimension where to apply wraparound.
      period - period on wraparound axis.
      source­Median - 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:
    • WraparoundTransform

      protected WraparoundTransform(WraparoundTransform other)
      Creates 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 different shift(double) implementation.
      Parameters:
      other - the other transform from which to copy the parameters.
  • Method Details

    • create

      public 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 source­Median argument is optional (can be Double​.Na­N if 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​.Na­N, 0) (non-invertible).
      Parameters:
      dimension - number of dimensions of the transform to create.
      wraparound­Dimension - dimension where wraparound happens.
      period - period on wraparound axis.
      source­Median - coordinate at the center of the range of valid source coordinates, or NaN if unknown.
      target­Median - coordinate at the center of the range of valid target coordinates.
      Returns:
      the wraparound transform.
    • replace

      public static MathTransform replace(MathTransform transform, Function<? super WraparoundTransform,? extends WraparoundTransform> replacement)
      Replaces all Wraparound­Transform instances in a chain of transform steps. For each instance found in the list of transform steps, the given function is invoked with the Wraparound­Transform instance found. If that function returns a different instance, then this method creates a new chain of transforms with the same steps than the given transform, except for the Wraparound­Transform steps that are replaced by the steps returned by the replacement function.

      This method allows injection of a specialized type of Wraparound­Transform, for example in order to override the shift(double) method with finer control of wraparound operations.

      Parameters:
      transform - the transform in which to replace Wraparound­Transform steps.
      replacement - function providing replacements for Wraparound­Transform steps.
      Returns:
      chain of transforms with Wraparound­Transform steps replaced (if any).
    • getSourceDimensions

      public final int getSourceDimensions()
      Gets the dimension of input points.
      Specified by:
      get­Source­Dimensions in interface Math­Transform
      Specified by:
      get­Source­Dimensions in class Abstract­Math­Transform
      Returns:
      the dimension of input points.
      See Also:
    • getTargetDimensions

      public final int getTargetDimensions()
      Gets the dimension of output points.
      Specified by:
      get­Target­Dimensions in interface Math­Transform
      Specified by:
      get­Target­Dimensions in class Abstract­Math­Transform
      Returns:
      the dimension of output points.
      See Also:
    • shift

      protected double shift(double x)
      Applies the wraparound on the given coordinate value. This method is invoked by default implementation of all transform(…) methods defined in this Wraparound­Transform class. It provides a single method to override if a different wraparound strategy is desired. The default implementation is:
      return Math.IEEEremainder(x, period);
      Subclasses may override this method for applying wraparound only under some conditions, in order to reduce discontinuities.
      Parameters:
      x - the value on which to apply wraparound.
      Returns:
      the value after wraparound.
      See Also:
    • transform

      public Matrix 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. The default implementation delegates to shift(double) and derivative(Direct­Position).
      Specified by:
      transform in class Abstract­Math­Transform
      Parameters:
      src­Pts - the array containing the source coordinate (can not be null).
      src­Off - the offset to the point to be transformed in the source array.
      dst­Pts - the array into which the transformed coordinate is returned. May be the same than src­Pts. May be null if only the derivative matrix is desired.
      dst­Off - the offset to the location of the transformed point that is stored in the destination array.
      derivate - true for computing the derivative, or false if not needed.
      Returns:
      the matrix of the transform derivative at the given source position, or null if the derivate argument is false.
      See Also:
    • transform

      public void transform(double[] srcPts, int srcOff, double[] dstPts, int dstOff, int numPts)
      Transforms many coordinates in a list of ordinal values. The default implementation delegates to shift(double) for each point.
      Specified by:
      transform in interface Math­Transform
      Overrides:
      transform in class Abstract­Math­Transform
      Parameters:
      src­Pts - the array containing the source point coordinates.
      src­Off - the offset to the first point to be transformed in the source array.
      dst­Pts - the array into which the transformed point coordinates are returned. May be the same than src­Pts.
      dst­Off - the offset to the location of the first transformed point that is stored in the destination array.
      num­Pts - the number of point objects to be transformed.
    • transform

      public void transform(float[] srcPts, int srcOff, float[] dstPts, int dstOff, int numPts)
      Transforms many coordinates in a list of ordinal values. The default implementation delegates to shift(double) for each point.
      Specified by:
      transform in interface Math­Transform
      Overrides:
      transform in class Abstract­Math­Transform
      Parameters:
      src­Pts - the array containing the source point coordinates.
      src­Off - the offset to the first point to be transformed in the source array.
      dst­Pts - the array into which the transformed point coordinates are returned. May be the same than src­Pts.
      dst­Off - the offset to the location of the first transformed point that is stored in the destination array.
      num­Pts - the number of point objects to be transformed.
    • derivative

      public Matrix derivative(DirectPosition point)
      Gets the derivative of this transform at a point.
      Mathematical note: strictly speaking the derivative at (n + 0.5) × period where 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:
      derivative in interface Math­Transform
      Overrides:
      derivative in class Abstract­Math­Transform
      Parameters:
      point - the coordinate point where to evaluate the derivative (ignored in default implementation, may be null).
      Returns:
      transform derivative (identity matrix in default implementation).
    • inverse

      Returns 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 is source­Median and p is period.
      Specified by:
      inverse in interface Math­Transform
      Overrides:
      inverse in class Abstract­Math­Transform
      Returns:
      wraparound transform producing values in the range of source coordinate values.
      Throws:
      Noninvertible­Transform­Exception - if source­Median is NaN or infinite.
    • tryConcatenate

      protected 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 on wraparound­Dimension can be moved.
      Overrides:
      try­Concatenate in class Abstract­Math­Transform
      Parameters:
      apply­Other­First - true if the transformation order is other followed by this, or false if the transformation order is this followed by other.
      other - the other math transform to (pre-)concatenate with this transform.
      factory - the factory which is (indirectly) invoking this method, or null if none.
      Returns:
      the math transforms combined in an optimized way, or null if no such optimization is available.
      Throws:
      Factory­Exception - if an error occurred while combining the transforms.
      See Also:
    • getParameterDescriptors

      public ParameterDescriptorGroup getParameterDescriptors()
      Returns the parameter descriptors for this math transform.
      Specified by:
      get­Parameter­Descriptors in interface Parameterized
      Overrides:
      get­Parameter­Descriptors in class Abstract­Math­Transform
      Returns:
      the parameter descriptors for this math transform.
      See Also:
    • getParameterValues

      public ParameterValueGroup getParameterValues()
      Returns 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:
      get­Parameter­Values in interface Parameterized
      Overrides:
      get­Parameter­Values in class Abstract­Math­Transform
      Returns:
      the parameter values for this math transform.
      See Also:
    • equals

      public boolean equals(Object object, ComparisonMode mode)
      Compares this transform with the given object for equality.
      Specified by:
      equals in interface Lenient­Comparable
      Overrides:
      equals in class Abstract­Math­Transform
      Parameters:
      object - the object to compare with this transform.
      mode - ignored, can be null.
      Returns:
      true if the given object is considered equals to this math transform.
      See Also:
    • computeHashCode

      protected int computeHashCode()
      Computes a hash code value for this transform.
      Overrides:
      compute­Hash­Code in class Abstract­Math­Transform
      Returns:
      the hash code value.