L3ShapeIsine.cpp

Go to the documentation of this file.

#include <L3ShapeIsine.h>
#include <stdlib.h>
#include <stdio.h>
#include <math.h>
 
// this should not be necessary, but M_PI seems to not be defined in C99
#define PI 3.141592653589793
 
namespace l3 {
 
 
L3ShapeIsine::L3ShapeIsine(int32_t numRows) : L3Shape(numRows) {
    int32_t i;
    double radfac = PI / 180.0;
 
    oldRow = 0;
 
    numBin = (int32_t *) calloc(totalRows, sizeof (int32_t));
    baseBin = (int64_t *) calloc(totalRows + 1, sizeof (int64_t));
    latBin = (double *) calloc(totalRows, sizeof (double));
 
    for (i = 0; i < totalRows; i++) {
        latBin[i] = (i + 0.5) * (180.0 / totalRows) - 90.0;
        numBin[i] = (int32_t) (cos(latBin[i] * radfac) * (2.0 * totalRows) + 0.5);
    }
 
    baseBin[0] = 1;
 
    for (i = 1; i <= totalRows; i++)
        baseBin[i] = baseBin[i - 1] + numBin[i - 1];
    totalBins = baseBin[totalRows] - 1;
}
 
L3ShapeIsine::~L3ShapeIsine() {
    free(numBin);
    free(baseBin);
    free(latBin);
}
 
void L3ShapeIsine::constrainRowCol(int32_t &row, int32_t &col) const {
    if (row < 0) {
        row = 0 - row;
        // if pass a pole even times, need to change col to other side
        if((row / totalRows) % 2 == 0) {
            row %= totalRows;
            col += numBin[row] / 2;
        } else {
            row %= totalRows;
        }
    } else if (row >= totalRows) {
        // if pass a pole odd times, need to change col to other side
        if((row / totalRows) % 2 == 1) {
            row %= totalRows;
            col += numBin[row] / 2;
        } else {
            row %= totalRows;
        }
    }
 
    if (col < 0 || col >= numBin[row]) {
        col %= numBin[row];
    }
}
 
int64_t L3ShapeIsine::getBaseBin(int32_t row) const {
    constrainRow(row);
    return baseBin[row];
}
 
int32_t L3ShapeIsine::getNumCols(int32_t row) const {
    constrainRow(row);
    return numBin[row];
}
 
int32_t L3ShapeIsine::bin2row(int64_t bin) {
    int32_t rlow, rhi, rmid;
 
    if (baseBin[oldRow] <= bin && baseBin[oldRow + 1] > bin) {
        return oldRow;
    } else {
        if (bin < 1)
            return 0; /* south pole */
        if (bin >= totalBins)
            return totalRows - 1; /* north pole */
 
        /* binary search for row */
        rlow = 0;
        rhi = totalRows - 1;
        while (1) {
            rmid = (rlow + rhi + 1) / 2;
            if (baseBin[rmid] > bin)
                rhi = rmid - 1;
            else
                rlow = rmid;
 
            if (rlow == rhi) {
                oldRow = rlow;
                return rlow;
            }
        }
    }
    return 0;
}
 
void L3ShapeIsine::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 = numBin[row] - 1; /* north pole */
        return;
    }
    row = bin2row(bin);
    col = bin - baseBin[row];
}
 
int64_t L3ShapeIsine::rowcol2bin(int32_t row, int32_t col) const {
    constrainRowCol(row, col);
    return baseBin[row] + col;
}
 
void L3ShapeIsine::rowcol2latlon(int32_t row, int32_t col,
        double &lat, double &lon) const {
    constrainRowCol(row, col);
    lat = latBin[row];
    lon = 360.0 * (col + 0.5) / numBin[row] + seamLon;
}
 
int32_t L3ShapeIsine::lat2row(double lat) const {
    lat = constrainLat(lat);
    int32_t row = (int32_t) ((90.0 + lat) * totalRows / 180.0);
    if (row >= totalRows)
        row = totalRows - 1;
    return row;
}
 
double L3ShapeIsine::row2lat(int32_t row) const {
    if(row < 0)
        return latBin[0];
    if(row >= totalRows)
        return latBin[totalRows-1];
    return latBin[row];
}
 
void L3ShapeIsine::latlon2rowcol(double lat, double lon,
        int32_t &row, int32_t &col) const {
    row = lat2row(lat);
    lon = constrainLon(lon);
    col = (int32_t) ((double) numBin[row] * (lon - seamLon) / 360.0);
    if (col >= numBin[row])
        col = numBin[row] - 1;
}
 
int64_t L3ShapeIsine::latlon2bin(double lat, double lon) const {
    int32_t row, col;
 
    latlon2rowcol(lat, lon, row, col);
    return baseBin[row] + col;
}
 
void L3ShapeIsine::rowcol2bounds(int32_t row, int32_t col,
        double &north, double &south,
        double &east, double &west) const {
    double lat, lon;
    rowcol2latlon(row, col, lat, lon);
    north = lat + 90.0 / totalRows;
    south = lat - 90.0 / totalRows;
    east = lon + 180.0 / numBin[row];
    west = lon - 180.0 / numBin[row];
}
 
}