/** * Creates a one-dimensional affine transform for the given coefficients. * Input values <var>x</var> will be converted into output values <var>y</var> using the following equation: * * <blockquote><var>y</var> = <var>x</var> ⋅ {@code scale} + {@code offset}</blockquote> * * @param scale the {@code scale} term in the linear equation. * @param offset the {@code offset} term in the linear equation. * @return the linear transform for the given scale and offset. */ public static LinearTransform linear(final double scale, final double offset) { return LinearTransform1D.create(scale, offset); }
/** * Creates a one-dimensional affine transform for the given coefficients. * Input values <var>x</var> will be converted into output values <var>y</var> using the following equation: * * <blockquote><var>y</var> = <var>x</var> ⋅ {@code scale} + {@code offset}</blockquote> * * @param scale the {@code scale} term in the linear equation. * @param offset the {@code offset} term in the linear equation. * @return the linear transform for the given scale and offset. * * @see org.apache.sis.measure.Units#converter(Number, Number) */ public static LinearTransform linear(final double scale, final double offset) { return LinearTransform1D.create(scale, offset); }
/** * Constructs a new exponential transform which include the given scale factor applied after the exponentiation. * * @param base the base to be raised to a power. * @param scale the scale value to be multiplied. * @return the math transform. */ public static MathTransform1D create(final double base, final double scale) { if (base == 0 || scale == 0) { return ConstantTransform1D.ZERO; } if (base == 1) { return LinearTransform1D.create(scale, 0); } return new ExponentialTransform1D(base, scale); }
/** * Constructs a new exponential transform which include the given scale factor applied after the exponentiation. * * @param base the base to be raised to a power. * @param scale the scale value to be multiplied. * @return the math transform. */ public static MathTransform1D create(final double base, final double scale) { if (base == 0 || scale == 0) { return ConstantTransform1D.ZERO; } if (base == 1) { return LinearTransform1D.create(scale, 0); } return new ExponentialTransform1D(base, scale); }
/** * Creates the inverse transform of this object. */ @Override public LinearTransform1D inverse() throws NoninvertibleTransformException { if (inverse == null) { /* * Note: we do not perform the following optimization, because MathTransforms.linear(…) * should never instantiate this class in the identity case. * * if (isIdentity()) { * inverse = this; * } else { ... } */ if (scale != 0) { final LinearTransform1D inverse; inverse = create(1/scale, -offset/scale); inverse.inverse = this; this.inverse = inverse; } else { inverse = super.inverse(); // Throws NoninvertibleTransformException } } return (LinearTransform1D) inverse; }
/** * Creates the inverse transform of this object. */ @Override public LinearTransform1D inverse() throws NoninvertibleTransformException { if (inverse == null) { /* * Note: we do not perform the following optimization, because MathTransforms.linear(…) * should never instantiate this class in the identity case. * * if (isIdentity()) { * inverse = this; * } else { ... } */ if (scale != 0) { final LinearTransform1D inverse; inverse = create(1/scale, -offset/scale); inverse.inverse = this; this.inverse = inverse; } else { inverse = super.inverse(); // Throws NoninvertibleTransformException } } return (LinearTransform1D) inverse; }
/** * Returns the concatenation of this transform by the given scale and offset. * This method does not check if a simplification is possible. */ private MathTransform1D concatenate(final double scale, final double offset) { final LinearTransform1D t = LinearTransform1D.create(scale, offset); return t.isIdentity() ? this : new ConcatenatedTransformDirect1D(this, t); }
/** * Returns the concatenation of this transform by the given scale and offset. * This method does not check if a simplification is possible. */ private MathTransform1D concatenate(final double scale, final double offset) { final LinearTransform1D t = LinearTransform1D.create(scale, offset); return t.isIdentity() ? this : new ConcatenatedTransformDirect1D(this, t); }
if (transform == null) { if (TransferFunctionType.LINEAR.equals(type)) { transform = LinearTransform1D.create(scale, offset); } else if (TransferFunctionType.EXPONENTIAL.equals(type)) { transform = ExponentialTransform1D.create(base, scale); if (offset != 0) { // Rarely occurs in practice. transform = MathTransforms.concatenate(transform, LinearTransform1D.create(0, offset)); LinearTransform1D.create(scale, offset));
/** * Implementation of {@link #testAffineConcatenations()} for the given base. */ private void testAffineConcatenations(final double base) throws TransformException { final MathTransform1D linear = LinearTransform1D.create(C1, C0); transform = MathTransforms.concatenate(linear, LogarithmicTransform1D.create(base, OFFSET), linear); run(ConcatenatedTransformDirect1D.class, base, OFFSET, true, true); }
/** * Implementation of {@link #testAffineConcatenations()} for the given base. */ private void testAffineConcatenations(final double base) throws TransformException { final LinearTransform1D linear = LinearTransform1D.create(C1, C0); transform = MathTransforms.concatenate(linear, ExponentialTransform1D.create(base, SCALE), linear); run(ConcatenatedTransformDirect1D.class, base, SCALE, true, true); }
/** * Implementation of {@link #testAffinePostConcatenation()} for the given base. */ private void testAffinePostConcatenation(final double base) throws TransformException { transform = MathTransforms.concatenate(LogarithmicTransform1D.create(base, OFFSET), LinearTransform1D.create(C1, C0)); run(ConcatenatedTransformDirect1D.class, base, OFFSET, false, true); }
/** * Implementation of {@link #testAffinePostConcatenation()} for the given base. */ private void testAffinePostConcatenation(final double base) throws TransformException { transform = MathTransforms.concatenate(ExponentialTransform1D.create(base, SCALE), LinearTransform1D.create(C1, C0)); run(ConcatenatedTransformDirect1D.class, base, SCALE, false, true); }
/** * Implementation of {@link #testAffinePreConcatenation()} for the given base. */ private void testAffinePreConcatenation(final double base) throws TransformException { transform = MathTransforms.concatenate(LinearTransform1D.create(C1, C0), LogarithmicTransform1D.create(base, OFFSET)); run(ConcatenatedTransformDirect1D.class, base, OFFSET, true, false); }
/** * Creates a transform which applies the given scale. * The source and target dimensions of the transform are the length of the given vector. * * @param factors the scale factors. * @return a transform applying the given scale. * * @since 1.0 */ public static LinearTransform scale(final double... factors) { ArgumentChecks.ensureNonNull("factors", factors); final LinearTransform tr; switch (factors.length) { case 0: return IdentityTransform.create(0); case 1: return LinearTransform1D.create(factors[0], 0); case 2: tr = new AffineTransform2D(factors[0], 0, 0, factors[1], 0, 0); break; default: tr = new ScaleTransform(factors); break; } return tr.isIdentity() ? IdentityTransform.create(factors.length) : tr; }
/** * Creates a transform which applies the given translation. * The source and target dimensions of the transform are the length of the given vector. * * @param vector the translation vector. * @return a transform applying the given translation. * * @since 1.0 */ public static LinearTransform translation(final double... vector) { ArgumentChecks.ensureNonNull("vector", vector); final LinearTransform tr; switch (vector.length) { case 0: return IdentityTransform.create(0); case 1: return LinearTransform1D.create(1, vector[0]); case 2: tr = new AffineTransform2D(1, 0, 0, 1, vector[0], vector[1]); break; default: tr = new TranslationTransform(vector); break; } return tr.isIdentity() ? IdentityTransform.create(vector.length) : tr; }
/** * Implementation of {@link #testAffinePreConcatenation()} for the given base. */ private void testAffinePreConcatenation(final double base) throws TransformException { transform = MathTransforms.concatenate(LinearTransform1D.create(C1, C0), ExponentialTransform1D.create(base, SCALE)); run(ExponentialTransform1D.class, base, SCALE, true, false); /* * Find back the original linear coefficients as documented in the ExponentialTransform1D class javadoc. */ final double offset = -log(SCALE) / log(base); final MathTransform1D log = LogarithmicTransform1D.create(base, offset); transform = (LinearTransform1D) MathTransforms.concatenate(transform, log); assertEquals("C1", C1, ((LinearTransform1D) transform).scale, EPS); assertEquals("C0", C0, ((LinearTransform1D) transform).offset, EPS); }