Add Raster reclassify, extrema, getMinValue, and getMaxValue methods

Author: jericks

doc/api/raster.rst

@@ -94,6 +94,11 @@ Properties
     `Array` of :class:`raster.Bands`
     Get an array of Bands
 
+.. attribute:: Raster.extrema
+
+    `Object` with min and max arrays with min and max values for each band
+    Get the minimum and maximum values for each band.
+
 Methods
 -------
 
@@ -119,6 +124,18 @@ Methods
 
     Get a value for each band from the Raster.
 
+.. function:: Raster.getMinimumValue(band)
+
+    :arg namd: `Number` The band
+
+    Get the minimum value for the given  band
+
+.. function:: Raster.getMaximumValue(band)
+
+    :arg namd: `Number` The band
+
+    Get the maximum value for the given  band
+
 .. function:: Raster.crop(bounds)
 
     :arg bounds: :class:`geom.Bound` The Bounds of the new Raster
@@ -135,7 +152,15 @@ Methods
 
     :arg projection: :class:`proj.Projection` The target Projection
 
-    Reproject a Raster from one Projection to anothet Projection.
+    Reproject a Raster from one Projection to another Projection.
+
+.. function:: Raster.reclassify(ranges, options)
+
+    :arg ranges: `Array` An array of object literals with required min, max, and value properties. minIncluded and maxIncluded are optional.
+
+    :arg options: `Object` An object literal with optional band and noData values.
+
+    Reclassify the values of the Raster.
 
 :class:`raster.Band`
 ====================

pom.xml

@@ -89,6 +89,11 @@
             <artifactId>gt-process-feature</artifactId>
             <version>${gt.version}</version>
         </dependency>
+        <dependency>
+            <groupId>org.geotools</groupId>
+            <artifactId>gt-process-raster</artifactId>
+            <version>${gt.version}</version>
+        </dependency>
         <dependency>
             <groupId>org.geotools</groupId>
             <artifactId>gt-epsg-hsql</artifactId>

src/main/java/org/geoscript/js/raster/Raster.java

@@ -12,11 +12,12 @@
 import org.geotools.coverage.processing.CoverageProcessor;
 import org.geotools.geometry.DirectPosition2D;
 import org.geotools.geometry.jts.ReferencedEnvelope;
+import org.geotools.process.raster.RangeLookupProcess;
+import org.jaitools.numeric.Range;
 import org.mozilla.javascript.*;
 import org.mozilla.javascript.annotations.JSConstructor;
 import org.mozilla.javascript.annotations.JSFunction;
 import org.mozilla.javascript.annotations.JSGetter;
-import org.opengis.coverage.Coverage;
 import org.opengis.coverage.SampleDimension;
 import org.opengis.geometry.DirectPosition;
 import org.opengis.geometry.Envelope;
@@ -166,6 +167,65 @@ public Raster reproject(Projection projection) {
         return new Raster(this.getParentScope(), newCoverage);
     }
 
+    @JSFunction
+    public Raster reclassify(NativeArray ranges, NativeObject options) {
+        int band = (int) options.getOrDefault("band", 0);
+        double noData  = (double) options.getOrDefault("noData",0);
+        List<Range> rangeList = new ArrayList<>();
+        int[] pixelValues = new int[ranges.size()];
+        for(int i = 0; i<ranges.size(); i++) {
+            NativeObject rangeObj = (NativeObject) ranges.get(i);
+            pixelValues[i] = getInt(rangeObj.get("value"));
+            rangeList.add(Range.create(
+                Double.parseDouble(rangeObj.get("min").toString()),
+                (boolean) rangeObj.getOrDefault("minIncluded", true),
+                Double.parseDouble(rangeObj.get("max").toString()),
+                (boolean) rangeObj.getOrDefault("maxIncluded", true)
+            ));
+        }
+        RangeLookupProcess process = new RangeLookupProcess();
+        GridCoverage2D newCoverage = process.execute(this.coverage, band, rangeList, pixelValues, noData, null);
+        return new Raster(this.getParentScope(), newCoverage);
+    }
+
+    @JSGetter
+    public NativeObject getExtrema() {
+        CoverageProcessor processor = new CoverageProcessor();
+        ParameterValueGroup params = processor.getOperation("Extrema").getParameters();
+        params.parameter("Source").setValue(coverage);
+        GridCoverage2D coverage = (GridCoverage2D) processor.doOperation(params);
+        Map<String, Object> values = new HashMap<>();
+        values.put("min", coverage.getProperty("minimum"));
+        values.put("max",coverage.getProperty("maximum"));
+        return (NativeObject) javaToJS(values, this.getParentScope());
+    }
+
+    @JSFunction
+    public Object getMinValue(int band) {
+        double minValue = this.coverage.getSampleDimension(band).getMinimumValue();
+        if (Double.isInfinite(minValue)) {
+            minValue = ((double[])this.getExtrema().get("min"))[band];
+        }
+        return minValue;
+    }
+
+    @JSFunction
+    public Object getMaxValue(int band) {
+        double maxValue = this.coverage.getSampleDimension(band).getMaximumValue();
+        if (Double.isInfinite(maxValue)) {
+            maxValue = ((double[])this.getExtrema().get("max"))[band];
+        }
+        return maxValue;
+    }
+
+    private int getInt(Object obj) {
+        if (obj instanceof Number) {
+            return ((Number)obj).intValue();
+        } else {
+            return getInt(Double.parseDouble(obj.toString()));
+        }
+    }
+
     @Override
     public String toString() {
         return this.getName();

src/test/resources/org/geoscript/js/tests/geoscript/raster/test_raster.js

@@ -114,4 +114,32 @@ exports["test: reproject a raster"] = function() {
     var reprojectedTif = tif.reproject(new proj.Projection("EPSG:3857"));
     assert.strictEqual("EPSG:4326", tif.proj.id, "Original raster should be EPSG:4326");
     assert.strictEqual("EPSG:3857", reprojectedTif.proj.id, "Original raster should be EPSG:3857");
+};
+
+exports["test: reclassify a raster"] = function() {
+    var format = new raster.Format({source: admin.raster.source});
+    var tif = format.read({});
+    var reclassifiedTif = tif.reclassify([
+        {min: -1000, max: 0, value: -1},
+        {min: 0, max: 50, value: 1},
+        {min: 50, max: 100, value: 2},
+        {min: 100, max: 2000, value: 3}
+    ], {noData: 0});
+    assert.strictEqual(-1, reclassifiedTif.getValue(new geom.Point([-175.8, 81.8]), "double")[0], "Value should be -1");
+    assert.strictEqual(-1, reclassifiedTif.getValue({x: 10, y: 20}, "double")[0], "Value should be -1");
+};
+
+exports["test: get min and max values for a raster band"] = function() {
+    var format = new raster.Format({source: admin.raster.source});
+    var tif = format.read({});
+    assert.strictEqual(49, tif.getMinValue(0));
+    assert.strictEqual(255, tif.getMaxValue(0));
+};
+
+exports["test: get extrema for all raster bands"] = function() {
+    var format = new raster.Format({source: admin.raster.source});
+    var tif = format.read({});
+    var extrema = tif.extrema
+    assert.strictEqual(49, extrema.min[0]);
+    assert.strictEqual(255, extrema.max[0]);
 };