Polygon Sponsor

Isotropy
What is isotropy?
Isotropy  Function: adjective Etymology: International
Scientific Vocabulary
: exhibiting properties (as velocity of light transmission) with the
same values when measured along axes in all directions <an isotropic
crystal>
In computational geometry things are often symmetric and
invariant to direction and orientation. This invariance to direction is
called isotropy. In such situations it is convenient to parameterize
direction or orientation and write code that is invariant to the direction or
orientation in which it is applied. To do this effectively we provide an
internally consistent set of isotropic data types to represent program
data that describes orientations and directions. These data types are:
 direction_1d  has one of the following 2 states: LOW, HIGH
 orientation_2d  has one of the following 2 states: HORIZONTAL,
VERTICAL
 direction_2d  has one of the following 4 states: WEST, EAST, SOUTH,
NORTH
 orientation_3d  has one of the following 3 states: HORIZONTAL,
VERTICAL, PROXIMAL
 direction_3d  has one of the following 6 states: WEST, EAST, SOUTH,
NORTH, DOWN, UP
The isotropic types create a system and interact with each other
in various ways, such as casting. Together they create a language for
describing isotropic situations programmatically. For instance, to get the
positive direction_2d from an orientation_2d you would call a member function of
orientation_2d and pass a direction_1d:
orientation_2d orient = HORIZONTAL;
direction_2d dir = orient.get_direction(direction_1d(HIGH));
assert(dir == EAST);
The motivation for providing isotropic data types is to
encourage programming at a higher level of abstraction where program behavior is
controlled by program data passed into function calls rather than flow control
syntax. Isotropic programming style is particularly applicable to working
with points, intervals and rectangles. Often times the implementation of
such logic is identical when implemented for the x or y coordinates, except that
the names of functions and data members are changed in a mechanical way leading
to code duplication and bloat that results in copypaste programming errors and
maintenance problems where changes made to a given code block relating to x
coordiantes are not duplicated to the code block that refers to y.
Isotropy therefore represents an opportunity to refactor and improve the quality
of low level geometry code especially in regard to interrelating coordinates,
points, intervals and rectangles.
direction_1d
The direction_1d data type has two possible states. These
are the positive and negative directions on a continuum such as the number line.
These states can be described by one of several direction_1d_enum values:
We make clockwise and counterclockwise winding orientation of polygons a
direction 1d value instead of providing a separate winding_orientation data
type. This is because winding orientation can be thought of as positive
and negative directions in a 1d (although cyclic) space. We assign
counterclockwise to be the positive direction of travel in the 1d cyclic space
to conform with the mathematical convention frequently described as the "right
hand rule" which assigns positive normal value to counterclockwise and negative
normal value to clockwise as well as the common convention that counterclockwise
polygon winding corresponds to positive polygonal regions where as clockwise
polygon winding corresponds to hole (negative) polygonal regions.
enum direction_1d_enum {LOW = 0, HIGH =
1,
LEFT = 0, RIGHT = 1,
CLOCKWISE = 0, COUNTERCLOCKWISE = 1,
REVERSE = 0, FORWARD = 1,
NEGATIVE = 0, POSITIVE = 1 };
Member Functions
direction_1d(direction_1d_enum
val = LOW) 
Constructor defaults to LOW. 
direction_1d(const
direction_1d& that) 
Copy construct. 
direction_1d(const
direction_2d& that) 
Down cast direction_2d, extracting out whether positive or negative 
direction_1d(const
direction_3d& that) 
Down cast direction_3d, extracting out whether positive or negative 
direction_1d& operator=(const direction_1d dir) 
Assignment 
direction_1d& operator==(const direction_1d dir)
const 
Equivalence 
direction_1d& operator!=(const direction_1d dir)
const 
Inequivalence 
unsigned int to_int() const 
Convert to the integer enum value of current state to use as index.
Autocast to int is disallowed for type safety reasons. 
direction_1d& backward() 
Inverts direction. 
int get_sign() const 
Returns positive 1 if positive direction and negative one if
negative direction. 
orientation_2d
The orientation_2d data type has two possible states.
These are the horizontal and vertical axis of a 2d Cartesian coordinate system.
These states can be described by one of the two orientation_2d_enum values:
enum orientation_2d_enum { HORIZONTAL =
0, VERTICAL = 1 };
Member Functions
orientation_2d(orientation_2d_enum
val = HORIZONTAL) 
Constructor defaults to HORIZONTAL. 
orientation_2d(const
orientation_2d& that) 
Copy construct. 
explicit
orientation_2d(const
direction_2d& that) 
Down cast direction_2d, extracting out whether horizontal or
vertical direction type 
orientation_2d& operator=(const orientation_2d
o) 
Assignment 
orientation_2d& operator==(const orientation_2d
o) const 
Equivalence 
orientation_2d& operator!=(const orientation_2d
o) const 
Inequivalence 
unsigned int to_int() const 
Convert to the integer enum value of current state to use as index.
Autocast to int is disallowed for type safety reasons 
orientation_2d& turn_90() 
Change to orthogonal orientation 
int get_perpendicular() const 
Returns orthogonal orientation 
int get_direction(direction_1d dir) const 
Returns the positive or negative direction_2d depending on the value
of dir 
direction_2d
The direction_2d data type has four possible states. These
are the cardinal directions of the 2D Cartesian coordinate system.
These states can be described by one of several direction_2d_enum values:
enum direction_2d_enum { WEST = 0, EAST
= 1, SOUTH = 2, NORTH = 3 };
Member Functions
direction_2d(direction_2d_enum
val = WEST) 
Constructor defaults to WEST. 
direction_2d(const
direction_2d& that) 
Copy construct. 
direction_1d& operator=(const direction_2d dir) 
Assignment 
direction_1d& operator==(const direction_2d dir)
const 
Equivalence 
direction_1d& operator!=(const direction_2d dir)
const 
Inequivalence 
unsigned int to_int() const 
Convert to the integer enum value of current state to use as index.
Autocast to int is disallowed for type safety reasons. 
direction_2d& backward() 
Inverts direction. 
direction_2d& turn(direction_1d dir) 
Changes to direction_2d to the left if dir is LOW, to the right if
dir is HIGH 
direction_2d& left() 
Changes to the direction_2d to the left 
direction_2d& right() 
Changes to the direction_2d to the right 
int is_positive() const 
Returns true if EAST or NORTH 
int is_negative() const 
Returns true if WEST or SOUTH 
int get_sign() const 
Returns positive 1 if positive direction and negative one if
negative direction. 
orientation_3d
The orientation_3d data type has three possible states.
These are the horizontal, vertical and proximal (x, y, z) axis of a 3d Cartesian
coordinate system. These states can be described by one of the
orientation_2d_enum values or by the orientation_3d_enum value:
enum orientation_3d_enum { PROXIMAL = 2
};
Member Functions
orientation_3d(orientation_2d_enum
val = HORIZONTAL) 
Constructor defaults to HORIZONTAL. 
orientation_3d(const
orientation_3d& that) 
Copy construct. 
explicit
orientation_3d(const
direction_2d& that) 
Extract out the orientation of the direction 
explicit
orientation_3d(const
direction_3d& that) 
Extract out the orientation of the direction 
orientation_3d(const
orientation_2d& that) 
Up cast orientation_2d to orientation_3d. 
orientation_3d(const
orientation_3d_enum& that) 
Construct from constant value 
orientation_3d& operator=(const orientation_3d
o) 
Assignment 
orientation_3d& operator==(const orientation_3d
o) const 
Equivalence 
orientation_3d& operator!=(const orientation_3d
o) const 
Inequivalence 
unsigned int to_int() const 
Convert to the integer enum value of current state to use as index.
Autocast to int is disallowed for type safety reasons 
int get_direction(direction_1d dir) const 
Returns the positive or negative direction_2d depending on the value
of dir 
direction_3d
The direction_3d data type has six possible states. These
are the cardinal directions of the 3D Cartesian coordinate system.
These states can be described by one of the direction_2d_enum values or the
direction_3d_enum values:
enum direction_3d_enum { DOWN = 4, UP =
5 };
Member Functions
direction_3d(direction_2d_enum
val = WEST) 
Constructor defaults to LOW. 
direction_3d(direction_3d_enum that) 
Construct from constant value 
direction_3d(const
direction_3d& that) 
Copy construct 
direction_3d(direction_2d that) 
Up cast direction_2d to direction_3d 
direction_3d& operator=(const direction_3d dir) 
Assignment 
direction_3d& operator==(const direction_3d dir)
const 
Equivalence 
direction_2d& operator!=(const direction_3d dir)
const 
Inequivalence 
unsigned int to_int() const 
Convert to the integer enum value of current state to use as index.
Autocast to int is disallowed for type safety reasons. 
direction_1d& backward() 
Inverts direction. 
int is_positive() const 
Returns true if direction is EAST, NORTH or UP. 
int is_negative() const 
Returns true if direction is WEST, SOUTH or DOWN 
int get_sign() const 
Returns positive 1 if positive direction and negative one if
negative direction. 
