How to use ucar.nc2

/**
 * Get Z Dimension Lenght for standard CF variables
 *
 * @param var
 * @return
 */
public static int getZDimensionLength(Variable var) {
  final int rank = var.getRank();
  if (rank > 2) {
    return var.getDimension(rank - Z_DIMENSION).getLength();
  }
  // TODO: Should I avoid use this method in case of 2D Variables?
  return 0;
}

public static int getDimensionLength(Variable var, final int dimensionIndex) {
  return var.getDimension(dimensionIndex).getLength();
}

private String getCoordinatesForVariable(String shortName) {
  Variable var = dataset.findVariable(null, shortName);
  if (var != null) {
    // Getting the coordinates attribute
    Attribute attribute = var.findAttribute(NetCDFUtilities.COORDINATES);
    if (attribute != null) {
      return attribute.getStringValue();
    } else {
      return var.getDimensionsString();
    }
  }
  return null;
}

NetcdfFile ncFile = NetcdfDataset.openFile(gribFile.getAbsolutePath(), null);
for (Attribute attr : ncFile.getGlobalAttributes()) {
  Property property = resolveMetadataKey(attr.getFullName());
  if (attr.getDataType().isString()) {
    metadata.add(property, attr.getStringValue());
  } else if (attr.getDataType().isNumeric()) {
    int value = attr.getNumericValue().intValue();
    metadata.add(property, String.valueOf(value));
xhtml.newline();
for (Dimension dim : ncFile.getDimensions()){
  xhtml.element("li", dim.getFullName() + "=" + String.valueOf(dim.getLength()) + ";");
  xhtml.newline();
xhtml.newline();
for (Variable var : ncFile.getVariables()){
  xhtml.element("p", String.valueOf(var.getDataType()) + var.getNameAndDimensions() + ";");
  for(Attribute element : var.getAttributes()){
    xhtml.element("li", " :" + element + ";");
    xhtml.newline();

protected void unravelStringMet(NetcdfFile ncFile, Group group, Metadata met) {
  if (group == null) {
    group = ncFile.getRootGroup();
  }
  // get file type
  met.set("File-Type-Description", ncFile.getFileTypeDescription());
  // unravel its string attrs
  for (Attribute attribute : group.getAttributes()) {
    if (attribute.isString()) {
      met.add(attribute.getFullName(), attribute.getStringValue());
    } else {
      // try and cast its value to a string
      met.add(attribute.getFullName(), String.valueOf(attribute
          .getNumericValue()));
    }
  }
  for (Group g : group.getGroups()) {
    unravelStringMet(ncFile, g, met);
  }
}

private static Variable getAuxiliaryCoordinate(
    NetcdfDataset dataset, Group group, Variable var, String dimName) {
  Variable coordinateVariable = null;
  Attribute attribute = var.findAttribute(NetCDFUtilities.COORDINATES);
  if (attribute != null) {
    String coordinates = attribute.getStringValue();
    String[] coords = coordinates.split(" ");
    for (String coord : coords) {
      Variable coordVar = dataset.findVariable(group, coord);
      List<Dimension> varDimensions = coordVar.getDimensions();
      if (varDimensions != null
          && varDimensions.size() == 1
          && varDimensions.get(0).getFullName().equalsIgnoreCase(dimName)) {
        coordinateVariable = coordVar;
        break;
      }
    }
  }
  return coordinateVariable;
}

  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.getFullName(), CheckType.NONE);
} else if (checkType == CheckType.ONLYGEOGRIDS) {
  List<Dimension> dimensions = var.getDimensions();
  if (dimensions.size() < 2) {
    return false;
    String dimName = dimension.getFullName();
    Group group = dimension.getGroup();
    Variable dimVariable = group.findVariable(dimName);
    if (dimVariable == null && dataset != null) {
      AxisType axisType = axis.getAxisType();
      if (axisType == null) {
        return false;
  DataType dataType = var.getDataType();
  if (dataType == DataType.CHAR) {

  /** Look for a Coordinate Reference System */
  private CoordinateReferenceSystem lookForCrs(
      CoordinateReferenceSystem crs, Attribute gridMappingAttribute, Variable var)
      throws FactoryException {
    if (gridMappingAttribute != null) {
      String gridMappingName = gridMappingAttribute.getStringValue();
      if (LOGGER.isLoggable(Level.FINE)) {
        LOGGER.fine("The variable refers to gridMapping: " + gridMappingName);
      }
      Variable mapping = dataset.findVariable(null, gridMappingName);
      if (mapping != null) {
        CoordinateReferenceSystem localCrs = NetCDFProjection.parseProjection(mapping);
        if (localCrs != null) {
          // lookup for a custom EPSG if any
          crs = NetCDFProjection.lookupForCustomEpsg(localCrs);
        }
      } else if (LOGGER.isLoggable(Level.WARNING)) {
        LOGGER.warning(
            "The specified variable "
                + var.getFullName()
                + " declares a gridMapping = "
                + gridMappingName
                + " but that mapping doesn't exist.");
      }
    }
    return crs;
  }
}

double max = Double.NaN;
DataType dataType = null;
Attribute rangeAttribute = var.findAttribute(ACTUAL_RANGE);
if (rangeAttribute == null) {
  rangeAttribute = var.findAttribute(VALID_RANGE);
  dataType = rangeAttribute.getDataType();
  min = rangeAttribute.getNumericValue(0).doubleValue();
  max = rangeAttribute.getNumericValue(1).doubleValue();
} else {
  Attribute minAttribute = var.findAttribute(VALID_MIN);
  Attribute maxAttribute = var.findAttribute(VALID_MAX);
  if (minAttribute != null && maxAttribute != null) {
    dataType = minAttribute.getDataType();
    min = minAttribute.getNumericValue().doubleValue();
    max = maxAttribute.getNumericValue().doubleValue();

Attribute coordinatesAttribute = var.findAttribute(NetCDFUtilities.COORDINATES);
boolean hasXLon = false;
boolean hasYLat = false;
if (coordinatesAttribute != null) {
  coordinates = coordinatesAttribute.getStringValue();
} else if (!(var instanceof CoordinateAxis)) {
  String dimensions = var.getDimensionsString();
  if (dimensions != null && !dimensions.isEmpty()) {
    coordinates = dimensions;

/**
 * Utility method for getting NoData from an input {@link Variable}
 *
 * @param var Variable instance
 * @return a Number representing NoData
 */
public static Number getNodata(Variable var) {
  if (var != null) {
    // Getting all the Variable attributes
    List<Attribute> attributes = var.getAttributes();
    String fullName;
    // Searching for FILL_VALUE or MISSING_VALUE attributes
    for (Attribute attribute : attributes) {
      fullName = attribute.getFullName();
      if (fullName.equalsIgnoreCase(FILL_VALUE)
          || fullName.equalsIgnoreCase(MISSING_VALUE)) {
        return attribute.getNumericValue();
      }
    }
  }
  return null;
}

Attribute semiMajorAxisAttribute = gridMappingVariable.findAttribute(CF.SEMI_MAJOR_AXIS);
if (semiMajorAxisAttribute != null) {
  semiMajorAxis = semiMajorAxisAttribute.getNumericValue();
  ellipsoidParams.put(NetCDFUtilities.SEMI_MAJOR, semiMajorAxis);
  semiMajorAxisAttribute = gridMappingVariable.findAttribute(CF.EARTH_RADIUS);
  if (semiMajorAxisAttribute != null) {
    semiMajorAxis = semiMajorAxisAttribute.getNumericValue();
    ellipsoidParams.put(NetCDFUtilities.SEMI_MAJOR, semiMajorAxis);
Attribute semiMinorAxisAttribute = gridMappingVariable.findAttribute(CF.SEMI_MINOR_AXIS);
if (semiMinorAxisAttribute != null) {
  semiMinorAxis = semiMinorAxisAttribute.getNumericValue();
  ellipsoidParams.put(NetCDFUtilities.SEMI_MINOR, semiMinorAxis);
      gridMappingVariable.findAttribute(CF.INVERSE_FLATTENING);
  if (inverseFlatteningAttribute != null) {
    inverseFlattening = inverseFlatteningAttribute.getNumericValue().doubleValue();

/**
 * Adjust the mappingName if needed. This may happen for some projections where different
 * standard parallels may require _1SP or _2SP suffix.
 *
 * @param the input netCDF mappingName
 * @param var the gridMapping variable
 * @return
 */
private static String getProjectionName(String mappingName, Variable var) {
  String projectionName = mappingName;
  if (mappingName.equalsIgnoreCase(CF.LAMBERT_CONFORMAL_CONIC)) {
    Attribute standardParallel = var.findAttribute(CF.STANDARD_PARALLEL);
    // special Management for multiple standard parallels to use
    // the proper projection
    projectionName =
        CF.LAMBERT_CONFORMAL_CONIC
            + (standardParallel.getLength() == 1 ? "_1SP" : "_2SP");
  } else if (mappingName.equalsIgnoreCase(CF.MERCATOR)) {
    Attribute standardParallel = var.findAttribute(CF.STANDARD_PARALLEL);
    projectionName = CF.MERCATOR + (standardParallel == null ? "_2SP" : "_1SP");
  }
  return projectionName;
}

/**
 * Extract the {@link CoordinateReferenceSystem} from a NetCDF attribute (if present)
 * containing a WKT String
 *
 * @param wktAttribute the NetCDF {@link Attribute} if any, containing WKT definition.
 * @return
 */
private static CoordinateReferenceSystem parseWKT(Attribute wktAttribute) {
  CoordinateReferenceSystem crs = null;
  if (wktAttribute != null) {
    String wkt = wktAttribute.getStringValue();
    try {
      crs = CRS.parseWKT(wkt);
    } catch (FactoryException e) {
      if (LOGGER.isLoggable(Level.WARNING)) {
        LOGGER.warning("Unable to setup a CRS from the specified WKT: " + wkt);
      }
    }
  }
  return crs;
}

/**
 * Get a {@link Variable} by name.
 *
 * @param varName the name of the {@link Variable} to pick.
 * @return the variable or <code>null</code>.
 */
public Variable getVariableByName(final String varName) {
  final List<Variable> varList = dataset.getVariables();
  for (Variable var : varList) {
    if (var.getFullName().equals(varName)) return var;
  }
  return null;
}

/**
 * Get a proper {@link CRSParser} for the input Variable.
 *
 * @param var
 * @return
 */
public static NetCDFProjection.CRSParser getCRSParser(Variable var) {
  if (var != null) {
    Attribute attr = null;
    // check on crs related attributes which may contain a fully
    // defined WKT or a grid mapping reference
    if ((attr = var.findAttribute(NetCDFUtilities.CERP_ESRI_PE_STRING)) != null) {
      return new WKTCRSParser(attr);
    } else if ((attr = var.findAttribute(NetCDFUtilities.SPATIAL_REF)) != null) {
      return new WKTCRSParser(attr);
    } else if ((attr = var.findAttribute(NetCDFUtilities.GRID_MAPPING_NAME)) != null) {
      return new GridMappingCRSParser(attr);
    }
  }
  return null;
}

/** @throws Exception */
private void initSlicesInfo() throws Exception {
  int[] shape = variableDS.getShape();
  numberOfSlices = 1;
  for (int i = 0; i < variableDS.getShape().length - 2; i++) {
    if (!ignoredDimensions.contains(variableDS.getDimension(i).getFullName())) {
      numberOfSlices *= shape[i];
    }
  }
}

public Map<String, Integer> mapIndex(int[] splittedIndex) {
  Map<String, Integer> resultIndex = new HashMap<String, Integer>();
  for (int n = 0; n < splittedIndex.length; n++) {
    if (nDimensionIndex[n] != -1) {
      resultIndex.put(
          variableDS.getDimension(nDimensionIndex[n]).getFullName(),
          splittedIndex[n]);
    }
  }
  return resultIndex;
}

/**
 * Returns the data type which most closely represents the "raw" internal data of the variable.
 * This is the value returned by the default implementation of {@link
 * NetcdfImageReader#getRawDataType}.
 *
 * @param variable The variable.
 * @return The data type, or {@link DataBuffer#TYPE_UNDEFINED} if unknown.
 * @see NetcdfImageReader#getRawDataType
 */
public static int getRawDataType(final VariableIF variable) {
  VariableDS ds = (VariableDS) variable;
  final DataType type;
  if (Boolean.getBoolean(ENHANCE_SCALE_MISSING)) {
    type = ds.getDataType();
  } else {
    type = ds.getOriginalDataType();
  }
  return transcodeNetCDFDataType(type, variable.isUnsigned());
}

/**
 * Return the value of a particular dimension.
 *
 * @param dimensionIndex the index of the dimension
 * @return the value
 */
@SuppressWarnings("unchecked")
private <T> T getValueByIndex(int dimensionIndex, final Map<String, Integer> mappedIndex) {
  final Dimension dimension = variableDS.getDimension(dimensionIndex);
  return (T)
      reader.georeferencing
          .getCoordinateVariable(dimension.getFullName())
          .read(mappedIndex);
}