GeoConstraint.h

 
// -*- mode: c++; c-basic-offset:4 -*-
 
// This file is part of libdap, A C++ implementation of the OPeNDAP Data
// Access Protocol.
 
// Copyright (c) 2006 OPeNDAP, Inc.
// Author: James Gallagher <jgallagher@opendap.org>
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
//
// You can contact OPeNDAP, Inc. at PO Box 112, Saunderstown, RI. 02874-0112.
 
#ifndef _geo_constraint_h
#define _geo_constraint_h 1
 
#include <string>
#include <sstream>
#include <set>
 
namespace libdap {
class BaseType;
class Array;
class Grid;
}
 
namespace functions
{

 
class GeoConstraint
{
public:
    enum Notation {
        unknown_notation,
        pos,
        neg_pos
    };

    enum LatitudeSense {
        unknown_sense,
        normal,
        inverted
    };
 
private:
    char *d_array_data;     //< Holds the Grid's data values
    int d_array_data_size;  //< Total size (bytes) of the array data
 
    double *d_lat;              //< Holds the latitude values
    double *d_lon;              //< Holds the longitude values
    int d_lat_length;           //< Elements (not bytes) in the latitude vector
    int d_lon_length;           //< ... longitude vector
 
    // These four are indexes of the constraint
    int d_latitude_index_top;
    int d_latitude_index_bottom;
    int d_longitude_index_left;
    int d_longitude_index_right;
 
    bool d_bounding_box_set;    //< Has the bounding box been set?
    bool d_longitude_rightmost; //< Is longitude the rightmost dimension?
 
    Notation d_longitude_notation;
    LatitudeSense d_latitude_sense;
 
    libdap::Array::Dim_iter d_lon_dim;  //< References the longitude dimension
    libdap::Array::Dim_iter d_lat_dim;  //< References the latitude dimension
 
    // Sets of string values used to find stuff in attributes
    set<string> d_coards_lat_units;
    set<string> d_coards_lon_units;
 
    set<string> d_lat_names;
    set<string> d_lon_names;
 
    // Hide these three automatically provided methods
    GeoConstraint(const GeoConstraint &param);
    GeoConstraint &operator=(GeoConstraint &rhs);
 
protected:
    virtual bool build_lat_lon_maps() = 0;

    virtual bool lat_lon_dimensions_ok() = 0;
 
    Notation categorize_notation(const double left, const double right) const;
    void transform_constraint_to_pos_notation(double &left, double &right) const;
    virtual void transform_longitude_to_pos_notation();
    virtual void transform_longitude_to_neg_pos_notation();
    virtual bool is_bounding_box_valid(const double left, const double top,
                    const double right, const double bottom) const;
    void find_longitude_indeces(double left, double right,
                                int &longitude_index_left,
                                int &longitude_index_right) const;
 
    virtual void transpose_vector(double *src, const int length);
    virtual void reorder_longitude_map(int longitude_index_left);
 
    virtual LatitudeSense categorize_latitude() const;
    void find_latitude_indeces(double top, double bottom, LatitudeSense sense,
                               int &latitude_index_top,
                               int &latitude_index_bottom) const;
 
    virtual void reorder_data_longitude_axis(libdap::Array &a,libdap:: Array::Dim_iter lon_dim);
    virtual void flip_latitude_within_array(libdap::Array &a, int lat_length, int lon_length);
 
    friend class GridGeoConstraintTest; // Unit tests
 
public:
    GeoConstraint();
 
    virtual ~GeoConstraint()
    {
        delete [] d_lat; d_lat = 0;
        delete [] d_lon; d_lon = 0;
        delete [] d_array_data; d_array_data = 0;
    }

    // These are set in reorder_data_longitude_axis()
    char *get_array_data() const
    {
        return d_array_data;
    }
    int get_array_data_size() const
    {
        return d_array_data_size;
    }
 
    double *get_lat() const
    {
        return d_lat;
    }
    double *get_lon() const
    {
        return d_lon;
    }
    void set_lat(double *lat)
    {
        d_lat = lat;
    }
    void set_lon(double *lon)
    {
        d_lon = lon;
    }
 
    int get_lat_size() const
    {
        return d_lat_length;
    }
    int get_lon_size() const
    {
        return d_lon_length;
    }
    void set_lat_size(int len)
    {
        d_lat_length = len;
    }
    void set_lon_size(int len)
    {
        d_lon_length = len;
    }
 
    libdap::Array::Dim_iter get_lon_dim() const
    {
        return d_lon_dim;
    }
    libdap::Array::Dim_iter get_lat_dim() const
    {
        return d_lat_dim;
    }
    void set_lon_dim(libdap::Array::Dim_iter lon)
    {
        d_lon_dim = lon;
    }
    void set_lat_dim(libdap::Array::Dim_iter lat)
    {
        d_lat_dim = lat;
    }
 
    // These four are indexes of the constraint
    int get_latitude_index_top() const
    {
        return d_latitude_index_top;
    }
    int get_latitude_index_bottom() const
    {
        return d_latitude_index_bottom;
    }
    void set_latitude_index_top(int top)
    {
        d_latitude_index_top = top;
    }
    void set_latitude_index_bottom(int bottom)
    {
        d_latitude_index_bottom = bottom;
    }
 
    int get_longitude_index_left() const
    {
        return d_longitude_index_left;
    }
    int get_longitude_index_right() const
    {
        return d_longitude_index_right;
    }
    void set_longitude_index_left(int left)
    {
        d_longitude_index_left = left;
    }
    void set_longitude_index_right(int right)
    {
        d_longitude_index_right = right;
    }
 
    bool is_bounding_box_set() const
    {
        return d_bounding_box_set;
    }
    bool is_longitude_rightmost() const
    {
        return d_longitude_rightmost;
    }
    void set_longitude_rightmost(bool state)
    {
        d_longitude_rightmost = state;
    }
 
    Notation get_longitude_notation() const
    {
        return d_longitude_notation;
    }
    LatitudeSense get_latitude_sense() const
    {
        return d_latitude_sense;
    }
    void set_longitude_notation(Notation n)
    {
        d_longitude_notation = n;
    }
    void set_latitude_sense(LatitudeSense l)
    {
        d_latitude_sense = l;
    }
 
    set<string> get_coards_lat_units() const
        {
            return d_coards_lat_units;
        }
    set<string> get_coards_lon_units() const
        {
            return d_coards_lon_units;
        }
 
    set<string> get_lat_names() const
        {
            return d_lat_names;
        }
    set<string> get_lon_names() const
        {
            return d_lon_names;
        }
 
    void set_bounding_box(double top, double left, double bottom, double right);

    virtual void apply_constraint_to_data() = 0;
};
 
} // namespace libdap
 
#endif // _geo_constraint_h