// @todo Make sure units are meters public Array getElevation(Range range) throws IOException, InvalidRangeException { List section = new ArrayList(1); section.add(range); Array a = elevVar.read(section); if (elevVarUnitsConversionFactor == 1.0) return (a); for (IndexIterator it = a.getIndexIterator(); it.hasNext(); ) { if (elevVar.getDataType() == DataType.DOUBLE) { double val = it.getDoubleNext(); it.setDoubleCurrent(val * elevVarUnitsConversionFactor); } else if (elevVar.getDataType() == DataType.FLOAT) { float val = it.getFloatNext(); it.setFloatCurrent((float) (val * elevVarUnitsConversionFactor)); } else if (elevVar.getDataType() == DataType.INT) { int val = it.getIntNext(); it.setIntCurrent((int) (val * elevVarUnitsConversionFactor)); } else if (elevVar.getDataType() == DataType.LONG) { long val = it.getLongNext(); it.setLongCurrent((long) (val * elevVarUnitsConversionFactor)); } else { throw new IllegalStateException( "Elevation variable type <" + elevVar.getDataType().toString() + "> not double, float, int, or long."); } } return (a); }
public void testEnhanceDefer() throws IOException { NetcdfDataset ncd = NetcdfDataset.openDataset( filename, EnumSet.of(NetcdfDataset.Enhance.ScaleMissing), -1, null, null); VariableDS enhancedVar = (VariableDS) ncd.findVariable("t1"); NetcdfDataset ncdefer = NetcdfDataset.openDataset( filename, EnumSet.of(NetcdfDataset.Enhance.ScaleMissingDefer), -1, null, null); VariableDS deferVar = (VariableDS) ncdefer.findVariable("t1"); Array data = enhancedVar.read(); Array dataDefer = deferVar.read(); System.out.printf("Enhanced="); NCdumpW.printArray(data); System.out.printf("%nDeferred="); NCdumpW.printArray(dataDefer); System.out.printf("%nProcessed="); CompareNetcdf2 nc = new CompareNetcdf2(new Formatter(System.out), false, false, true); assert !nc.compareData(enhancedVar.getShortName(), data, dataDefer, false); IndexIterator ii = dataDefer.getIndexIterator(); while (ii.hasNext()) { double val = deferVar.convertScaleOffsetMissing(ii.getDoubleNext()); ii.setDoubleCurrent(val); } NCdumpW.printArray(dataDefer); assert nc.compareData(enhancedVar.getShortName(), data, dataDefer, false); ncd.close(); ncdefer.close(); }
/** * Cast a dataset to this compound type. If repeat is set, the first element of each item in the * given dataset is repeated across all elements of an item. Otherwise, each item comprises a * truncated or zero-padded copy of elements from the given dataset. * * @param itemSize * @param repeat repeat first element * @param dataset */ public CompoundIntegerDataset( final int itemSize, final boolean repeat, final AbstractDataset dataset) { isize = itemSize; size = dataset.size; shape = dataset.shape.clone(); name = new String(dataset.name); odata = data = createArray(size); final int os = dataset.getElementsPerItem(); IndexIterator iter = dataset.getIterator(); if (repeat) { int i = 0; while (iter.hasNext()) { final int v = (int) dataset.getElementLongAbs(iter.index); // PRIM_TYPE // GET_ELEMENT_WITH_CAST for (int k = 0; k < isize; k++) data[i++] = v; } } else { final int kmax = Math.min(isize, os); int i = 0; while (iter.hasNext()) { for (int k = 0; k < kmax; k++) data[i + k] = (int) dataset.getElementLongAbs(iter.index + k); // GET_ELEMENT_WITH_CAST i += isize; } } }
@Override public StringDatasetBase setByBoolean(final Object obj, Dataset selection) { if (obj instanceof Dataset) { final Dataset ds = (Dataset) obj; final int length = ((Number) selection.sum()).intValue(); if (length != ds.getSize()) { throw new IllegalArgumentException( "Number of true items in selection does not match number of items in dataset"); } final IndexIterator oiter = ds.getIterator(); final BooleanIterator biter = getBooleanIterator(selection); while (biter.hasNext() && oiter.hasNext()) { data[biter.index] = ds.getStringAbs(oiter.index); // GET_ELEMENT_WITH_CAST } } else { final String dv = obj.toString(); // PRIM_TYPE // FROM_OBJECT final BooleanIterator biter = getBooleanIterator(selection); while (biter.hasNext()) { data[biter.index] = dv; } } setDirty(); return this; }
@Override public StringDatasetBase setBy1DIndex(final Object obj, final Dataset index) { if (obj instanceof Dataset) { final Dataset ds = (Dataset) obj; if (index.getSize() != ds.getSize()) { throw new IllegalArgumentException( "Number of items in index dataset does not match number of items in dataset"); } final IndexIterator oiter = ds.getIterator(); final IntegerIterator iter = new IntegerIterator(index, size); while (iter.hasNext() && oiter.hasNext()) { data[iter.index] = ds.getStringAbs(oiter.index); // GET_ELEMENT_WITH_CAST } } else { final String dv = obj.toString(); // PRIM_TYPE // FROM_OBJECT IntegerIterator iter = new IntegerIterator(index, size); while (iter.hasNext()) { data[iter.index] = dv; } } setDirty(); return this; }
@Override public StringDatasetBase setByIndexes(final Object obj, final Object... indexes) { final IntegersIterator iter = new IntegersIterator(shape, indexes); final int[] pos = iter.getPos(); if (obj instanceof Dataset) { final Dataset ds = (Dataset) obj; if (calcSize(iter.getShape()) != ds.getSize()) { throw new IllegalArgumentException( "Number of items in index datasets does not match number of items in dataset"); } final IndexIterator oiter = ds.getIterator(); while (iter.hasNext() && oiter.hasNext()) { setItem(ds.getStringAbs(oiter.index), pos); // GET_ELEMENT_WITH_CAST } } else { final String dv = obj.toString(); // PRIM_TYPE // FROM_OBJECT while (iter.hasNext()) { setItem(dv, pos); } } setDirty(); return this; }
public void testAggCoordVar2(NetcdfFile ncfile) { Variable time = ncfile.findVariable("time"); assert null != time; assert time.getShortName().equals("time"); assert time.getRank() == 1 : time.getRank(); assert time.getShape()[0] == 3; assert time.getDataType() == DataType.INT; assert time.getDimension(0) == ncfile.findDimension("time"); try { Array data = time.read(); assert (data instanceof ArrayInt); IndexIterator dataI = data.getIndexIterator(); assert dataI.getIntNext() == 0 : dataI.getIntCurrent(); assert dataI.getIntNext() == 1 : dataI.getIntCurrent(); assert dataI.getIntNext() == 2 : dataI.getIntCurrent(); } catch (IOException io) { io.printStackTrace(); assert false; } }
@Override public void setElements(AbstractDataset source, int element) { if (element < 0) element += isize; if (element < 0 || element > isize) { throw new IllegalArgumentException( String.format("Invalid choice of element: %d/%d", element, isize)); } if (elementClass() != source.elementClass()) { throw new IllegalArgumentException( "Element class of destination does not match this dataset"); } final IndexIterator it = getIterator(element); final int[] elements = ((IntegerDataset) source).data; // CLASS_TYPE // PRIM_TYPE if (source.isContiguous()) { int n = 0; while (it.hasNext()) { data[it.index] = elements[n]; n++; } } else { final IndexIterator sit = source.getIterator(); while (it.hasNext() && sit.hasNext()) { data[it.index] = elements[sit.index]; } } }
@Override public void fillDataset(Dataset result, IndexIterator iter) { IndexIterator riter = result.getIterator(); String[] rdata = ((StringDatasetBase) result).data; // PRIM_TYPE while (riter.hasNext() && iter.hasNext()) rdata[riter.index] = data[iter.index]; }
private void convertScaleOffsetUnsignedInt(IndexIterator iterIn, IndexIterator iterOut) { boolean checkMissing = useNaNs && hasMissing(); while (iterIn.hasNext()) { int valb = iterIn.getIntNext(); double val = scale * DataType.unsignedIntToLong(valb) + offset; iterOut.setDoubleNext(checkMissing && isMissing_(val) ? Double.NaN : val); } }
// get a list of station obs for this station public List getData(Station s, CancelTask cancel) throws IOException { ArrayStructure stationData = readData("ID " + s.getName(), cancel); ArrayList stationObs = new ArrayList(); IndexIterator ii = stationData.getIndexIterator(); while (ii.hasNext()) { stationObs.add(new StationObs((Station) s, (StructureData) ii.getObjectNext())); } return stationObs; }
@Override public void fillDataset(AbstractDataset result, IndexIterator iter) { IndexIterator riter = result.getIterator(); int[] rdata = ((CompoundIntegerDataset) result).data; // PRIM_TYPE while (riter.hasNext() && iter.hasNext()) { for (int i = 0; i < isize; i++) rdata[riter.index + i] = data[iter.index + i]; } }
/** * @param obj * @return dataset filled with given object */ @Override public CompoundIntegerDataset fill(final Object obj) { IndexIterator iter = getIterator(); int[] vr = toIntegerArray(obj, isize); // PRIM_TYPE // CLASS_TYPE while (iter.hasNext()) { for (int i = 0; i < isize; i++) data[iter.index + i] = vr[i]; // PRIM_TYPE } return this; }
@Override public StringDatasetBase fill(final Object obj) { String dv = obj.toString(); // PRIM_TYPE // FROM_OBJECT IndexIterator iter = getIterator(); while (iter.hasNext()) { data[iter.index] = dv; } setDirty(); return this; }
@Override public IntegerDataset real() { // CLASS_TYPE IntegerDataset rdataset = new IntegerDataset(shape); // CLASS_TYPE IndexIterator iter = getIterator(); IndexIterator riter = rdataset.getIterator(); int[] rdata = rdataset.data; // PRIM_TYPE while (iter.hasNext() && riter.hasNext()) rdata[riter.index] = data[iter.index]; return rdataset; }
private Array convertToChar(Variable newVar, Array oldData) { ArrayChar newData = (ArrayChar) Array.factory(DataType.CHAR, newVar.getShape()); Index ima = newData.getIndex(); IndexIterator ii = oldData.getIndexIterator(); while (ii.hasNext()) { String s = (String) ii.getObjectNext(); int[] c = ii.getCurrentCounter(); for (int i = 0; i < c.length; i++) ima.setDim(i, c[i]); newData.setString(ima, s); } return newData; }
@Override public CompoundIntegerDataset getSlice(final SliceIterator siter) { CompoundIntegerDataset result = new CompoundIntegerDataset(isize, siter.getSliceShape()); int[] rdata = result.data; // PRIM_TYPE IndexIterator riter = result.getIterator(); while (siter.hasNext() && riter.hasNext()) { for (int i = 0; i < isize; i++) rdata[riter.index + i] = data[siter.index + i]; } result.setName(name + ".slice"); return result; }
protected Array convertEnums(Array values) { DataType dt = DataType.getType(values.getElementType()); if (!dt.isNumeric()) System.out.println("HEY"); Array result = Array.factory(DataType.STRING, values.getShape()); IndexIterator ii = result.getIndexIterator(); values.resetLocalIterator(); while (values.hasNext()) { String sval = lookupEnumString(values.nextInt()); ii.setObjectNext(sval); } return result; }
private List<int[]> findPositions(final String value) { // PRIM_TYPE IndexIterator iter = getIterator(true); List<int[]> posns = new ArrayList<int[]>(); int[] pos = iter.getPos(); { while (iter.hasNext()) { if (data[iter.index] == value) { posns.add(pos.clone()); } } } return posns; }
/** * Get the minimum and the maximum data value of the previously read Array, skipping missing * values as defined by isMissingData(double val). * * @param a Array to get min/max values * @return both min and max value. */ public MAMath.MinMax getMinMaxSkipMissingData(Array a) { if (!hasMissingData()) return MAMath.getMinMax(a); IndexIterator iter = a.getIndexIterator(); double max = -Double.MAX_VALUE; double min = Double.MAX_VALUE; while (iter.hasNext()) { double val = iter.getDoubleNext(); if (isMissingData(val)) continue; if (val > max) max = val; if (val < min) min = val; } return new MAMath.MinMax(min, max); }
// for jon blower private Array getEnhancedArray(VariableDS vds) throws IOException { Array data = vds.read(); EnumSet<NetcdfDataset.Enhance> mode = vds.getEnhanceMode(); if (mode.contains(NetcdfDataset.Enhance.ScaleMissing)) return data; if (!mode.contains(NetcdfDataset.Enhance.ScaleMissingDefer)) throw new IllegalStateException("Must include " + NetcdfDataset.Enhance.ScaleMissingDefer); IndexIterator ii = data.getIndexIterator(); while (ii.hasNext()) { double val = vds.convertScaleOffsetMissing(ii.getDoubleNext()); ii.setDoubleCurrent(val); } return data; }
private void allocateArray(final int... nshape) { if (data == null) { throw new IllegalStateException("Data buffer in dataset is null"); } if (dataShape != null) { // see if reserved space is sufficient if (isShapeInDataShape(nshape)) { shape = nshape; size = calcSize(shape); if (Arrays.equals(shape, dataShape)) { dataShape = null; // no reserved space } return; } } final IndexIterator iter = getIterator(); // not enough room so need to expand the allocated memory if (dataShape == null) dataShape = shape.clone(); expandDataShape(nshape); dataSize = calcSize(dataShape); final int[] ndata = createArray(dataSize); // PRIM_TYPE final int[] oshape = shape; // now this object has the new dimensions so specify them correctly shape = nshape; size = calcSize(nshape); // make sure that all the data is set to NaN, minimum value or false Arrays.fill(ndata, Integer.MIN_VALUE); // CLASS_TYPE // DEFAULT_VAL // now copy the data back to the correct positions final IndexIterator niter = getSliceIterator(null, oshape, null); while (niter.hasNext() && iter.hasNext()) for (int j = 0; j < isize; j++) { ndata[niter.index + j] = data[iter.index + j]; } odata = data = ndata; // if fully expanded then reset the reserved space dimensions if (dataSize == size) { dataShape = null; } }
@Override public void copyItemsFromAxes(final int[] pos, final boolean[] axes, final Dataset dest) { String[] ddata = (String[]) dest.getBuffer(); // PRIM_TYPE SliceIterator siter = getSliceIteratorFromAxes(pos, axes); int[] sshape = squeezeShape(siter.getShape(), false); IndexIterator diter = dest.getSliceIterator(null, sshape, null); if (ddata.length < calcSize(sshape)) { throw new IllegalArgumentException("destination array is not large enough"); } while (siter.hasNext() && diter.hasNext()) ddata[diter.index] = data[siter.index]; }
@Override public StringDatasetBase getUniqueItems() { Set<String> set = new TreeSet<String>(); // CLASS_TYPE IndexIterator it = getIterator(); while (it.hasNext()) { set.add(data[it.index]); } StringDataset u = new StringDataset(set.size()); // CLASS_TYPE int i = 0; String[] udata = u.getData(); // PRIM_TYPE for (String v : set) { // CLASS_TYPE udata[i++] = v; } return u; }
/** * Cast a dataset to this class type * * @param dataset */ public StringDatasetBase(final Dataset dataset) { copyToView(dataset, this, true, false); offset = 0; stride = null; base = null; try { odata = data = createArray(size); } catch (Throwable t) { logger.error("Could not create a dataset of shape {}", Arrays.toString(shape), t); throw t; } IndexIterator iter = dataset.getIterator(); for (int i = 0; iter.hasNext(); i++) { data[i] = dataset.getStringAbs(iter.index); // GET_ELEMENT_WITH_CAST } }
@Override public CompoundIntegerDataset ipower(final Object b) { if (b instanceof AbstractDataset) { final AbstractDataset bds = (AbstractDataset) b; checkCompatibility(bds); final IndexIterator it1 = getIterator(); final IndexIterator it2 = bds.getIterator(); final int bis = bds.getElementsPerItem(); if (bis == 1) { while (it1.hasNext() && it2.hasNext()) { final int db = (int) bds.getElementLongAbs(it2.index); // PRIM_TYPE // GET_ELEMENT_WITH_CAST for (int i = 0; i < isize; i++) { final double v = Math.pow(data[it1.index + i], db); if (Double.isInfinite(v) || Double.isNaN(v)) { // INT_ZEROTEST data[it1.index + i] = 0; // INT_ZEROTEST // CLASS_TYPE } else { // INT_ZEROTEST data[it1.index + i] = (int) (long) v; // PRIM_TYPE_LONG // ADD_CAST } // INT_ZEROTEST } } } else if (bis == isize) { while (it1.hasNext() && it2.hasNext()) { for (int i = 0; i < isize; i++) { final double v = Math.pow(data[it1.index + i], bds.getElementDoubleAbs(it2.index + i)); if (Double.isInfinite(v) || Double.isNaN(v)) { // INT_ZEROTEST data[it1.index + i] = 0; // INT_ZEROTEST // CLASS_TYPE } else { // INT_ZEROTEST data[it1.index + i] = (int) (long) v; // PRIM_TYPE_LONG // ADD_CAST } // INT_ZEROTEST } } } else { throw new IllegalArgumentException( "Argument does not have same number of elements per item or is not a non-compound dataset"); } } else { final int[] vr = toIntegerArray(b, isize); // PRIM_TYPE // CLASS_TYPE final IndexIterator it1 = getIterator(); while (it1.hasNext()) { for (int i = 0; i < isize; i++) { final double v = Math.pow(data[it1.index + i], vr[i]); if (Double.isInfinite(v) || Double.isNaN(v)) { // INT_ZEROTEST data[it1.index + i] = 0; // INT_ZEROTEST // CLASS_TYPE } else { // INT_ZEROTEST data[it1.index + i] = (int) (long) v; // PRIM_TYPE_LONG // ADD_CAST } // INT_ZEROTEST } } } setDirty(); return this; }
@Override public double residual(final Object b) { double sum = 0; if (b instanceof AbstractDataset) { final AbstractDataset bds = (AbstractDataset) b; checkCompatibility(bds); final IndexIterator it1 = getIterator(); final IndexIterator it2 = bds.getIterator(); final int bis = bds.getElementsPerItem(); if (bis == 1) { double comp = 0; while (it1.hasNext() && it2.hasNext()) { final double db = bds.getElementDoubleAbs(it2.index); for (int i = 0; i < isize; i++) { final double diff = data[it1.index + i] - db; final double err = diff * diff - comp; final double temp = sum + err; comp = (temp - sum) - err; sum = temp; } } } else if (bis == isize) { double comp = 0; while (it1.hasNext() && it2.hasNext()) { for (int i = 0; i < isize; i++) { final double diff = data[it1.index + i] - bds.getElementDoubleAbs(it2.index + i); final double err = diff * diff - comp; final double temp = sum + err; comp = (temp - sum) - err; sum = temp; } } } else { throw new IllegalArgumentException( "Argument does not have same number of elements per item or is not a non-compound dataset"); } } else { final double[] vr = toDoubleArray(b, isize); final IndexIterator it1 = getIterator(); double comp = 0; while (it1.hasNext()) { for (int i = 0; i < isize; i++) { final double diff = data[it1.index + i] - vr[i]; final double err = diff * diff - comp; final double temp = sum + err; comp = (temp - sum) - err; sum = temp; } } } return sum; }
@Override public boolean equals(Object obj) { if (!super.equals(obj)) { return false; } if (getRank() == 0) // already true for scalar dataset return true; CompoundIntegerDataset other = (CompoundIntegerDataset) obj; IndexIterator it = getIterator(); while (it.hasNext()) { for (int j = 0; j < isize; j++) { if (data[it.index + j] != other.data[it.index + j]) return false; } } return true; }
@Override public boolean equals(Object obj) { if (!super.equals(obj)) { return false; } if (getRank() == 0) // already true for zero-rank dataset return true; StringDatasetBase other = (StringDatasetBase) obj; IndexIterator iter = getIterator(); IndexIterator oiter = other.getIterator(); while (iter.hasNext() && oiter.hasNext()) { if (!data[iter.index].equals(other.data[oiter.index])) // OBJECT_UNEQUAL return false; } return true; }
private void readOneRadial(Cinrad2Record r, int datatype, Range gateRange, IndexIterator ii) throws IOException { if (r == null) { for (int i = gateRange.first(); i <= gateRange.last(); i += gateRange.stride()) ii.setByteNext(Cinrad2Record.MISSING_DATA); return; } r.readData(volScan.raf, datatype, gateRange, ii); }