#include <GeoConstraint.h>

Inheritance diagram for functions::GeoConstraint:

Public Types
enum	LatitudeSense { unknown_sense, normal, inverted }

enum	Notation { unknown_notation, pos, neg_pos }

Public Member Functions
virtual void	apply_constraint_to_data ()=0
	Once the bounding box is set use this method to apply the constraint. More...

void	set_bounding_box (double top, double left, double bottom, double right)

Constructors
	GeoConstraint ()
	Initialize GeoConstraint. More...

Accessors/Mutators
char *	get_array_data () const

int	get_array_data_size () const

double *	get_lat () const

double *	get_lon () const

void	set_lat (double *lat)

void	set_lon (double *lon)

int	get_lat_length () const

int	get_lon_length () const

void	set_lat_length (int len)

void	set_lon_length (int len)

libdap::Array::Dim_iter	get_lon_dim () const

libdap::Array::Dim_iter	get_lat_dim () const

void	set_lon_dim (libdap::Array::Dim_iter lon)

void	set_lat_dim (libdap::Array::Dim_iter lat)

int	get_latitude_index_top () const

int	get_latitude_index_bottom () const

void	set_latitude_index_top (int top)

void	set_latitude_index_bottom (int bottom)

int	get_longitude_index_left () const

int	get_longitude_index_right () const

void	set_longitude_index_left (int left)

void	set_longitude_index_right (int right)

bool	is_bounding_box_set () const

bool	is_longitude_rightmost () const

void	set_longitude_rightmost (bool state)

Notation	get_longitude_notation () const

LatitudeSense	get_latitude_sense () const

void	set_longitude_notation (Notation n)

void	set_latitude_sense (LatitudeSense l)

set< string >	get_coards_lat_units () const

set< string >	get_coards_lon_units () const

set< string >	get_lat_names () const

set< string >	get_lon_names () const

Protected Member Functions
virtual bool	build_lat_lon_maps ()=0

virtual LatitudeSense	categorize_latitude () const

Notation	categorize_notation (const double left, const double right) const

void	find_latitude_indeces (double top, double bottom, LatitudeSense sense, int &latitude_index_top, int &latitude_index_bottom) const

void	find_longitude_indeces (double left, double right, int &longitude_index_left, int &longitude_index_right) const

virtual void	flip_latitude_within_array (libdap::Array &a, int lat_length, int lon_length)

virtual bool	is_bounding_box_valid (const double left, const double top, const double right, const double bottom) const

virtual bool	lat_lon_dimensions_ok ()=0

virtual void	reorder_data_longitude_axis (libdap::Array &a, libdap::Array::Dim_iter lon_dim)

virtual void	reorder_longitude_map (int longitude_index_left)

void	transform_constraint_to_pos_notation (double &left, double &right) const

virtual void	transform_longitude_to_neg_pos_notation ()

virtual void	transform_longitude_to_pos_notation ()

virtual void	transpose_vector (double *src, const int length)

Friends
class	GridGeoConstraintTest

Detailed Description

Encapsulate the logic needed to handle geographical constraints when they are applied to DAP Grid (and some Array) variables.

This class will apply a longitude/latitude bounding box to a Grid that is a 'geo-referenced' Grid. That is, it follows the COARDS/CF conventions. This may be relaxed...

If the longitude range of the constraint crosses the boundary of the data array so that the constraint creates two separate rectangles, this class will arrange to return the result as a single Grid. It will do this by rearranging the data before control is passed onto the constraint evaluator and serialization logic. Here's a diagram of how it works:

Suppose a constraint for the longitude BB starts at the left edge of L and goes to the right edge of R:

   0.0       180.0       360.0 (longitude, in degrees)
    +----------------------+
    |xxxxxyyyyyyyyyyyyzzzzz|
    -----+            +-----
    |    |            |    |
    | R  |            | L  |
    |    |            |    |
    -----+            +-----
    |                      |
    +----------------------+

For example, suppose the client provides a bounding box that starts at 200 degrees and ends at 80. This class will first copy the Left part to new storage and then copy the right part, thus 'stitching together' the two halves of the constraint. The result looks like:

 80.0  360.0/0.0  180.0  ~200.0 (longitude, in degrees)
    +----------------------+
    |zzzzzxxxxxxyyyyyyyyyyy|
    -----++-----           |
    |    ||    |           |
    | L  || R  |           |
    |    ||    |           |
    -----++-----           |
    |                      |
    +----------------------+

The changes are made in the Grid variable itself, so once this is done the Grid should not be re-read by the CE or serialization code.

Author: James Gallagher

Definition at line 97 of file GeoConstraint.h.

Member Enumeration Documentation

◆ LatitudeSense

enum functions::GeoConstraint::LatitudeSense

Most of the time, latitude starts at the top of an array with positive values and ends up at the bottom with negative ones. But sometimes... the world is upside down.

Definition at line 112 of file GeoConstraint.h.

◆ Notation

enum functions::GeoConstraint::Notation

The longitude extents of the constraint bounding box can be expressed two ways: using a 0/359 notation and using a -180/179 notation. I call the 0/359 notation 'pos' and the -180/179 notation 'neg_pos'.

Definition at line 103 of file GeoConstraint.h.

Constructor & Destructor Documentation

◆ GeoConstraint()

functions::GeoConstraint::GeoConstraint ( )

Initialize GeoConstraint.

Definition at line 550 of file GeoConstraint.cc.

Member Function Documentation

◆ apply_constraint_to_data()

virtual void functions::GeoConstraint::apply_constraint_to_data ( )

pure virtual

Once the bounding box is set use this method to apply the constraint.

Implemented in functions::GridGeoConstraint.

◆ build_lat_lon_maps()

virtual bool functions::GeoConstraint::build_lat_lon_maps ( )

protectedpure virtual

A protected method that searches for latitude and longitude map vectors and sets six key internal fields. This method returns false if either map cannot be found.

The d_lon, d_lon_length and d_lon_dim (and matching lat) fields must be set by this method.

Returns: True if the maps are found, otherwise False

◆ categorize_latitude()

GeoConstraint::LatitudeSense functions::GeoConstraint::categorize_latitude ( ) const

protectedvirtual

Take a look at the latitude vector values and record whether the world is normal or upside down.

Returns: normal or inverted.

Definition at line 332 of file GeoConstraint.cc.

◆ categorize_notation()

GeoConstraint::Notation functions::GeoConstraint::categorize_notation	(	const double	left,
		const double	right
	)		const

protected

A private method that determines if the longitude part of the bounding box uses 0/359 or -180/179 notation. This class only supports latitude constraints which use 90/-90 notation, so there's no need to figure out what sort of notation they use.

Note: This function assumes that if one of the two values is negative, then the notation is or the -180/179 form, otherwise not. If the user asks for 30 degrees to 50 degrees (or 50 to 30, for that matter), there's no real way to tell which notation they are using.

Parameters

left	The left side of the bounding box, in degrees
right	The right side of the bounding box

Returns: The notation (pos or neg_pos)

Definition at line 106 of file GeoConstraint.cc.

◆ find_latitude_indeces()

void functions::GeoConstraint::find_latitude_indeces	(	double	top,
		double	bottom,
		LatitudeSense	sense,
		int &	latitude_index_top,
		int &	latitude_index_bottom
	)		const

protected

Scan from the top to the bottom, and the bottom to the top, looking for the top and bottom bounding box edges, respectively.

Parameters

top	The top edge of the bounding box
bottom	The bottom edge
sense	Does the array/grid store data with larger latitudes at the starting indices or are the latitude 'upside down?'
latitude_index_top	Value-result parameter that holds the index in the grid's latitude map of the top bounding box edge. Uses a closed interval for the test.
latitude_index_bottom	Value-result parameter for the bottom edge index.

Definition at line 281 of file GeoConstraint.cc.

◆ find_longitude_indeces()

void functions::GeoConstraint::find_longitude_indeces	(	double	left,
		double	right,
		int &	longitude_index_left,
		int &	longitude_index_right
	)		const

protected

Scan from the left to the right, and the right to the left, looking for the left and right bounding box edges, respectively.

Parameters

left	The left edge of the bounding box
right	The right edge
longitude_index_left	Value-result parameter that holds the index in the grid's longitude map of the left bounding box edge. Uses a closed interval for the test.
longitude_index_right	Value-result parameter for the right edge index.

Definition at line 203 of file GeoConstraint.cc.

◆ lat_lon_dimensions_ok()

virtual bool functions::GeoConstraint::lat_lon_dimensions_ok ( )

protectedpure virtual

Are the latitude and longitude dimensions ordered so that this class can properly constrain the data? This method throws Error if lat and lon are not to two 'fastest-varying' (or 'rightmost) dimensions. It sets the internal property longitude_rightmost if that's true.

Note: Called by the constructor once build_lat_lon_maps() has returned.

Returns: True if the lat/lon maps are the two rightmost maps, false otherwise

◆ reorder_data_longitude_axis()

void functions::GeoConstraint::reorder_data_longitude_axis	(	libdap::Array &	a,
		libdap::Array::Dim_iter	lon_dim
	)

protectedvirtual

Reorder the data values relative to the longitude axis so that the reordered longitude map (see GeoConstraint::reorder_longitude_map()) and the data values match.

Note: This should be called with the Array that contains the d_lon_dim Array::Dim_iter.; This method must set the d_array_data and d_array_data_size fields. If those are set, apply_constraint_to_data() will use those values.; First set all the other constraints, including the latitude and then make this call. Other constraints, besides latitude, will be simple range constraints. Latitude might require that values be flipped, but that can be done after the longitude reordering takes place.

Todo:: Fix this code so that it works with latitude as the rightmost map

Definition at line 474 of file GeoConstraint.cc.

◆ reorder_longitude_map()

void functions::GeoConstraint::reorder_longitude_map ( int longitude_index_left )

protectedvirtual

Reorder the elements in the longitude map so that the longitude constraint no longer crosses the edge of the map's storage. The d_lon field is modified.

Note: The d_lon vector always has double values regardless of the type of d_longitude.

Parameters

longitude_index_left The left edge of the bounding box.

Definition at line 435 of file GeoConstraint.cc.

◆ set_bounding_box()

void functions::GeoConstraint::set_bounding_box	(	double	top,
		double	left,
		double	bottom,
		double	right
	)

Set the bounding box for this constraint. After calling this method the object has values for the indexes for the latitude and longitude extent as well as the sense of the latitude (south pole at the top or bottom of the Array or Grid). These are used by the apply_constraint_to_data() method to actually constrain the data.

Parameters

left	The left side of the bounding box.
right	The right side
top	The top
bottom	The bottom

Definition at line 594 of file GeoConstraint.cc.

◆ transform_longitude_to_neg_pos_notation()

void functions::GeoConstraint::transform_longitude_to_neg_pos_notation ( )

protectedvirtual

Given that the Grid has a longitude map that uses the 'pos' notation, transform it to the 'neg_pos' notation. This method modifies the d_lon array.

Note: : About the two notations: 0 180 360 |------------------------—|----------------------—| 0 180,-180 0

Definition at line 164 of file GeoConstraint.cc.

◆ transform_longitude_to_pos_notation()

void functions::GeoConstraint::transform_longitude_to_pos_notation ( )

protectedvirtual

Given that the Grid has a longitude map that uses the 'neg_pos' notation, transform it to the 'pos' notation. This method modifies the d_lon array.

Note: : About the two notations: 0 180 360 |------------------------—|----------------------—| 0 180,-180 0

Definition at line 145 of file GeoConstraint.cc.

◆ transpose_vector()

void functions::GeoConstraint::transpose_vector	(	double *	src,
		const int	length
	)

protectedvirtual

Given a vector of doubles, transpose the elements. Use this to flip the latitude vector for a Grid that stores the southern latitudes at the top instead of the bottom.

Parameters

src	A pointer to the vector
length	The number of elements in the vector

Definition at line 365 of file GeoConstraint.cc.

The documentation for this class was generated from the following files:

Public Types

Public Member Functions

Protected Member Functions

Friends

Detailed Description

Member Enumeration Documentation

◆ LatitudeSense

◆ Notation

Constructor & Destructor Documentation

◆ GeoConstraint()

Member Function Documentation

◆ apply_constraint_to_data()

◆ build_lat_lon_maps()

◆ categorize_latitude()

◆ categorize_notation()

◆ find_latitude_indeces()

◆ find_longitude_indeces()

◆ lat_lon_dimensions_ok()

◆ reorder_data_longitude_axis()

◆ reorder_longitude_map()

◆ set_bounding_box()

◆ transform_longitude_to_neg_pos_notation()

◆ transform_longitude_to_pos_notation()

◆ transpose_vector()