Interface IScalarAffineTransform

    • Method Detail

      • getOffset

        java.lang.Number getOffset()
        Returns:
        the offset to be added (after the source value has been multiplied with the multiplier)
      • getMultiplier

        double getMultiplier()
        Returns:
        the multiplier which source values should be multiplied with (before the offset is added)
      • targetOutOfRange

        boolean targetOutOfRange​(long srcNumericalValue,
                                 long maxAbsValue)
      • targetOutOfRange

        boolean targetOutOfRange​(double srcNumericalValue,
                                 long maxAbsValue)
      • targetValue

        long targetValue​(long srcNumericalValue)
        Parameters:
        srcNumericalValue - a numerical quantity value, expressed in the source unit
        Returns:
        the corresponding numerical quantity value, when expressed in the target unit, rounded to the closest integer that can be represented by a long
      • targetFloor

        long targetFloor​(long srcNumericalValue)
        Parameters:
        srcNumericalValue - a numerical quantity value, expressed in the source unit
        Returns:
        the floor of the corresponding numerical quantity value, when expressed in the target unit, clamped to a long
      • targetFloor

        double targetFloor​(double srcNumericalValue)
        Parameters:
        srcNumericalValue - a numerical quantity value, expressed in the source unit
        Returns:
        the floor of the corresponding numerical quantity value, when expressed in the target unit
      • targetIntFloor

        int targetIntFloor​(java.lang.Number srcNumericalValue)
        Parameters:
        srcNumericalValue - a numerical quantity value, expressed in the source unit
        Returns:
        the floor of the corresponding numerical quantity value, when expressed in the target unit, clamped to an int
      • targetNumber

        java.lang.Number targetNumber​(long srcNumericalValue)
        Parameters:
        srcNumericalValue - an exact numerical quantity value, expressed in the source unit
        Returns:
        the corresponding numerical quantity value, when expressed in the target unit, as a Long if it can exactly be represented in one, otherwise as some other Number with at least the precision of double
      • targetNumber

        java.lang.Number targetNumber​(java.lang.Number srcNumericalValue)
        Parameters:
        srcNumericalValue - an exact or inexact numerical quantity value, expressed in the source unit
        Returns:
        the corresponding numerical quantity value, when expressed in the target unit, as a Long if it can exactly be represented in one, otherwise as some other Number with at least the precision of double
      • targetValue

        double targetValue​(double srcNumericalValue)
        Parameters:
        srcNumericalValue - a numerical quantity value, expressed in the source unit
        Returns:
        the corresponding numerical quantity value, when expressed in the target unit
      • isUnity

        boolean isUnity()
        Returns:
        true iff this represents the identity transform
      • isInteger

        boolean isInteger()
        Returns:
        true iff this transform can exactly be described by an integer multiplier followed by an integer offset
      • concat

        IScalarAffineTransform concat​(IScalarAffineTransform innerTransform)
        Concatenate this transform with innerTransform, such that applying the resulting transform is equivalent to first applying innerTransform and then applying this transform on the resulting value. That is, R(v) = T(I(v)), where R(v) is the resulting transform, T(v) is this transform, and I(v) is innerTransform.

        In this snippet, v1 and v2 should be equal, apart from numerical precision, for any v.

         IScalarAffineTransform R, T = ..., I = ...;
         double v = ...;
        
         R = T.concat(I);
         double v1 = R.targetValue(v);
         double v2 = T.targetValue(I.targetValue(v));
         
        Parameters:
        innerTransform - the transform that should be applied before this transform
        Returns:
        the concatenated transform
      • invertAndConcat

        IScalarAffineTransform invertAndConcat​(IScalarAffineTransform innerTransform)
        Concatenate the inverse of this transform with innerTransform, such that applying the resulting transform is equivalent to first applying innerTransform and then applying this inverse of this transform on the resulting value. That is, R(v) = T-1(I(v)), where R(v) is the resulting transform, T-1(v) is the inverse of this transform, and I(v) is innerTransform.

        In this snippet, v1 and v2 should be equal, apart from numerical precision, for any v.

         IScalarAffineTransform R, T = ..., I = ...;
         double v = ...;
        
         R = T.invertAndConcat(I);
         double v1 = R.targetValue(v);
         double v2 = T.invert().targetValue(I.targetValue(v));
         
        Parameters:
        innerTransform - the transform that should be applied before this transform
        Returns:
        the concatenated transform