L3ShapeSMI.cpp

Go to the documentation of this file.

#include <L3ShapeSMI.h>
#include <stdlib.h>
#include <stdio.h>
#include <math.h>
 
namespace l3 {
 
L3ShapeSMI::L3ShapeSMI(int32_t numRows, int32_t numCols,
        double north, double south,
        double east, double west)
: L3Shape(numRows) {
    totalCols = numCols;
    totalBins = totalRows * totalCols;
 
    north_ = north;
    south_ = south;
    east_ = east;
    west_ = west;
}
 
L3ShapeSMI::~L3ShapeSMI() {
}
 
void L3ShapeSMI::constrainRowCol(int32_t &row, int32_t &col) const {
    if (row < 0)
        row = 0;
    else if (row >= totalRows)
        row = totalRows - 1;
 
    if (col < 0) {
        col = totalCols + col;
        if(col < 0)
            col = 0;
    } else if (col >= totalCols) {
        col = col - totalCols;
        if(col >= totalCols)
            col = totalCols - 1;
    }
}
 
int64_t L3ShapeSMI::getBaseBin(int32_t row) const {
    constrainRow(row);
    return (int64_t) row * (int64_t) totalCols + 1;
}
 
int32_t L3ShapeSMI::getNumCols(int32_t row) const {
    return totalCols;
}
 
int32_t L3ShapeSMI::bin2row(int64_t bin) {
    if (bin < 1)
        return 0; /* south pole */
    if (bin >= totalBins)
        return totalRows - 1; /* north pole */
    return (bin - 1) / totalCols;
}
 
void L3ShapeSMI::bin2rowcol(int64_t bin, int32_t &row, int32_t &col) {
    if (bin < 1) {
        row = col = 0; /* south pole */
        return;
    }
    if (bin >= totalBins) {
        row = totalRows - 1;
        col = totalCols - 1; /* north pole */
        return;
    }
    bin--;
    row = bin / totalCols;
    col = bin - row * totalCols;
}
 
int64_t L3ShapeSMI::rowcol2bin(int32_t row, int32_t col) const {
    constrainRowCol(row, col);
    return row * totalCols + col + 1;
}
 
void L3ShapeSMI::rowcol2latlon(int32_t row, int32_t col,
        double &lat, double &lon) const {
    constrainRowCol(row, col);
    lat = (north_ - south_) * (row + 0.5) / totalRows + south_;
    lon = (east_ - west_) * (col + 0.5) / totalCols + west_;
}
 
int32_t L3ShapeSMI::lat2row(double lat) const {
    lat = constrainLat(lat);
    if (lat > north_ || lat < south_)
        return -1;
 
    int32_t row =
            (int32_t) ((lat - south_) * totalRows / (north_ - south_));
    if (row >= totalRows)
        row = totalRows - 1;
    if (row < 0)
        row = 0;
    return row;
}
 
double L3ShapeSMI::row2lat(int32_t row) const {
    return (north_ - south_) * (row + 0.5) / totalRows + south_;
}
 
 
void L3ShapeSMI::latlon2rowcol(double lat, double lon,
        int32_t &row, int32_t &col) const {
    row = lat2row(lat);
    if (row == -1) {
        col = -1;
        return;
    }
    lon = constrainLon(lon);
    if (lon < west_ || lon > east_) {
        row = col = -1;
        return;
    }
    col = (int32_t) (totalCols * (lon - west_) / (east_ - west_));
    if (col >= totalCols || col < 0)
        row = col = -1;
}
 
int64_t L3ShapeSMI::latlon2bin(double lat, double lon) const {
    int32_t row, col;
 
    latlon2rowcol(lat, lon, row, col);
    return (int64_t) row * (int64_t) totalCols + (int64_t) col;
}
 
void L3ShapeSMI::rowcol2bounds(int32_t row, int32_t col,
        double &north, double &south,
        double &east, double &west) const {
    double lat, lon;
    rowcol2latlon(row, col, lat, lon);
    double tmp = (north_ - south_) / totalRows / 2.0;
    north = lat + tmp;
    south = lat - tmp;
 
    tmp = (east_ - west_) / totalCols / 2.0;
    east = lon + tmp;
    west = lon - tmp;
}
 
}