use of org.flyte.api.v1.Variable in project imageio-ext by geosolutions-it.
the class NetCDFUtilities method isVariableAccepted.
/**
* NetCDF files may contains a wide set of variables. Some of them are
* unuseful for our purposes. The method returns {@code true} if the
* specified variable is accepted.
*/
public static boolean isVariableAccepted(final Variable var, final CheckType checkType) {
if (var instanceof CoordinateAxis1D) {
return false;
} else if (checkType == CheckType.NOSCALARS) {
List<Dimension> dimensions = var.getDimensions();
if (dimensions.size() < 2) {
return false;
}
DataType dataType = var.getDataType();
if (dataType == DataType.CHAR) {
return false;
}
return isVariableAccepted(var.getName(), CheckType.NONE);
} else if (checkType == CheckType.ONLYGEOGRIDS) {
List<Dimension> dimensions = var.getDimensions();
if (dimensions.size() < 2) {
return false;
}
for (Dimension dimension : dimensions) {
String dimName = dimension.getName();
// check the dimension to be defined
Group group = dimension.getGroup();
Variable dimVariable = group.findVariable(dimName);
if (dimVariable == null) {
return false;
}
if (dimVariable instanceof CoordinateAxis1D) {
CoordinateAxis1D axis = (CoordinateAxis1D) dimVariable;
AxisType axisType = axis.getAxisType();
if (axisType == null) {
return false;
}
}
}
DataType dataType = var.getDataType();
if (dataType == DataType.CHAR) {
return false;
}
return isVariableAccepted(var.getName(), CheckType.NONE);
} else
return isVariableAccepted(var.getName(), checkType);
}
use of org.flyte.api.v1.Variable in project imageio-ext by geosolutions-it.
the class INGVConverter method run.
private void run(String fileNameIn, String fileNameOut) {
try {
final File fileIn = new File(fileNameIn);
final NetcdfFile ncFileIn = NetcdfFile.open(fileNameIn);
final File fileOut = new File(fileNameOut);
// keep original name
final File outputFile = File.createTempFile(fileIn.getName(), ".tmp");
final NetcdfFileWriteable ncFileOut = NetcdfFileWriteable.createNew(outputFile.getAbsolutePath());
boolean hasDepth = false;
// input dimensions
String timeName = "time_counter";
Dimension timeOriginalDim = ncFileIn.findDimension(timeName);
if (timeOriginalDim == null) {
timeOriginalDim = ncFileIn.findDimension("time");
timeName = "time";
}
final Dimension yDim = ncFileIn.findDimension("y");
final Dimension xDim = ncFileIn.findDimension("x");
// input VARIABLES
final Variable timeOriginalVar = ncFileIn.findVariable(timeName);
final Array timeOriginalData = timeOriginalVar.read();
final DataType timeDataType = timeOriginalVar.getDataType();
final Variable navLat = ncFileIn.findVariable(NAV_LAT);
final DataType navLatDataType = navLat.getDataType();
final Variable navLon = ncFileIn.findVariable(NAV_LON);
final DataType navLonDataType = navLon.getDataType();
final int nLat = yDim.getLength();
final int nLon = xDim.getLength();
final int nTimes = timeOriginalDim.getLength();
final Array latOriginalData = navLat.read("0:" + (nLat - 1) + ":1, 0:0:1").reduce();
final Array lonOriginalData = navLon.read("0:0:1, 0:" + (nLon - 1) + ":1").reduce();
// //
//
// Depth related vars
//
// //
Array depthOriginalData = null;
DataType depthDataType = null;
int nDepths = 0;
Array depthDestData = null;
Dimension depthDim = null;
String depthName = "depth";
Variable depthOriginalVar = null;
int dName = 0;
while (depthOriginalVar == null) {
if (dName == depthNames.length)
break;
String name = depthNames[dName++];
// Depth
depthOriginalVar = ncFileIn.findVariable(name);
}
if (depthOriginalVar != null) {
depthName = depthNames[dName - 1];
nDepths = depthOriginalVar.getDimension(0).getLength();
depthOriginalData = depthOriginalVar.read();
hasDepth = true;
}
Dimension timeDim = ncFileOut.addDimension("time", nTimes);
Dimension latDim = ncFileOut.addDimension(NetCDFUtilities.LAT, nLat);
Dimension lonDim = ncFileOut.addDimension(NetCDFUtilities.LON, nLon);
if (hasDepth)
depthDim = ncFileOut.addDimension(NetCDFUtilities.DEPTH, nDepths);
// writing file
NetCDFConverterUtilities.copyGlobalAttributes(ncFileOut, ncFileIn.getGlobalAttributes());
// //
//
// Time requires a special Management
//
// //
// time Variable
Variable timeVar = ncFileOut.addVariable(NetCDFUtilities.TIME, timeDataType, new Dimension[] { timeDim });
NetCDFConverterUtilities.setVariableAttributes(timeOriginalVar, ncFileOut, NetCDFUtilities.TIME);
// Dimensions
ncFileOut.addVariable(NetCDFUtilities.LAT, navLatDataType, new Dimension[] { latDim });
NetCDFConverterUtilities.setVariableAttributes(navLat, ncFileOut, NetCDFUtilities.LAT);
ncFileOut.addVariable(NetCDFUtilities.LON, navLonDataType, new Dimension[] { lonDim });
NetCDFConverterUtilities.setVariableAttributes(navLon, ncFileOut, NetCDFUtilities.LON);
Array lat1Data = NetCDFConverterUtilities.getArray(nLat, navLatDataType);
NetCDFConverterUtilities.setData1D(latOriginalData, lat1Data, navLatDataType, nLat, true);
// lon Variable
Array lon1Data = NetCDFConverterUtilities.getArray(nLon, navLonDataType);
NetCDFConverterUtilities.setData1D(lonOriginalData, lon1Data, navLonDataType, nLon, false);
if (hasDepth) {
depthDataType = depthOriginalVar.getDataType();
ncFileOut.addVariable(NetCDFUtilities.DEPTH, depthDataType, new Dimension[] { depthDim });
NetCDFConverterUtilities.setVariableAttributes(depthOriginalVar, ncFileOut, NetCDFUtilities.DEPTH);
}
if (hasDepth) {
// depth level Variable
depthDestData = NetCDFConverterUtilities.getArray(nDepths, depthDataType);
NetCDFConverterUtilities.setData1D(depthOriginalData, depthDestData, depthDataType, nDepths, false);
}
// {} Variables
final ArrayList<String> variables = new ArrayList<String>(5);
final HashMap<String, String> updatingValidRange = new HashMap<String, String>(5);
final HashMap<String, String> updatingFilLValue = new HashMap<String, String>(5);
int numVars = 0;
for (int i = 0; i < NUMVARS; i++) {
String varName = (String) VARIABLES.get(i);
Variable var = ncFileIn.findVariable(varName);
if (var != null) {
variables.add(varName);
boolean hasLocalDepth = NetCDFConverterUtilities.hasThisDimension(var, depthName);
if (hasDepth && hasLocalDepth)
ncFileOut.addVariable(varName, var.getDataType(), new Dimension[] { timeDim, depthDim, latDim, lonDim });
else
ncFileOut.addVariable(varName, var.getDataType(), new Dimension[] { timeDim, latDim, lonDim });
// //
//
// Check for updating valid range
//
// //
boolean hasMinMax = false;
Attribute validMax = var.findAttribute(NetCDFUtilities.DatasetAttribs.VALID_MAX);
Attribute validMin = var.findAttribute(NetCDFUtilities.DatasetAttribs.VALID_MIN);
Attribute fillValue = var.findAttribute(NetCDFUtilities.DatasetAttribs.FILL_VALUE);
boolean hasMissingValue = false;
boolean hasFillValue = true;
if (fillValue == null) {
hasFillValue = false;
fillValue = var.findAttribute(NetCDFUtilities.DatasetAttribs.MISSING_VALUE);
if (fillValue != null)
hasMissingValue = true;
}
Attribute validRange = var.findAttribute(NetCDFUtilities.DatasetAttribs.VALID_RANGE);
boolean hasValidRange = false;
boolean rewriteAttribute = false;
if (validMin != null && validMax != null && fillValue != null) {
rewriteAttribute = !NetCDFConverterUtilities.isFillValueOutsideValidRange(validMax, validMin, fillValue, var.getDataType());
hasMinMax = true;
} else if (validRange != null && fillValue != null) {
rewriteAttribute = !NetCDFConverterUtilities.isFillValueOutsideValidRange(validRange, fillValue, var.getDataType());
hasValidRange = true;
} else {
rewriteAttribute = true;
}
if (rewriteAttribute) {
updatingValidRange.put(varName, "");
DataType varDatatype = var.getDataType();
Array range = NetCDFConverterUtilities.getRangeArray(varDatatype);
ncFileOut.addVariableAttribute(varName, NetCDFUtilities.DatasetAttribs.VALID_RANGE, range);
if (hasMissingValue && !hasFillValue) {
updatingFilLValue.put(varName, "");
Number fillVal = NetCDFConverterUtilities.getNumber(varDatatype);
ncFileOut.addVariableAttribute(varName, NetCDFUtilities.DatasetAttribs.FILL_VALUE, fillVal);
}
}
String[] exceptions = null;
if (hasMinMax) {
if (hasMissingValue)
exceptions = new String[] { NetCDFUtilities.DatasetAttribs.VALID_MAX, NetCDFUtilities.DatasetAttribs.VALID_MIN, NetCDFUtilities.DatasetAttribs.MISSING_VALUE };
else
exceptions = new String[] { NetCDFUtilities.DatasetAttribs.VALID_MAX, NetCDFUtilities.DatasetAttribs.VALID_MIN };
} else if (hasValidRange) {
if (hasMissingValue)
exceptions = new String[] { NetCDFUtilities.DatasetAttribs.VALID_RANGE, NetCDFUtilities.DatasetAttribs.MISSING_VALUE };
else
exceptions = new String[] { NetCDFUtilities.DatasetAttribs.VALID_RANGE };
} else if (hasMissingValue)
exceptions = new String[] { NetCDFUtilities.DatasetAttribs.MISSING_VALUE };
NetCDFConverterUtilities.setVariableAttributes(var, ncFileOut, exceptions);
numVars++;
}
}
// writing bin data ...
ncFileOut.create();
Array timeData = NetCDFConverterUtilities.getArray(nTimes, timeDataType);
NetCDFConverterUtilities.setData1D(timeOriginalData, timeData, timeDataType, nTimes, false);
ncFileOut.write("time", timeData);
timeVar = ncFileOut.findVariable("time");
timeDim.addCoordinateVariable(timeVar);
ncFileOut.write(NetCDFUtilities.LAT, lat1Data);
ncFileOut.write(NetCDFUtilities.LON, lon1Data);
if (hasDepth) {
Variable depthVar = ncFileOut.findVariable("depth");
depthDim.addCoordinateVariable(depthVar);
ncFileOut.write(NetCDFUtilities.DEPTH, depthDestData);
}
for (int i = 0; i < numVars; i++) {
String varName = (String) variables.get(i);
Variable var = ncFileIn.findVariable(varName);
final boolean hasLocalDepth = NetCDFConverterUtilities.hasThisDimension(var, depthName);
Array originalVarArray = var.read();
DataType varDataType = var.getDataType();
Array destArray = null;
int[] dimensions = null;
final boolean setDepth = hasDepth && hasLocalDepth;
if (setDepth) {
dimensions = new int[] { timeDim.getLength(), depthDim.getLength(), latDim.getLength(), lonDim.getLength() };
} else {
dimensions = new int[] { timeDim.getLength(), latDim.getLength(), lonDim.getLength() };
}
destArray = NetCDFConverterUtilities.getArray(dimensions, varDataType);
boolean findNewRange = updatingValidRange.containsKey(varName);
boolean updateFillValue = updatingFilLValue.containsKey(varName);
final int[] loopLengths;
if (setDepth)
loopLengths = new int[] { nTimes, nDepths, nLat, nLon };
else
loopLengths = new int[] { nTimes, nLat, nLon };
NetCDFConverterUtilities.writeData(ncFileOut, varName, var, originalVarArray, destArray, findNewRange, updateFillValue, loopLengths, true);
}
ncFileOut.close();
outputFile.renameTo(fileOut);
} catch (Exception e) {
// something bad happened
if (NetCDFConverterUtilities.LOGGER.isLoggable(Level.INFO))
NetCDFConverterUtilities.LOGGER.log(Level.INFO, e.getLocalizedMessage(), e);
}
}
use of org.flyte.api.v1.Variable in project imageio-ext by geosolutions-it.
the class MercatorOceanConverter method run.
private void run(String fileNameIn, String fileNameOut) {
try {
final File fileIn = new File(fileNameIn);
final NetcdfFile ncFileIn = NetcdfFile.open(fileNameIn);
final File fileOut = new File(fileNameOut);
// keep original name
final File outputFile = File.createTempFile(fileIn.getName(), ".tmp");
final NetcdfFileWriteable ncFileOut = NetcdfFileWriteable.createNew(outputFile.getAbsolutePath());
// input dimensions
final Dimension latOriginalDim = ncFileIn.findDimension(NetCDFUtilities.LATITUDE);
final Dimension lonOriginalDim = ncFileIn.findDimension(NetCDFUtilities.LONGITUDE);
// input VARIABLES
// Variable time_0 = ncFileIn.findVariable("time");
// Array time_0_Data = time_0.read();
// Index time_0_Index = time_0_Data.getIndex();
final Variable lonOriginalVar = ncFileIn.findVariable(NetCDFUtilities.LONGITUDE);
final int nLon = lonOriginalDim.getLength();
final Variable latOriginalVar = ncFileIn.findVariable(NetCDFUtilities.LATITUDE);
final int nLat = latOriginalDim.getLength();
final Array latOriginalData = latOriginalVar.read();
final Index latOriginalIndex = latOriginalData.getIndex();
final Array lonOriginalData = lonOriginalVar.read();
final Index lonOriginalIndex = lonOriginalData.getIndex();
final Variable depthOriginalVar = ncFileIn.findVariable(// Depth
NetCDFUtilities.DEPTH);
final int nLevels = depthOriginalVar.getDimension(0).getLength();
final Array depthOriginalData = depthOriginalVar.read();
// Dimension timeDim = ncFileOut.addDimension("time",
// timeDim0.getLength());
Dimension latDim = ncFileOut.addDimension(NetCDFUtilities.LAT, nLat);
Dimension lonDim = ncFileOut.addDimension(NetCDFUtilities.LON, nLon);
Dimension depthDim = ncFileOut.addDimension(NetCDFUtilities.DEPTH, nLevels);
Dimension timeDim = ncFileOut.addDimension(NetCDFUtilities.TIME, 1);
// writing file
computeMatrixExtremes(latOriginalData, lonOriginalData, nLon, nLat, latOriginalIndex, lonOriginalIndex);
NetCDFConverterUtilities.copyGlobalAttributes(ncFileOut, ncFileIn.getGlobalAttributes());
// //
//
// Time requires a special Management
//
// //
// time Variable
Variable timeVar = ncFileOut.addVariable(NetCDFUtilities.TIME, DataType.FLOAT, new Dimension[] { timeDim });
Attribute referenceTime = ncFileIn.findGlobalAttribute(TIME_ORIGIN);
Attribute forecastDate = ncFileIn.findGlobalAttribute(FORECAST_DAY);
int numDay = 0;
if (referenceTime != null && forecastDate != null) {
numDay = setTime(ncFileOut, referenceTime, forecastDate);
}
// final float referenceTime = setTimeVariableAttributes(timeVar,
// ncFileOut);
// lat Variable
ArrayFloat latDestData = new ArrayFloat(new int[] { latOriginalDim.getLength() });
Index latDestIndex = latDestData.getIndex();
ncFileOut.addVariable(NetCDFUtilities.LAT, DataType.FLOAT, new Dimension[] { latDim });
// NOTE: A Strange BUG (I guess)
// when you copy attributes from old vars to new vars, it overwrite
// coordvars!!!
ncFileOut.addVariableAttribute(NetCDFUtilities.LAT, "long_name", NetCDFUtilities.LATITUDE);
ncFileOut.addVariableAttribute(NetCDFUtilities.LAT, UNITS, latOriginalVar.getUnitsString());
// new String[] { "long_name", UNITS, "step" , "axis"});
for (int yPos = 0; yPos < latOriginalDim.getLength(); yPos++) {
latDestData.setFloat(latDestIndex.set(yPos), new Float(this.ymax - (new Float(yPos).floatValue() * this.periodY)).floatValue());
}
// lon Variable
ArrayFloat lonDestData = new ArrayFloat(new int[] { lonOriginalDim.getLength() });
Index lonDestIndex = lonDestData.getIndex();
ncFileOut.addVariable(NetCDFUtilities.LON, DataType.FLOAT, new Dimension[] { lonDim });
ncFileOut.addVariableAttribute(NetCDFUtilities.LON, "long_name", NetCDFUtilities.LONGITUDE);
ncFileOut.addVariableAttribute(NetCDFUtilities.LON, UNITS, lonOriginalVar.getUnitsString());
// new String[] { "long_name", UNITS, "step", "axis"});
for (int xPos = 0; xPos < lonOriginalDim.getLength(); xPos++) {
lonDestData.setFloat(lonDestIndex.set(xPos), new Float(this.xmin + (new Float(xPos).floatValue() * this.periodX)).floatValue());
}
// depth level Variable
ArrayFloat depthDestData = new ArrayFloat(new int[] { depthDim.getLength() });
Index depthDestIndex = depthDestData.getIndex();
ncFileOut.addVariable(NetCDFUtilities.DEPTH, DataType.FLOAT, new Dimension[] { depthDim });
ncFileOut.addVariableAttribute(NetCDFUtilities.DEPTH, "long_name", NetCDFUtilities.DEPTH);
ncFileOut.addVariableAttribute(NetCDFUtilities.DEPTH, UNITS, depthOriginalVar.getUnitsString());
final Attribute positiveAttrib = depthOriginalVar.findAttribute("positive");
String positiveValue = "down";
if (positiveAttrib != null)
positiveValue = positiveAttrib.getStringValue();
ncFileOut.addVariableAttribute(NetCDFUtilities.DEPTH, "positive", positiveValue);
for (int wPos = 0; wPos < depthDim.getLength(); wPos++) {
depthDestData.setFloat(depthDestIndex.set(wPos), depthOriginalData.getFloat(depthDestIndex));
}
int numVars = 0;
final ArrayList<String> variables = new ArrayList<String>(5);
// {} Variables
for (int i = 0; i < NUMVARS; i++) {
String varName = (String) VARIABLES.get(i);
Variable var = ncFileIn.findVariable(varName);
if (var != null) {
variables.add(varName);
boolean hasLocalDepth = NetCDFConverterUtilities.hasThisDimension(var, "depth");
if (hasLocalDepth)
ncFileOut.addVariable(varName, var.getDataType(), new Dimension[] { timeDim, depthDim, latDim, lonDim });
else
ncFileOut.addVariable(varName, var.getDataType(), new Dimension[] { timeDim, latDim, lonDim });
NetCDFConverterUtilities.setVariableAttributes(var, ncFileOut, new String[] { "positions" });
numVars++;
}
}
// writing bin data ...
ncFileOut.create();
ArrayFloat timeData = new ArrayFloat(new int[] { timeDim.getLength() });
Index timeIndex = timeData.getIndex();
timeData.setFloat(timeIndex.set(0), numDay);
ncFileOut.write(NetCDFUtilities.TIME, timeData);
timeDim.addCoordinateVariable(timeVar);
Variable latitudeVar = ncFileOut.findVariable(NetCDFUtilities.LAT);
latDim.addCoordinateVariable(latitudeVar);
ncFileOut.write(NetCDFUtilities.LAT, latDestData);
Variable longitudeVar = ncFileOut.findVariable(NetCDFUtilities.LON);
lonDim.addCoordinateVariable(longitudeVar);
ncFileOut.write(NetCDFUtilities.LON, lonDestData);
Variable depthVar = ncFileOut.findVariable(NetCDFUtilities.DEPTH);
depthDim.addCoordinateVariable(depthVar);
ncFileOut.write(NetCDFUtilities.DEPTH, depthDestData);
for (int i = 0; i < numVars; i++) {
final String varName = (String) variables.get(i);
final Variable var = ncFileIn.findVariable(varName);
final boolean hasLocalDepth = NetCDFConverterUtilities.hasThisDimension(var, "depth");
final Array originalData = var.read();
Index varIndex = originalData.getIndex();
final DataType varDataType = var.getDataType();
final Attribute fv = var.findAttribute("_FillValue");
float fillValue = Float.NaN;
if (fv != null) {
fillValue = (fv.getNumericValue()).floatValue();
}
Array destArray = null;
int[] dimensions = null;
if (hasLocalDepth) {
dimensions = new int[] { timeDim.getLength(), depthDim.getLength(), nLat, nLon };
} else {
dimensions = new int[] { timeDim.getLength(), nLat, nLon };
}
destArray = NetCDFConverterUtilities.getArray(dimensions, varDataType);
Index destIndex = destArray.getIndex();
ArrayFloat tempData = new ArrayFloat(new int[] { latOriginalDim.getLength(), lonOriginalDim.getLength() });
Index tempIndex = tempData.getIndex();
if (hasLocalDepth) {
for (int levelPos = 0; levelPos < depthDim.getLength(); levelPos++) {
for (int yPos = 0; yPos < latOriginalDim.getLength(); yPos++) {
for (int xPos = 0; xPos < lonOriginalDim.getLength(); xPos++) {
tempData.setFloat(tempIndex.set(yPos, xPos), originalData.getFloat(varIndex.set(levelPos, yPos, xPos)));
}
}
final WritableRaster outData = Resampler(latOriginalData, lonOriginalData, lonOriginalDim.getLength(), latOriginalDim.getLength(), 2, tempData, fillValue);
for (int j = 0; j < latOriginalDim.getLength(); j++) {
for (int k = 0; k < lonOriginalDim.getLength(); k++) {
float sample = outData.getSampleFloat(k, j, 0);
destArray.setFloat(destIndex.set(0, levelPos, j, k), sample);
}
}
}
} else {
for (int yPos = 0; yPos < latOriginalDim.getLength(); yPos++) {
for (int xPos = 0; xPos < lonOriginalDim.getLength(); xPos++) {
tempData.setFloat(tempIndex.set(yPos, xPos), originalData.getFloat(varIndex.set(yPos, xPos)));
}
}
final WritableRaster outData = Resampler(latOriginalData, lonOriginalData, lonOriginalDim.getLength(), latOriginalDim.getLength(), 2, tempData, fillValue);
for (int j = 0; j < latOriginalDim.getLength(); j++) {
for (int k = 0; k < lonOriginalDim.getLength(); k++) {
float sample = outData.getSampleFloat(k, j, 0);
destArray.setFloat(destIndex.set(0, j, k), sample);
}
}
}
// }
ncFileOut.write(varName, destArray);
}
ncFileOut.close();
outputFile.renameTo(fileOut);
} catch (Exception e) {
// something bad happened
if (LOGGER.isLoggable(Level.INFO))
LOGGER.log(Level.INFO, e.getLocalizedMessage(), e);
JAI.getDefaultInstance().getTileCache().flush();
}
}
use of org.flyte.api.v1.Variable in project imageio-ext by geosolutions-it.
the class HDF4TeraScanImageReader method initializeProfile.
/**
* Retrieve Terascan specific information.
*
* @throws IOException
*/
protected void initializeProfile() throws IOException {
boolean checkProducts = true;
final NetcdfDataset dataset = reader.getDataset();
if (dataset == null) {
throw new IOException("Unable to initialize profile due to a null dataset");
}
final List<Variable> variables = dataset.getVariables();
final List<Attribute> attributes = dataset.getGlobalAttributes();
reader.setNumGlobalAttributes(attributes.size());
productList = HDF4TeraScanProperties.refineProductList(variables);
final int numImages = productList != null ? productList.length : 0;
setNumImages(numImages);
reader.setNumImages(numImages);
final Map<Range, TerascanDatasetWrapper> indexMap = new HashMap<Range, TerascanDatasetWrapper>(numImages);
// Scanning all the datasets
try {
for (Variable var : variables) {
final String name = var.getName();
for (int j = 0; j < numImages; j++) {
// Checking if the actual dataset is a product.
if (!checkProducts || name.equals(productList[j])) {
// Updating the subDatasetsMap map
indexMap.put(new Range(j, j + 1), new TerascanDatasetWrapper(var));
break;
}
}
}
} catch (InvalidRangeException e) {
throw new IllegalArgumentException("Error occurred during NetCDF file parsing", e);
}
reader.setIndexMap(indexMap);
}
use of org.flyte.api.v1.Variable in project imageio-ext by geosolutions-it.
the class NetCDFImageReader method initialize.
/**
* Initialize main properties for this reader.
*
* @throws exception
* {@link InvalidRangeException}
*/
protected synchronized void initialize() {
int numImages = 0;
final Map<Range, NetCDFVariableWrapper> indexMap = new HashMap<Range, NetCDFVariableWrapper>();
final NetcdfDataset dataset = reader.getDataset();
try {
if (dataset != null) {
checkType = NetCDFUtilities.getCheckType(dataset);
final List<Variable> variables = dataset.getVariables();
if (variables != null) {
for (final Variable variable : variables) {
if (variable != null && variable instanceof VariableDS) {
if (!NetCDFUtilities.isVariableAccepted(variable, checkType))
continue;
int[] shape = variable.getShape();
switch(shape.length) {
case 2:
indexMap.put(new Range(numImages, numImages + 1), new NetCDFVariableWrapper(variable));
numImages++;
break;
case 3:
indexMap.put(new Range(numImages, numImages + shape[0]), new NetCDFVariableWrapper(variable));
numImages += shape[0];
break;
case 4:
indexMap.put(new Range(numImages, numImages + shape[0] * shape[1]), new NetCDFVariableWrapper(variable));
numImages += shape[0] * shape[1];
break;
}
}
}
}
} else
throw new IllegalArgumentException("Not a valid dataset has been found");
} catch (InvalidRangeException e) {
throw new IllegalArgumentException("Error occurred during NetCDF file parsing", e);
}
reader.setIndexMap(indexMap);
setNumImages(numImages);
reader.setNumImages(numImages);
int numAttribs = 0;
final List<Attribute> globalAttributes = dataset.getGlobalAttributes();
if (globalAttributes != null && !globalAttributes.isEmpty())
numAttribs = globalAttributes.size();
reader.setNumGlobalAttributes(numAttribs);
}
Aggregations