Refine search
: category.getRange().getMinimum(); double maximum = nodataConfigured ? configuredNoDataValues[0] : category.getRange().getMaximum(); if (Double.isNaN(minimum) && Double.isNaN(maximum)) { NumberRange.create(minimum, maximum)); && !Double.isInfinite(configuredRange.getMinimum()) && !Double.isInfinite(configuredRange.getMaximum())) { Class targetType = categories != null && !categories.isEmpty() ? categories.get(0).getRange().getElementClass() : Double.class; final NumberRange<?> dataRange = configuredRange.castTo(targetType); List<NumberRange<?>> dataRanges = new ArrayList<>(); dataRanges.add(dataRange); List<NumberRange<?>> newDataRanges = new ArrayList<>(); for (NumberRange<?> dr : dataRanges) { NumberRange<?>[] subtracted = dr.subtract(category.getRange()); for (NumberRange<?> range : subtracted) { if (!range.isEmpty()) { newDataRanges.add(range);
/** * Parses the specified value as a NumberRange if it's in the min/max form, as a Double * otherwise * * @param val */ private Object parseNumberOrRange(String val) { if (val.contains("/")) { String[] splitted = val.split("/"); final String strStart = splitted[0]; final String strEnd = splitted[1]; if (strStart.equals(strEnd)) { return Double.parseDouble(strStart); } double start = Double.parseDouble(strStart); double end = Double.parseDouble(strEnd); return new NumberRange<Double>(Double.class, start, end); } else { return Double.parseDouble(val); } }
@Override public void marshal( Object original, HierarchicalStreamWriter writer, MarshallingContext context) { NumberRange range = (NumberRange) original; writer.startNode("min"); if (Double.isInfinite(((Number) range.getMinValue()).doubleValue())) { context.convertAnother("-inf"); } else { context.convertAnother(range.getMinValue()); } writer.endNode(); writer.startNode("max"); if (Double.isInfinite(((Number) range.getMaxValue()).doubleValue())) { context.convertAnother("inf"); } else { context.convertAnother(range.getMaxValue()); } writer.endNode(); }
/** * Guesses the size of the sample able to contain the range fully * * @param range */ static int guessSizeFromRange(NumberRange range) { double min = range.getMinimum(); double max = range.getMaximum(); double diff = max - min; if (diff <= ((int) Byte.MAX_VALUE - (int) Byte.MIN_VALUE)) { return 8; } else if (diff <= ((int) Short.MAX_VALUE - (int) Short.MIN_VALUE)) { return 16; } else if (diff <= ((double) Integer.MAX_VALUE - (double) Integer.MIN_VALUE)) { return 32; } else if (diff <= ((double) Float.MAX_VALUE - (double) Float.MIN_VALUE)) { return 32; } else { return 64; } }
if (range.contains((Number) o)) { result.add(o); if (range.intersects((NumberRange) o)) { result.add(o);
coverageDim.setName(wrappedName); coverageDim.setDimensionType(SampleDimensionType.SIGNED_16BITS); coverageDim.setRange(NumberRange.create(0d, 10000d)); new GridSampleDimension( "original", new Category[] { new Category( Vocabulary.formatInternational(VocabularyKeys.NODATA), new Color[] {new Color(0, 0, 0, 0)}, NumberRange.create(-9999, -9999)) }, null); List<Category> categories = copy.getCategories(); assertTrue(category.getName().equals(Category.NODATA.getName())); assertEquals(category.getRange().getMinimum(), noData1, DELTA); assertEquals(category.getRange().getMaximum(), noData1, DELTA);
final NumberRange<?> range = new NumberRange(value.getClass(), value, value); final Color[] colors = ColorUtilities.subarray(palette, intValue, intValue + 1); categoryList.add(new Category(name, colors, range, false)); final NumberRange<?> range = new NumberRange(classe, min, max); final Color[] colors = ColorUtilities.subarray(palette, lower, upper); categoryList.add(new Category(name, colors, range, false)); lower = upper; for (int i = categoryList.size(); --i >= 0; ) { Category category = categoryList.get(i); if (!category.isQuantitative()) { final NumberRange range = category.getRange(); final Comparable min = range.getMinValue(); final Comparable max = range.getMaxValue(); @SuppressWarnings("unchecked") final int c = min.compareTo(max); final double min = range.getMinimum(); final double max = range.getMaximum(); if (max - minimum < maximum - min) { if (max >= minimum) { minIncluded = !range.isMaxIncluded(); maxIncluded = !range.isMinIncluded(); max = ClassChanger.cast(max, classe); final NumberRange range =
/** Returns the expected range of values for the resulting image. */ protected NumberRange deriveRange(final NumberRange[] ranges, final Parameters parameters) { final NumberRange range = ranges[0]; final double min = -range.getMaximum(); final double max = -range.getMinimum(); return NumberRange.create(min, max); }
public SLDSelector(NumberRange<?> scaleRange, Filter filter) { this.scaleRange = new NumberRange( Double.class, scaleRange.getMinimum(), scaleRange.isMinIncluded(), scaleRange.getMaximum(), scaleRange.isMaxIncluded()); this.filter = filter; }
CoverageDimensionInfo dim = catalog.getFactory().createCoverageDimension(); GridSampleDimension sd = sampleDimensions[i]; String name = sd.getDescription().toString(Locale.getDefault()); dim.setName(name); final Unit uom = sd.getUnits(); dim.setDimensionType(sd.getSampleDimensionType()); double sdMin = sd.getMinimumValue(); dim.setRange(NumberRange.create(sdMin, sdMax)); final List<Category> categories = sd.getCategories(); && cat.getName().toString(Locale.ENGLISH).equalsIgnoreCase("no data")) { double min = cat.getRange().getMinimum(); double max = cat.getRange().getMaximum();
static double getCandidateNoData(GridCoverage2D gc) { // no data management final GridSampleDimension sd = (GridSampleDimension) gc.getSampleDimension(0); final List<Category> categories = sd.getCategories(); final Iterator<Category> it = categories.iterator(); Category candidate; double inNoData = Double.NaN; final String noDataName = Vocabulary.format(VocabularyKeys.NODATA); while (it.hasNext()) { candidate = (Category) it.next(); final String name = candidate.getName().toString(); if (name.equalsIgnoreCase("No Data") || name.equalsIgnoreCase(noDataName)) { inNoData = candidate.getRange().getMaximum(); } } return inNoData; } }
@Test public void testWrapCustomizationSurviveCopyConstructor() throws Exception { final GridSampleDimension sampleDim = new GridSampleDimension( "original", SampleDimensionType.REAL_64BITS, final double newMaximum = 2000d; final NumberRange<Double> range = new NumberRange<Double>(Double.class, newMinimum, newMaximum); coverageDim.setRange(range); assertEquals(newMinimum, wrappedRange.getMinimum(), DELTA); assertEquals(newMaximum, wrappedRange.getMaximum(), DELTA);
double minimum = scale.getMinimum(); double maximum = scale.getMaximum(); boolean minIncluded = scale.isMinIncluded(); boolean maxIncluded = scale.isMaxIncluded(); if (scale instanceof MeasurementRange) { try { return null; // This is allowed by this method contract. MathTransform1D tr = category.getSampleToGeophysics(); if (tr != null) try { tr = (MathTransform1D) tr.inverse(); final NumberRange range = category.getRange(); final double lower = range.getMinimum(); final double extent = range.getMaximum() - lower; minimum = (minimum / 100) * extent + lower; maximum = (maximum / 100) * extent + lower; minIncluded &= range.isMinIncluded(); maxIncluded &= range.isMaxIncluded(); upper = round(maximum, !maxIncluded); return new NumberRange(lower, true, upper, false);
for (GridSampleDimension sd : gc2d.getSampleDimensions()) { final double[] sdNoData = sd.getNoDataValues(); if (sdNoData != null) { for (double nodata : sdNoData) { if (sd.getCategories() != null) { for (Category cat : sd.getCategories()) { if (cat.getName().equals(NO_DATA)) { final NumberRange<? extends Number> catRange = cat.getRange(); if (!Double.isNaN(catRange.getMinimum())) { if (catRange.getMinimum() == catRange.getMaximum()) { noDataList.add(catRange.getMinimum()); } else { Range<Double> noData = new Range<Double>( catRange.getMinimum(), catRange.isMinIncluded(), catRange.getMaximum(), catRange.isMaxIncluded()); noDataList.add(noData);
/** * Returns a sample dimension for the current {@linkplain GridCoverageBuilder#getSampleRange * range of sample values}. */ public GridSampleDimension getSampleDimension() { if (sampleDimension == null) { NumberRange<? extends Number> range = getSampleRange(); int lower = (int) Math.floor(range.getMinimum(true)); int upper = (int) Math.ceil(range.getMaximum(false)); final Category[] categories = new Category[nodata.size() + 1]; int i = 0; for (final Map.Entry<Integer, CharSequence> entry : nodata.entrySet()) { final int sample = entry.getKey(); if (sample >= lower && sample < upper) { if (sample - lower <= upper - sample) { lower = sample + 1; } else { upper = sample; } } categories[i++] = new Category(entry.getValue(), null, sample); } range = NumberRange.create(lower, true, upper, false); categories[i] = new Category(name, null, range, true); sampleDimension = new GridSampleDimension(name, categories, units); } return sampleDimension; }
for (int i = 0; i < sd.length; i++) { writer.write("<CoverageDimension>\n"); writer.write("<name>" + sd[i].getDescription().toString() + "</name>\n"); writer.write("<interval>\n"); writer.write("<min>" + sd[i].getMinimumValue() + "</min>\n"); writer.write("<max>" + sd[i].getMaximumValue() + "</max>\n"); writer.write("</interval>\n"); final List<Category> categories = sd[i].getCategories(); for (Iterator<Category> it = sd[i].getCategories().iterator(); it.hasNext(); ) { Category cat = (Category) it.next(); if ((cat != null) && cat.getName().toString().equalsIgnoreCase("no data")) { double min = cat.getRange().getMinimum(); double max = cat.getRange().getMaximum(); writer.write("<value>" + min + "</value>\n"); if (min != max) writer.write("<value>" + max + "</value>\n");
/** Creates a {@link GridCoverage2D} for the provided {@link RenderedImage}. */ private GridCoverage2D createCoverage(String name, RenderedImage image) { Category noDataCategory = new Category( Vocabulary.formatInternational(VocabularyKeys.NODATA), new Color[] {new Color(0, 0, 0, 0)}, NumberRange.create(DEFAULT_NODATA, DEFAULT_NODATA)); Category[] categories = new Category[] {noDataCategory}; GridSampleDimension[] bands; bands = new GridSampleDimension[1]; bands[0] = new GridSampleDimension(null, categories, null); final Map<String, Object> properties = new HashMap<String, Object>(); CoverageUtilities.setNoDataProperty(properties, DEFAULT_NODATA); return this.coverageFactory.create( name, image, this.originalEnvelope, bands, null, properties); }
/** * Encode the interval range * * @param range */ private boolean setRange(NumberRange<? extends Number> range) { if (range != null && !Double.isInfinite(range.getMaximum()) && !Double.isInfinite(range.getMinimum())) { start("swe:interval"); chars(range.getMinValue() + " " + range.getMaxValue()); end("swe:interval"); return true; } return false; }
"3 or 4 band, 8 bit unsigned image, assumed to be " + "RGB or RGBA respectively and nodata value hardcoded to 255"); return (Number) nativeCellType.getSampleValueRange().getMaxValue(); final double minimumSample = sampleValueRange.getMinimum(true); final double maximumSample = sampleValueRange.getMaximum(true); if (sampleValueRange.contains((Number) Double.valueOf(lower))) { } else if (sampleValueRange.contains((Number) Double.valueOf(greater))) {
/** * Retrieves a best guess for the sample value to use for background, * inspecting the categories of the provided {@link GridCoverage2D}. * * @param coverage to use for guessing background values. * @return an array of double values to use as a background. */ public static double[] getBackgroundValues(GridCoverage2D coverage) { /* * Get the sample value to use for background. We will try to fetch this * value from one of "no data" categories. For geophysics images, it is * usually NaN. For non-geophysics images, it is usually 0. */ final GridSampleDimension[] sampleDimensions = coverage.getSampleDimensions(); final double[] background = new double[sampleDimensions.length]; for (int i=0; i<background.length; i++) { final NumberRange range = sampleDimensions[i].getBackground().getRange(); final double min = range.getMinimum(); final double max = range.getMaximum(); if (range.isMinIncluded()) { background[i] = min; } else if (range.isMaxIncluded()) { background[i] = max; } else { background[i] = 0.5 * (min + max); } } return background; }