- Add the Codota plugin to your IDE and get smart completions
private void myMethod () {Charset c =
String charsetName;Charset.forName(charsetName)
- Smart code suggestions by Tabnine
}
@Override public Position transform(Position ptSrc, Position ptDst) { ensureNonNull("ptSrc", ptSrc); if (ptDst == null) { ptDst = new Position(); } ptDst.setOrdinatePosition(transform(ptSrc.getOrdinatePosition())); return ptDst; } }
final double offset = minimum - MIN_VALUE * scale; final DefaultPiecewiseTransform1DElement mainElement = DefaultPiecewiseTransform1DElement.create( "gamma-correction-transform", RangeFactory.create(minimum, maximum), return new DefaultPiecewiseTransform1D<DefaultPiecewiseTransform1DElement>( new DefaultPiecewiseTransform1DElement[] {mainElement}, 0);
DefaultPiecewiseTransform1DElement.create( "zero", RangeFactory.create(0, 100), RangeFactory.create(0, 200)); Assert.assertTrue(e0 instanceof DefaultLinearPiecewiseTransform1DElement); ((DefaultLinearPiecewiseTransform1DElement) e0).getOutputMinimum(), e0.transform(0), 0.0); Assert.assertEquals( ((DefaultLinearPiecewiseTransform1DElement) e0).getOutputMaximum(), e0.transform(e0.getInputMaximum()), 0.0); Assert.assertEquals(0.0, ((DefaultLinearPiecewiseTransform1DElement) e0).getOffset(), 0.0); Assert.assertEquals(2.0, ((DefaultLinearPiecewiseTransform1DElement) e0).getScale(), 0.0); Assert.assertFalse(e0.isIdentity()); Assert.assertEquals(1, e0.getSourceDimensions()); Assert.assertEquals(1, e0.getTargetDimensions()); Assert.assertEquals(e0.transform(Double.POSITIVE_INFINITY), 0.0, 0.0); Assert.assertTrue(false); } catch (Exception e) { new DefaultPiecewiseTransform1D<DefaultPiecewiseTransform1DElement>( new DefaultPiecewiseTransform1DElement[] {e0}); Assert.assertEquals(0.0, transform.transform(0), 0); Assert.assertEquals(1, transform.getSourceDimensions()); Assert.assertEquals(1, transform.getTargetDimensions());
new DefaultPiecewiseTransform1DElement( "t0", RangeFactory.create(0.0, true, 1.0, true), PiecewiseUtilities.createLinearTransform1D( RangeFactory.create(0.0, true, 1.0, true), RangeFactory.create(200, 201))); Assert.assertEquals(t0.transform(0.5), 200.5, 0.0); Assert.assertTrue(t0.contains(0.5)); Assert.assertTrue(t0.contains(RangeFactory.create(0.1, 0.9))); Assert.assertFalse(t0.contains(1.5)); Assert.assertFalse(t0.contains(RangeFactory.create(0.1, 1.9))); Assert.assertTrue(t0.equals(t0)); Assert.assertEquals( t0.transform(new Position(0.5), null).getOrdinatePosition(), 200.5, 0.0); Assert.assertEquals( t0.inverse().transform(new Position(200.5), null).getOrdinatePosition(), 0.5, 0.0); DefaultPiecewiseTransform1DElement.create( "t0", RangeFactory.create(0.0, true, 1.0, true), RangeFactory.create(200, 201)); Assert.assertFalse( t0.equals( DefaultPiecewiseTransform1DElement.create( "t0", RangeFactory.create(0.0, true, 1.0, true), RangeFactory.create(200, 202)))); Assert.assertEquals(t0.transform(0.5), 200.5, 0.0); Assert.assertEquals(
new DefaultPassthroughPiecewiseTransform1DElement( "p0", RangeFactory.create(0.0, true, 1.0, true)); Assert.assertEquals(p0.getTargetDimensions(), 1); Assert.assertEquals(p0.getSourceDimensions(), 1); Assert.assertTrue(p0.isIdentity()); Assert.assertEquals(p0.inverse(), SingleDimensionTransformation.IDENTITY); Assert.assertEquals(p0.transform(0.5), 0.5, 0.0); Assert.assertEquals(p0.transform(new Position(0.5), null).getOrdinatePosition(), 0.5, 0.0); Assert.assertEquals( p0.inverse().transform(new Position(0.5), null).getOrdinatePosition(), 0.5, 0.0); final Position inDP = new Position(0.6); final Position outDP = p0.transform(inDP, null); Assert.assertTrue(outDP.getOrdinatePosition() == 0.6); new DefaultPiecewiseTransform1D<DefaultPiecewiseTransform1DElement>( new DefaultPiecewiseTransform1DElement[] {p0}, 11); Assert.assertEquals(piecewise.getApproximateDomainRange().getMin().doubleValue(), 0.0, 0.0); Assert.assertEquals(piecewise.getApproximateDomainRange().getMax().doubleValue(), 1.0, 0.0); Assert.assertEquals(piecewise.transform(0.5), 0.5, 0.0); Assert.assertEquals( piecewise.transform(new Position(0.5), null).getOrdinatePosition(), 0.5, 0.0); Assert.assertEquals(piecewise.transform(1.5), 0.0, 11.0); new DefaultPassthroughPiecewiseTransform1DElement("p1"); Assert.assertEquals(p1.getTargetDimensions(), 1); Assert.assertEquals(p1.getSourceDimensions(), 1); Assert.assertTrue(p1.isIdentity());
DefaultPiecewiseTransform1DElement.create( "zero", RangeFactory.create(Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY), Assert.assertEquals(0.0, e0.transform(0), 0.0); Assert.assertEquals(e0.transform(Double.POSITIVE_INFINITY), 0.0, 0.0); try { e0.inverse(); Assert.assertTrue(false); } catch (Exception e) { new DefaultPiecewiseTransform1D<DefaultPiecewiseTransform1DElement>( new DefaultPiecewiseTransform1DElement[] {e0}); Assert.assertEquals(0.0, transform.transform(0), 0); Assert.assertEquals(transform.transform(Double.POSITIVE_INFINITY), 0.0, 0.0); DefaultPiecewiseTransform1DElement.create( "zero", RangeFactory.create(Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY), Assert.assertEquals(0.0, e0.transform(0), 0.0); Assert.assertEquals(e0.transform(Double.POSITIVE_INFINITY), 0.0, 0.0); try { e0.inverse(); Assert.assertTrue(false); } catch (Exception e) { new DefaultPiecewiseTransform1D<DefaultPiecewiseTransform1DElement>(
DefaultPiecewiseTransform1DElement.create("zero", RangeFactory.create(0, 0), 0); final DefaultPiecewiseTransform1DElement mainElement = new DefaultPiecewiseTransform1DElement( "natural logarithm", RangeFactory.create(0, false, 255, true), new DefaultPiecewiseTransform1D<DefaultPiecewiseTransform1DElement>( new DefaultPiecewiseTransform1DElement[] {zero, mainElement}); Assert.assertEquals(0.0, transform.transform(0), 0); Assert.assertEquals(0.0, transform.transform(1), 0); Assert.assertEquals(Math.log(255.0), transform.transform(255), 0); Assert.assertEquals(Math.log(124.0), transform.transform(124), 0); Assert.assertEquals(Math.log(255.0), transform.transform(256), 0); } catch (TransformationException e) { exceptionFound = true; DefaultPiecewiseTransform1DElement.create( "no-data", RangeFactory.create(-1, -1), Double.NaN); transform = new DefaultPiecewiseTransform1D<DefaultPiecewiseTransform1DElement>( new DefaultPiecewiseTransform1DElement[] {zero, mainElement, nodata}); Assert.assertEquals(0.0, transform.transform(0), 0); Assert.assertEquals(0.0, transform.transform(1), 0); Assert.assertEquals(Math.log(255.0), transform.transform(255), 0); Assert.assertEquals(Math.log(124.0), transform.transform(124), 0);
public double transform(final double value) throws TransformationException { final T piece = findDomainElement(value); if (piece == null) { // do we have a default value? if (hasDefaultValue()) return getDefaultValue(); throw new TransformationException("Error evaluating:" + value); } return piece.transform(value); }
new DefaultPiecewiseTransform1DElement( "natural logarithm", RangeFactory.create(minimum[0], maximum[0]), new DefaultPiecewiseTransform1D<DefaultPiecewiseTransform1DElement>( new DefaultPiecewiseTransform1DElement[] {mainElement}, 0);
DefaultLinearPiecewiseTransform1DElement.create( "c1", RangeFactory.create(1, 128), RangeFactory.create(1, 255)); final DefaultPiecewiseTransform1DElement c0 = DefaultLinearPiecewiseTransform1DElement.create( "c0", RangeFactory.create(129, 255), RangeFactory.create(255, 255)); final DefaultPiecewiseTransform1DElement nodata = DefaultLinearPiecewiseTransform1DElement.create( "nodata", RangeFactory.create(0, 0), 0); final DefaultPiecewiseTransform1D<DefaultPiecewiseTransform1DElement> list = new DefaultPiecewiseTransform1D<DefaultPiecewiseTransform1DElement>( new DefaultPiecewiseTransform1DElement[] {c0, c1, nodata}); ImageWorker w = new ImageWorker(image);
@Override public int hashCode() { if (hashCode < 0) { int result = PiecewiseUtilities.deepHashCode(elements); result = PiecewiseUtilities.deepHashCode(minimums); result = PiecewiseUtilities.hash(getName(), result); hashCode = PiecewiseUtilities.hash(getApproximateDomainRange(), hashCode); } return hashCode; } }
/** Apply a Generic Piecewise operation on the underlying image. */ public ImageWorker piecewise(PiecewiseTransform1D transform, Integer bandIndex) { ParameterBlock pb = new ParameterBlock(); pb.setSource(image, 0); // The source image. pb.set(transform, 0); pb.set(bandIndex, 1); pb.set(roi, 2); pb.set(nodata, 3); if (isNoDataNeeded()) { if (transform.hasGaps()) { // We must set the new NoData value setNoData( RangeFactory.create( transform.getDefaultValue(), transform.getDefaultValue())); } } image = JAI.create("GenericPiecewise", pb, getRenderingHints()); return this; }
/** * Retrieves the scale factor for this linear {@link PiecewiseTransform1DElement}. * * @return the scale factor for this linear {@link PiecewiseTransform1DElement}. */ public double getScale() { // get the transform at this point it is linear for sure final SingleDimensionTransformation transform = (SingleDimensionTransformation) getTransform(); return transform.getScale(); }
if (PiecewiseUtilities.compare(previousMax, q) != 0) { Range valueRange = RangeFactory.create(previousMax, true, q, false);
@Override public Position transform(Position ptSrc, Position ptDst) throws TransformationException { if (ptDst == null) { ptDst = new Position(); } ptDst.setOrdinatePosition(transform(ptSrc.getOrdinatePosition())); return ptDst; } });
public double transform(final double value) throws TransformationException { final T piece = findDomainElement(value); if (piece == null) { // do we have a default value? if (hasDefaultValue()) return getDefaultValue(); throw new TransformationException("Error evaluating:" + value); } return piece.transform(value); }
/** * Return a Piecewise transform doing clamping outside the central range * * @param minimum minimum valid value of the central range * @param maximum maximum valid value of the central range * @param minValue minValue to be returned from values outside (below) the central range * @param maxValue maxValue to be returned from values outside (above) the central range * @return */ private static PiecewiseTransform1D<DefaultPiecewiseTransform1DElement> generateClampingPiecewise( double minimum, double maximum, double minValue, double maxValue) { final DefaultPiecewiseTransform1DElement zeroElement = DefaultPiecewiseTransform1DElement.create( "clamp-to-min", RangeFactory.create(0, true, minimum, false), minValue); final DefaultPiecewiseTransform1DElement mainElement = DefaultPiecewiseTransform1DElement.create( "passthrough", RangeFactory.create(minimum, maximum)); final DefaultPiecewiseTransform1DElement maxElement = DefaultPiecewiseTransform1DElement.create( "clamp-to-max", RangeFactory.create(maximum, false, Double.POSITIVE_INFINITY, true), maxValue); return new DefaultPiecewiseTransform1D<DefaultPiecewiseTransform1DElement>( new DefaultPiecewiseTransform1DElement[] {zeroElement, mainElement, maxElement}, 0); }
DefaultPiecewiseTransform1DElement.create( "exponential-contrast-enhancement-transform", RangeFactory.create(minimum, maximum), return new DefaultPiecewiseTransform1D<DefaultPiecewiseTransform1DElement>( new DefaultPiecewiseTransform1DElement[] {mainElement}, 0);
DefaultPiecewiseTransform1DElement.create( "logarithmic-contrast-enhancement-transform", RangeFactory.create(minimum, maximum), return new DefaultPiecewiseTransform1D<DefaultPiecewiseTransform1DElement>( new DefaultPiecewiseTransform1DElement[] {mainElement}, 0);