import ucar.ma2.Range; //导入依赖的package包/类
/**
 * Get min/max the longitude from two ranges.
 *
 * @param r1 first Longitude range
 * @param r2 second Longitude range
 * @param r1Values first Longitude range values
 * @param r2Values second Longitude range values
 * @return Normalized Min/Max of the Longitude ranges values
 */
public static MinMax getMinMaxLonNormal(Range r1, Range r2, double[] r1Values, double[] r2Values) {
    double min = Double.MAX_VALUE;
    double max = Double.MIN_VALUE;

    if (r1.first() > r2.first()) {
        min = r1Values[0];
        max = r2Values[1];
        // double center = ((r1Values[0] != 0.) ? r1Values[0] : r1Values[1]);
        double center = r1Values[0] + 180;
        max = LatLonPointImpl.lonNormal(r2Values[1], center);

    } else {
        min = r2Values[0];
        max = r1Values[1];
    }

    return new MAMath.MinMax(min, max);

}
 

import ucar.ma2.Range; //导入依赖的package包/类
/**
 * Compare.
 *
 * @param r1 the r1
 * @param r2 the r2
 * @return the int {@inheritDoc}
 */
@SuppressWarnings("unchecked")
@Override
public int compare(Range r1, Range r2) {
    if (r1.first() > r2.first()) {
        if (ascending) {
            return 1;
        } else {
            return -1;
        }
    }
    if (r1.first() < r2.first()) {
        if (ascending) {
            return -1;
        } else {
            return 1;
        }
    }
    return 0;
}
 

import ucar.ma2.Range; //导入依赖的package包/类
/**
 * Returns a true if all of Y/X empty ranges of a list are empty ranges or if list is empty.
 * 
 * @param listRanges list of Y/X list ranges to be tested
 * @return true if all of Y/X empty ranges of a list are empty ranges or if list is empty.
 * @throws MotuException
 */
public static boolean hasEmptyYXRanges(List<List<Range>> listRanges) throws MotuException {

    if (listRanges.size() <= 0) {
        return true;
    }

    int countEmptyRanges = 0;
    for (List<Range> ranges : listRanges) {
        if (!(ExtractCriteriaLatLon.hasRange(ranges))) {
            countEmptyRanges++;
        }
    }

    return (countEmptyRanges == listRanges.size());
}
 

import ucar.ma2.Range; //导入依赖的package包/类
/**
 * Return range corresponding to criteria.
 * 
 * @param array values from which range is computed
 * @return range corresponding to criteria in the array, or null if no range found
 * @param rangeValue values coresponding to the range, or Double.MAX_VALUE if undefined values
 * @throws MotuException
 * @throws MotuInvalidDepthRangeException
 */
public Range toRange(double[] array, double[] rangeValue) throws MotuException, MotuInvalidDepthRangeException {

    Range range = toRange(array);
    if (rangeValue != null) {
        assert rangeValue.length == 2;
        rangeValue[0] = Double.MAX_VALUE;
        rangeValue[1] = Double.MAX_VALUE;
        if (range != null) {
            rangeValue[0] = array[range.first()];
            rangeValue[1] = array[range.last()];
        }
    }

    return range;
}
 

import ucar.ma2.Range; //导入依赖的package包/类
/**
 * Gets Z range and ranges values to be extracted.
 * 
 * @throws MotuInvalidDepthRangeException
 * @throws MotuException
 * @throws NetCdfVariableException
 * 
 */
public Range getZRange() throws MotuException, MotuInvalidDepthRangeException, NetCdfVariableException {
    if (zRangeValue != null) {
        zRangeValue[0] = Double.MAX_VALUE;
        zRangeValue[1] = Double.MAX_VALUE;
    }

    zRange = null;
    if (getRequestDownloadStatus().getRequestProduct().getProduct().getProductMetaData().hasZAxis()) {
        Array zAxisData = getRequestDownloadStatus().getRequestProduct().getProduct().getZAxisData();
        ExtractCriteriaDepth extractCriteriaDepth = getRequestDownloadStatus().getRequestProduct().getRequestProductParameters().findCriteriaDepth();
        if (extractCriteriaDepth != null) {
            zRange = extractCriteriaDepth.toRange(zAxisData, zRangeValue);
        }
    }

    return zRange;
}
 

import ucar.ma2.Range; //导入依赖的package包/类
/**
 * Get min/max the longitude from the grid.
 *
 * @return Normalized Min/Max of the Longitude ranges values
 * @throws MotuException the motu exception
 * @throws MotuNotImplementedException the motu not implemented exception
 */
public MAMath.MinMax getMinMaxLonNormal() throws MotuException, MotuNotImplementedException {

    // Assumes size of lists are consistency.
    if (listYXRanges.size() == 2) {
        List<Range> yxRanges1 = listYXRanges.get(0);
        List<Range> yxRanges2 = listYXRanges.get(1);
        return RequestProductParameters.getMinMaxLonNormal(yxRanges1.get(1), yxRanges2.get(1), rangesLonValue.get(0), rangesLonValue.get(1));
    } else if (rangesLonValue.size() == 1) {
        double[] rangeLonVal = rangesLonValue.get(0);
        return new MAMath.MinMax(rangeLonVal[0], rangeLonVal[1]);
    } else if (rangesLonValue.size() == 0) {
        // no range
        return new MAMath.MinMax(Double.MAX_VALUE, Double.MAX_VALUE);
    } else {
        throw new MotuNotImplementedException(
                String.format("Longitude ranges list more than 2 elements is not implemented (%s)", this.getClass().getName()));

    }
}
 

import ucar.ma2.Range; //导入依赖的package包/类
/**
 * Gets the original range list geo axis.
 * 
 * @param axis the axis
 * @param y_range the y_range
 * @param x_range the x_range
 * @return the original range list geo axis
 */
public Section getOriginalRangeListGeoAxis(CoordinateAxis axis, Range y_range, Range x_range) {

    // get the ranges list
    int rank = axis.getRank();
    Range[] ranges = new Range[rank];
    int indexX = getGeoXDimVarIndex(axis);
    if (indexX >= 0) {
        ranges[indexX] = x_range;
    }
    int indexY = getGeoYDimVarIndex(axis);
    if (indexY >= 0) {
        ranges[indexY] = y_range;
    }
    List<Range> rangesList = Arrays.asList(ranges);

    return new Section(rangesList);
}
 

import ucar.ma2.Range; //导入依赖的package包/类
private void readXY_1(Range yRange, Range xRange, IndexIterator ii) throws IOException {
    byte[] imageBytes = getIamgeData();

    //Get grid data
    int i, j;
    int xNum = (int) _width;
    int yNum = (int) _height;

    float[] data = new float[yNum * xNum];
    for (i = 0; i < yNum; i++) {
        for (j = 0; j < xNum; j++) {
            data[(yNum - i - 1) * xNum + j] = DataConvert.byte2Int(imageBytes[i * xNum + j]);
        }
    }

    for (int y = yRange.first(); y <= yRange.last();
            y += yRange.stride()) {
        for (int x = xRange.first(); x <= xRange.last();
                x += xRange.stride()) {
            int index = y * xNum + x;
            ii.setFloatNext(data[index]);
        }
    }
}
 

import ucar.ma2.Range; //导入依赖的package包/类
/**
 * Read array data of the variable
 *
 * @param varName Variable name
 * @param origin The origin array
 * @param size The size array
 * @param stride The stride array
 * @return Array data
 */
@Override
public Array read(String varName, int[] origin, int[] size, int[] stride) {
    try {
        Section section = new Section(origin, size, stride);
        Array dataArray = Array.factory(DataType.FLOAT, section.getShape());
        int rangeIdx = 2;
        Range yRange = section.getRange(rangeIdx++);
        Range xRange = section.getRange(rangeIdx);
        IndexIterator ii = dataArray.getIndexIterator();
        readXY(yRange, xRange, ii);

        return dataArray;
    } catch (InvalidRangeException ex) {
        Logger.getLogger(MICAPS4DataInfo.class.getName()).log(Level.SEVERE, null, ex);
        return null;
    }
}
 

import ucar.ma2.Range; //导入依赖的package包/类
/**
 * Read array data of the variable
 *
 * @param varName Variable name
 * @param origin The origin array
 * @param size The size array
 * @param stride The stride array
 * @return Array data
 */
@Override
public Array read(String varName, int[] origin, int[] size, int[] stride) {
    try {
        Section section = new Section(origin, size, stride);
        Array dataArray = Array.factory(DataType.FLOAT, section.getShape());
        int rangeIdx = 2;
        Range yRange = section.getRange(rangeIdx++);
        Range xRange = section.getRange(rangeIdx);
        IndexIterator ii = dataArray.getIndexIterator();
        readXY(varName, yRange, xRange, ii);

        return dataArray;
    } catch (InvalidRangeException ex) {
        Logger.getLogger(MICAPS4DataInfo.class.getName()).log(Level.SEVERE, null, ex);
        return null;
    }
}
 

import ucar.ma2.Range; //导入依赖的package包/类
/**
 * Read array data of the variable
 *
 * @param varName Variable name
 * @param origin The origin array
 * @param size The size array
 * @param stride The stride array
 * @return Array data
 */
@Override
public Array read(String varName, int[] origin, int[] size, int[] stride) {
    try {
        Section section = new Section(origin, size, stride);
        Array dataArray = Array.factory(this.dataType, section.getShape());
        int rangeIdx = 0;
        Range yRange = section.getRange(rangeIdx++);
        Range xRange = section.getRange(rangeIdx);
        //IndexIterator ii = dataArray.getIndexIterator();
        readXY(yRange, xRange, dataArray);

        return dataArray;
    } catch (InvalidRangeException ex) {
        Logger.getLogger(ASCIIGridDataInfo.class.getName()).log(Level.SEVERE, null, ex);
        return null;
    }
}
 

import ucar.ma2.Range; //导入依赖的package包/类
/**
 * Read array data of the variable
 *
 * @param varName Variable name
 * @param origin The origin array
 * @param size The size array
 * @param stride The stride array
 * @return Array data
 */
@Override
public Array read(String varName, int[] origin, int[] size, int[] stride) {
    try {
        Section section = new Section(origin, size, stride);
        Array dataArray = Array.factory(DataType.FLOAT, section.getShape());
        int rangeIdx = 0;
        Range yRange = section.getRange(rangeIdx++);
        Range xRange = section.getRange(rangeIdx);
        IndexIterator ii = dataArray.getIndexIterator();
        readXY(yRange, xRange, ii);

        return dataArray;
    } catch (InvalidRangeException ex) {
        Logger.getLogger(SurferGridDataInfo.class.getName()).log(Level.SEVERE, null, ex);
        return null;
    }
}
 

import ucar.ma2.Range; //导入依赖的package包/类
/**
 * Integrate vector array using the composite trapezoidal rule.
 *
 * @param y Vecotr array
 * @param dx Spacing between all y elements
 * @param ranges
 * @return Definite integral as approximated by trapezoidal rule
 * @throws ucar.ma2.InvalidRangeException
 */
public static double trapz(Array y, double dx, List<Range> ranges) throws InvalidRangeException {
    int n = 1;
    for (Range range : ranges) {
        n = n * range.length();
    }
    n -= 1;
    double a = 1;
    double b = n * dx + a;
    double r = 0;
    double v;
    IndexIterator ii = y.getRangeIterator(ranges);
    int i = 0;
    while (ii.hasNext()) {
        v = ii.getDoubleNext();
        r += v;
        if (i > 0 && i < n) {
            r += v;
        }
        i += 1;
    }
    r = r * ((b - a) / (2 * n));
    return r;
}
 

import ucar.ma2.Range; //导入依赖的package包/类
/**
 * Set section
 *
 * @param a Array a
 * @param ranges Ranges
 * @param v Array value
 * @return Result array
 * @throws InvalidRangeException
 */
public static Array setSection(Array a, List<Range> ranges, Array v) throws InvalidRangeException {
    Array r = a.section(ranges);
    IndexIterator iter = r.getIndexIterator();
    //int[] current;
    Index index = v.getIndex();
    while (iter.hasNext()) {
        iter.next();
        //current = iter.getCurrentCounter();
        //index.set(current);
        iter.setObjectCurrent(v.getObject(index));
        index.incr();
    }
    r = Array.factory(a.getDataType(), a.getShape(), r.getStorage());
    return r;
}
 

import ucar.ma2.Range; //导入依赖的package包/类
/**
 * Compute sum value of an array
 *
 * @param a Array a
 * @param ranges Range list
 * @return Sum value
 * @throws ucar.ma2.InvalidRangeException
 */
public static double sum(Array a, List<Range> ranges) throws InvalidRangeException {
    double s = 0.0, v;
    int n = 0;
    IndexIterator ii = a.getRangeIterator(ranges);
    while (ii.hasNext()) {
        v = ii.getDoubleNext();
        if (!Double.isNaN(v)) {
            s += v;
            n += 1;
        }
    }
    if (n == 0) {            
        s = Double.NaN;
    }
    return s;
}
 

import ucar.ma2.Range; //导入依赖的package包/类
/**
 * Compute mean value of an array
 *
 * @param a Array a
 * @param ranges Range list
 * @return Mean value
 * @throws ucar.ma2.InvalidRangeException
 */
public static double mean(Array a, List<Range> ranges) throws InvalidRangeException {
    double mean = 0.0, v;
    int n = 0;
    IndexIterator ii = a.getRangeIterator(ranges);
    while (ii.hasNext()) {
        v = ii.getDoubleNext();
        if (!Double.isNaN(v)) {
            mean += v;
            n += 1;
        }
    }
    if (n > 0) {
        mean = mean / n;
    } else {
        mean = Double.NaN;
    }
    return mean;
}
 

import ucar.ma2.Range; //导入依赖的package包/类
/**
 * Instantiate a new {@link RangesList} with defined dimension indices
 * 
 * @param xIndex
 *            The index of the x-dimension
 * @param yIndex
 *            The index of the y-dimension
 * @param zIndex
 *            The index of the z-dimension
 * @param tIndex
 *            The index of the t-dimension
 */
public RangesList(int xIndex, int yIndex, int zIndex, int tIndex) {
    int rank = 0;
    if (xIndex >= 0) {
        xAxisIndex = xIndex;
        rank++;
    }
    if (yIndex >= 0) {
        yAxisIndex = yIndex;
        rank++;
    }
    if (zIndex >= 0) {
        zAxisIndex = zIndex;
        rank++;
    }
    if (tIndex >= 0) {
        tAxisIndex = tIndex;
        rank++;
    }
    ranges = new ArrayList<Range>(rank);
    for (int i = 0; i < rank; i++) {
        ranges.add(ZERO_RANGE);
    }
}
 

import ucar.ma2.Range; //导入依赖的package包/类
/** 
 * Test {@link RangeList} get?AxisIndex and getRanges methods.
 */
@Test
public void test() {
    List<GridDatatype> gridVarLists = gridDataset.getGrids();
    /*
     * The order of 4D test data is first, T axis, second, Z axis, followed
     * by y and x axis.
     */
    for (GridDatatype gdt : gridVarLists) {
        RangesList gdtRange = new RangesList(gdt);
        assertEquals(0, gdtRange.getTAxisIndex());
        assertEquals(1, gdtRange.getZAxisIndex());
        assertEquals(2, gdtRange.getYAxisIndex());
        assertEquals(3, gdtRange.getXAxisIndex());
        List<Range> ranges = gdtRange.getRanges();
        for (Range r : ranges) {
            assertEquals(ZERO_RANGE, r);
        }
    }
}
 

import ucar.ma2.Range; //导入依赖的package包/类
/**
 * Return range corresponding to criteria, and range values (optional).
 * 
 * @param array values from which range is computed
 * @param udUnits units of the values
 * @param rangeValue values corresponding to the range, or Double.MAX_VALUE if undefined values
 * @return range corresponding to criteria in the array, or null if no range found
 * @throws MotuException
 * @throws MotuInvalidDateRangeException
 */
public Range toRange(double[] array, String udUnits, double[] rangeValue) throws MotuException, MotuInvalidDateRangeException {
    Range range = toRange(array, udUnits);
    if (rangeValue != null) {
        assert rangeValue.length == 2;
        rangeValue[0] = Double.MAX_VALUE;
        rangeValue[1] = Double.MAX_VALUE;
        if (range != null) {
            rangeValue[0] = array[range.first()];
            rangeValue[1] = array[range.last()];
        }
    }

    return range;
}
 

import ucar.ma2.Range; //导入依赖的package包/类
/**
 * Gets range values corresponding to range index.
 * 
 * @param gcs grid coordinate system from which range is computed
 * @param rangeLat latitude range
 * @param rangeLon longitude range
 * @param rangeValueLat latitude values corresponding to the range
 * @param rangeValueLon longitude values corresponding to the range
 */
private void getRangeValues(GridCoordSys gcs, Range rangeLat, Range rangeLon, double[] rangeValueLat, double[] rangeValueLon)
        throws MotuNotImplementedException {
    // this is the case where no point are included
    boolean hasLatRange = ExtractCriteriaLatLon.hasRange(rangeLat);
    boolean hasLonRange = ExtractCriteriaLatLon.hasRange(rangeLon);

    CoordinateAxis xaxis = gcs.getXHorizAxis();
    CoordinateAxis yaxis = gcs.getYHorizAxis();
    if ((xaxis instanceof CoordinateAxis1D) && (yaxis instanceof CoordinateAxis1D)) {
        CoordinateAxis1D xaxis1 = (CoordinateAxis1D) xaxis;
        CoordinateAxis1D yaxis1 = (CoordinateAxis1D) yaxis;
        if ((rangeValueLat != null) && hasLatRange) {
            rangeValueLat[0] = yaxis1.getCoordValue(rangeLat.first());
            rangeValueLat[1] = yaxis1.getCoordValue(rangeLat.last());
        }
        if ((rangeValueLon != null) && hasLonRange) {
            rangeValueLon[0] = xaxis1.getCoordValue(rangeLon.first());
            rangeValueLon[1] = xaxis1.getCoordValue(rangeLon.last());
        }
    } else if ((xaxis instanceof CoordinateAxis2D) && (yaxis instanceof CoordinateAxis2D) && gcs.isLatLon()) {
        CoordinateAxis2D lonAxis = (CoordinateAxis2D) xaxis;
        CoordinateAxis2D latAxis = (CoordinateAxis2D) yaxis;
        if ((rangeValueLat != null) && hasLatRange) {
            rangeValueLat[0] = latAxis.getCoordValue(rangeLat.first(), rangeLon.first());
            rangeValueLat[1] = latAxis.getCoordValue(rangeLat.last(), rangeLon.last());
        }
        if ((rangeValueLon != null) && hasLonRange) {
            rangeValueLon[0] = lonAxis.getCoordValue(rangeLat.first(), rangeLon.first());
            rangeValueLon[1] = lonAxis.getCoordValue(rangeLat.last(), rangeLon.last());
        }
    } else {
        throw new MotuNotImplementedException(
                "Coordinate axes that are not 1D or 2D/LatLon are not implemented in ExtractCriteriaLatLon.toRange");
    }

}