Tabnine Logo
it.geosolutions.jaiext.piecewise
Code IndexAdd Tabnine to your IDE (free)

How to use it.geosolutions.jaiext.piecewise

Best Java code snippets using it.geosolutions.jaiext.piecewise (Showing top 20 results out of 315)

origin: geotools/geotools

  @Override
  public Position transform(Position ptSrc, Position ptDst) {
    ensureNonNull("ptSrc", ptSrc);
    if (ptDst == null) {
      ptDst = new Position();
    }
    ptDst.setOrdinatePosition(transform(ptSrc.getOrdinatePosition()));
    return ptDst;
  }
}
origin: geotools/geotools

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);
origin: geotools/geotools

    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());
origin: geotools/geotools

    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(
origin: geotools/geotools

    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());
origin: geotools/geotools

    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>(
origin: geotools/geotools

    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);
origin: geosolutions-it/jai-ext

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);
}
origin: geotools/geotools

new DefaultPiecewiseTransform1DElement(
    "natural logarithm",
    RangeFactory.create(minimum[0], maximum[0]),
new DefaultPiecewiseTransform1D<DefaultPiecewiseTransform1DElement>(
    new DefaultPiecewiseTransform1DElement[] {mainElement}, 0);
origin: geotools/geotools

    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);
origin: it.geosolutions.jaiext.piecewise/jt-piecewise

  @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;
  }
}
origin: it.geosolutions.jaiext.piecewise/jt-piecewise

@Override
public int hashCode() {
  if (hashCode >= 0)
    return hashCode;
  hashCode = 37;
  hashCode = PiecewiseUtilities.hash(defaultValue, hashCode);
  hashCode = PiecewiseUtilities.hash(hasDefaultValue, hashCode);
  hashCode = PiecewiseUtilities.hash(super.hashCode(), hashCode);
  return hashCode;
}
origin: geotools/geotools

/** 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;
}
origin: it.geosolutions.jaiext.piecewise/jt-piecewise

/**
 * 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();
}
origin: geotools/geotools

if (PiecewiseUtilities.compare(previousMax, q) != 0) {
  Range valueRange = RangeFactory.create(previousMax, true, q, false);
origin: geotools/geotools

  @Override
  public Position transform(Position ptSrc, Position ptDst)
      throws TransformationException {
    if (ptDst == null) {
      ptDst = new Position();
    }
    ptDst.setOrdinatePosition(transform(ptSrc.getOrdinatePosition()));
    return ptDst;
  }
});
origin: it.geosolutions.jaiext.piecewise/jt-piecewise

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);
}
origin: geotools/geotools

/**
 * 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);
}
origin: geotools/geotools

    DefaultPiecewiseTransform1DElement.create(
        "exponential-contrast-enhancement-transform",
        RangeFactory.create(minimum, maximum),
return new DefaultPiecewiseTransform1D<DefaultPiecewiseTransform1DElement>(
    new DefaultPiecewiseTransform1DElement[] {mainElement}, 0);
origin: geotools/geotools

    DefaultPiecewiseTransform1DElement.create(
        "logarithmic-contrast-enhancement-transform",
        RangeFactory.create(minimum, maximum),
return new DefaultPiecewiseTransform1D<DefaultPiecewiseTransform1DElement>(
    new DefaultPiecewiseTransform1DElement[] {mainElement}, 0);
it.geosolutions.jaiext.piecewise

Most used classes

  • DefaultPiecewiseTransform1D
    Convenience implementation of the PiecewiseTransform1D interface which subclass the DefaultDomain1D
  • PiecewiseUtilities
    Convenience class to group utilities methods for DomainElement1D and Domain1D implmentations.
  • Position
    Class used for indicating a position on a selected axis. Note that the position is single dimensiona
  • DefaultLinearPiecewiseTransform1DElement
    Convenience class for linear transformations that maps an interval to another interval.
  • DefaultPiecewiseTransform1DElement
    Convenience implementation of the DefaultPiecewiseTransform1DElement .
  • DefaultPassthroughPiecewiseTransform1DElement,
  • MathTransformation,
  • PiecewiseTransform1D,
  • PiecewiseTransform1DElement,
  • DefaultDomain1D,
  • DefaultDomainElement1D,
  • DomainElement1D,
  • GenericPiecewiseOpImage,
  • SingleDimensionTransformation$ConstantTransform,
  • SingleDimensionTransformation,
  • TransformationException
Tabnine Logo
  • Products

    Search for Java codeSearch for JavaScript code
  • IDE Plugins

    IntelliJ IDEAWebStormVisual StudioAndroid StudioEclipseVisual Studio CodePyCharmSublime TextPhpStormVimGoLandRubyMineEmacsJupyter NotebookJupyter LabRiderDataGripAppCode
  • Company

    About UsContact UsCareers
  • Resources

    FAQBlogTabnine AcademyTerms of usePrivacy policyJava Code IndexJavascript Code Index
Get Tabnine for your IDE now