public void readByte2Short() throws Exception {
Variable t2 = null;
assert (null != (t2 = ncfileRead.findVariable("t2")));
assert (t2.getDataType() == DataType.BYTE);
Attribute att = t2.findAttribute(CDM.SCALE_FACTOR);
assert (null != att);
assert (!att.isArray());
assert (1 == att.getLength());
assert (2 == att.getNumericValue().doubleValue());
assert (DataType.SHORT == att.getDataType());
assert (null != (t2 = dsRead.findVariable("t2")));
assert t2 instanceof VariableEnhanced;
VariableDS vs = (VariableDS) t2;
assert (vs.getDataType() == DataType.SHORT) : vs.getDataType();
assert (!vs.hasMissing());
Array A = vs.read();
assert (A.getElementType() == short.class) : A.getElementType();
Index ima = A.getIndex();
int[] shape = A.getShape();
int i, j;
for (i = 0; i < shape[0]; i++) {
for (j = 0; j < shape[1]; j++) {
assert (A.getShort(ima.set(i, j)) == (2 * (i * 10 + j) + 77));
}
}
System.out.println("**************TestStandardVar readByte2Short");
}
// 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;
}
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();
}
public void readDoubleMissing() throws Exception {
VariableDS v = null;
assert (null != (v = (VariableDS) dsRead.findVariable("m1")));
assert (v.getDataType() == DataType.DOUBLE);
Array A = v.read();
Index ima = A.getIndex();
double val = A.getFloat(ima.set(1, 1));
assert Double.isNaN(val);
assert v.isMissing(val);
// reread with useNans off
v.setUseNaNs(false);
v.createNewCache();
A = v.read();
ima = A.getIndex();
val = A.getFloat(ima.set(1, 1));
assert TestAll.closeEnough(val, -999.99) : val;
assert v.isMissing(val);
}
public void readByte() throws Exception {
Variable v = null;
assert (null != (v = ncfileRead.findVariable("t3")));
assert (v.getDataType() == DataType.BYTE);
assert (null != (v = dsRead.findVariable("t3")));
assert v instanceof VariableEnhanced;
assert v instanceof VariableDS;
VariableDS vs = (VariableDS) v;
assert (vs.getDataType() == DataType.BYTE);
Attribute att = vs.findAttribute("_FillValue");
assert (null != att);
assert (!att.isArray());
assert (1 == att.getLength());
System.out.println("_FillValue = " + att.getNumericValue().byteValue());
assert (((byte) 255) == att.getNumericValue().byteValue());
assert (DataType.BYTE == att.getDataType());
assert (vs.hasMissing());
assert (vs.hasFillValue());
assert (vs.isMissing((double) ((byte) 255)));
assert (vs.isFillValue((double) ((byte) 255)));
Array A = vs.read();
assert (A.getElementType() == byte.class) : A.getElementType();
Index ima = A.getIndex();
int[] shape = A.getShape();
int i, j;
for (i = 0; i < shape[0]; i++) {
for (j = 0; j < shape[1]; j++) {
assert (A.getFloat(ima.set(i, j)) == (i * 10 + j));
}
}
System.out.println("**************TestStandardVar ReadByte");
}
public void readShort2FloatMissing() throws Exception {
Variable v = null;
assert (null != (v = ncfileRead.findVariable("t5")));
assert (v.getDataType() == DataType.SHORT);
// standard convert with missing data
assert (null != (v = dsRead.findVariable("t5")));
assert v instanceof VariableEnhanced;
assert v instanceof VariableDS;
VariableDS vs = (VariableDS) v;
assert (vs.getDataType() == DataType.FLOAT);
assert (vs.hasMissing());
assert (vs.hasMissingValue());
double mv = 2 * (-9999) + 77;
assert (vs.isMissing((double) mv));
assert (vs.isMissingValue((double) mv));
Array A = vs.read();
Index ima = A.getIndex();
int[] shape = A.getShape();
int i, j;
assert (vs.isMissing(A.getFloat(ima.set(0, 0))));
for (i = 0; i < shape[0]; i++) {
for (j = 1; j < shape[1]; j++) {
float val = A.getFloat(ima.set(i, j));
float want = 2 * (i * 10 + j) + 77;
if (val != want) System.out.println(i + " " + j + " " + val + " " + want);
assert (val == want);
}
}
// useNaNs
vs.setUseNaNs(true);
assert (vs.getDataType() == DataType.FLOAT);
assert (vs.hasMissing());
assert (vs.hasMissingValue());
double mv2 = 2 * (-9999) + 77;
assert (vs.isMissing((double) mv2));
assert (vs.isMissingValue((double) mv2));
Array A2 = vs.read();
Index ima2 = A2.getIndex();
int[] shape2 = A2.getShape();
double mval = A2.getFloat(ima2.set(0, 0));
assert vs.isMissing(mval);
assert Double.isNaN(mval);
for (i = 0; i < shape2[0]; i++) {
for (j = 1; j < shape2[1]; j++) {
float val = A2.getFloat(ima2.set(i, j));
float want = 2 * (i * 10 + j) + 77;
if (val != want) System.out.println(i + " " + j + " " + val + " " + want);
assert (val == want) : val + " != " + want;
}
}
assert (null == vs.findAttribute(CDM.SCALE_FACTOR));
assert (null == vs.findAttribute("add_offset"));
assert (null == vs.findAttribute(CDM.MISSING_VALUE));
System.out.println("**************TestStandardVar Read readShort2FloatMissing");
}
public void readShortMissing() throws Exception {
Variable v = null;
assert (null != (v = ncfileRead.findVariable("t4")));
assert (v.getDataType() == DataType.SHORT);
// default use of missing_value
assert (null != (v = dsRead.findVariable("t4")));
assert v instanceof VariableEnhanced;
assert v instanceof VariableDS;
VariableDS vs = (VariableDS) v;
assert (vs.getDataType() == DataType.SHORT);
Attribute att = vs.findAttribute(CDM.MISSING_VALUE);
assert (null != att);
assert (!att.isArray());
assert (1 == att.getLength());
System.out.println("missing_value = " + att.getNumericValue().shortValue());
assert (((short) -9999) == att.getNumericValue().shortValue());
assert (DataType.SHORT == att.getDataType());
assert (vs.hasMissing());
assert (vs.hasMissingValue());
assert (vs.isMissing((double) ((short) -9999)));
assert (vs.isMissingValue((double) ((short) -9999)));
Array A = vs.read();
Index ima = A.getIndex();
int[] shape = A.getShape();
int i, j;
for (i = 0; i < shape[0]; i++) {
for (j = 0; j < shape[1]; j++) {
assert (A.getFloat(ima.set(i, j)) == (i * 10 + j));
}
}
// turn off missing data
vs.setMissingDataIsMissing(false);
assert (vs.getDataType() == DataType.SHORT);
assert (!vs.hasMissing());
assert (vs.hasMissingValue());
assert (!vs.isMissing((double) ((short) -9999)));
assert (vs.isMissingValue((double) ((short) -9999)));
vs.setMissingDataIsMissing(true);
assert (vs.hasMissing());
assert (vs.isMissing((double) ((short) -9999)));
System.out.println("**************TestStandardVar Read readShortMissing");
}
