/** * Tests the creation of a concatenated transfer function. */ @Test @DependsOnMethod("testLogarithmic") public void testConcatenated() { final TransferFunction f = new TransferFunction(); f.setType(TransferFunctionType.LOGARITHMIC); f.setScale(0.15); f.setOffset(-2); assertEquals("toString", "y = 0.15⋅㏒⒳ − 2", f.toString()); final MathTransform1D transform = f.getTransform(); assertInstanceOf("transform", ConcatenatedTransformDirect1D.class, transform); /* * Get back the coefficients. */ final TransferFunction b = new TransferFunction(); b.setTransform(transform); assertEquals("type", TransferFunctionType.LOGARITHMIC, b.getType()); assertEquals("base", 10, b.getBase(), STRICT); assertEquals("scale", 0.15, b.getScale(), 1E-16); assertEquals("offset", -2, b.getOffset(), 1E-16); }
/** * Adds a quantitative category for sample values ranging from {@code lower} inclusive to {@code upper} exclusive. * Sample values are converted into real values using the following linear equation: * * <blockquote><var>measure</var> = <var>sample</var> × <var>scale</var> + <var>offset</var></blockquote> * * Results of above conversion are measurements in the units specified by the {@code units} argument. * * <div class="note"><b>Implementation note:</b> * this convenience method delegates to {@link #addQuantitative(CharSequence, NumberRange, MathTransform1D, Unit)}.</div> * * @param name the category name as a {@link String} or {@link InternationalString} object. * @param lower the lower sample value, inclusive. * @param upper the upper sample value, exclusive. * @param scale the scale value which is multiplied to sample values for the category. Must be different than zero. * @param offset the offset value to add to sample values for this category. * @param units the units of measurement of values after conversion by the scale factor and offset. * @return {@code this}, for method call chaining. * @throws IllegalArgumentException if {@code lower} is not smaller than {@code upper}, * or if {@code scale} or {@code offset} are not real numbers, or if {@code scale} is zero. */ public Builder addQuantitative(CharSequence name, int lower, int upper, double scale, double offset, Unit<?> units) { final TransferFunction transferFunction = new TransferFunction(); transferFunction.setScale(scale); transferFunction.setOffset(offset); return addQuantitative(name, NumberRange.create(lower, true, upper, false), transferFunction.getTransform(), units); }
/** * Creates a logarithmic transform from the specified group of parameter values. * * @param values The group of parameter values. * @return The created math transform. * @throws ParameterNotFoundException if a required parameter was not found. */ @Override public MathTransform1D createMathTransform(MathTransformFactory factory, final ParameterValueGroup values) throws ParameterNotFoundException { final TransferFunction f = new TransferFunction(); f.setType(TransferFunctionType.LOGARITHMIC); f.setBase(Parameters.castOrWrap(values).getValue(BASE)); f.setOffset(Parameters.castOrWrap(values).getValue(OFFSET)); return f.getTransform(); } }
/** * Creates a logarithmic transform from the specified group of parameter values. * * @param values The group of parameter values. * @return The created math transform. * @throws ParameterNotFoundException if a required parameter was not found. */ @Override public MathTransform1D createMathTransform(MathTransformFactory factory, final ParameterValueGroup values) throws ParameterNotFoundException { final TransferFunction f = new TransferFunction(); f.setType(TransferFunctionType.EXPONENTIAL); f.setBase(Parameters.castOrWrap(values).getValue(BASE)); f.setScale(Parameters.castOrWrap(values).getValue(SCALE)); return f.getTransform(); } }
public void testCreateTransform() throws FactoryException { final MathTransformFactory factory = DefaultFactories.forBuildin(MathTransformFactory.class); final TransferFunction f = new TransferFunction(); f.setScale(0.15); f.setOffset(-2); MathTransform transform = f.createTransform(factory); assertInstanceOf("transform", LinearTransform.class, transform); assertMatrixEquals("transform.matrix", new Matrix2(0.15, -2, 0, 1), f.setType(TransferFunctionType.LOGARITHMIC); f.setScale(1); f.setOffset(-2); transform = f.getTransform(); assertInstanceOf("transform", LogarithmicTransform1D.class, transform); f.setType(TransferFunctionType.EXPONENTIAL); f.setScale(0.15); f.setOffset(0); transform = f.getTransform(); assertInstanceOf("transform", ExponentialTransform1D.class, transform);
assertFalse ("identity", tr.getTransform().isIdentity()); assertEquals("scale", scale, tr.getScale(), STRICT); assertEquals("offset", offset, tr.getOffset(), STRICT);
return Optional.empty(); final TransferFunction f = new TransferFunction(); try { f.setTransform(tr); } catch (IllegalArgumentException e) { throw new IllegalStateException(Resources.format(Resources.Keys.CanNotSimplifyTransferFunction_1, e));
final double Δsample = samples.getMaxDouble(isMaxIncluded) - minSample; final double scale = Δvalue / Δsample; final TransferFunction transferFunction = new TransferFunction(); transferFunction.setScale(scale); transferFunction.setOffset(minValue - scale * minSample); // TODO: use Math.fma with JDK9. return addQuantitative(name, samples, transferFunction.getTransform(), (converted instanceof MeasurementRange<?>) ? ((MeasurementRange<?>) converted).unit() : null);
/** * Tests the creation of a logarithmic transfer function. */ @Test @DependsOnMethod("testLinear") public void testLogarithmic() { final TransferFunction f = new TransferFunction(); f.setType(TransferFunctionType.LOGARITHMIC); f.setOffset(-2); assertEquals("base", 10, f.getBase(), STRICT); assertEquals("toString", "y = ㏒⒳ − 2", f.toString()); final MathTransform1D transform = f.getTransform(); assertInstanceOf("transform", LogarithmicTransform1D.class, transform); /* * Get back the coefficients. */ final TransferFunction b = new TransferFunction(); b.setTransform(transform); assertEquals("type", TransferFunctionType.LOGARITHMIC, b.getType()); assertEquals("base", 10, b.getBase(), STRICT); assertEquals("scale", 1, b.getScale(), STRICT); assertEquals("offset", -2, b.getOffset(), STRICT); }
final TransferFunction tr = new TransferFunction(); final double scale = data.getAttributeAsNumber(CDM.SCALE_FACTOR); final double offset = data.getAttributeAsNumber(CDM.ADD_OFFSET); if (!Double.isNaN(scale)) tr.setScale (scale); if (!Double.isNaN(offset)) tr.setOffset(offset); final MathTransform1D mt = tr.getTransform(); if (!mt.isIdentity()) {
/** * Tests the creation of an exponential transfer function. */ @Test @DependsOnMethod("testLinear") public void testExponential() { final TransferFunction f = new TransferFunction(); f.setType(TransferFunctionType.EXPONENTIAL); f.setScale(0.15); assertEquals("base", 10, f.getBase(), STRICT); assertEquals("toString", "y = 0.15⋅10ˣ", f.toString()); final MathTransform1D transform = f.getTransform(); assertInstanceOf("transform", ExponentialTransform1D.class, transform); /* * Get back the coefficients. */ final TransferFunction b = new TransferFunction(); b.setTransform(transform); assertEquals("type", TransferFunctionType.EXPONENTIAL, b.getType()); assertEquals("base", 10, b.getBase(), STRICT); assertEquals("scale", 0.15, b.getScale(), STRICT); assertEquals("offset", 0, b.getOffset(), STRICT); }
/** * Tests the creation of a linear transfer function. */ @Test public void testLinear() { final TransferFunction f = new TransferFunction(); assertEquals("type", TransferFunctionType.LINEAR, f.getType()); assertEquals("base", 1, f.getBase(), STRICT); assertEquals("scale", 1, f.getScale(), STRICT); assertEquals("offset", 0, f.getOffset(), STRICT); assertEquals("toString", "y = x", f.toString()); f.setScale(0.15); f.setOffset(-2); assertEquals("toString", "y = 0.15⋅x − 2", f.toString()); final MathTransform1D transform = f.getTransform(); assertInstanceOf("transform", LinearTransform.class, transform); assertMatrixEquals("transform.matrix", new Matrix2(0.15, -2, 0, 1), ((LinearTransform) transform).getMatrix(), STRICT); /* * Get back the coefficients. */ final TransferFunction b = new TransferFunction(); b.setTransform(transform); assertEquals("type", TransferFunctionType.LINEAR, b.getType()); assertEquals("base", 1, b.getBase(), STRICT); assertEquals("scale", 0.15, b.getScale(), STRICT); assertEquals("offset", -2, b.getOffset(), STRICT); }