third_party/boost/include/boost/polygon/transform.hpp - webm/webmlive - Git at Google

 /*
     Copyright 2008 Intel Corporation

     Use, modification and distribution are subject to the Boost Software License,
     Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
     http://www.boost.org/LICENSE_1_0.txt).
 */
 #ifndef BOOST_POLYGON_TRANSFORM_HPP
 #define BOOST_POLYGON_TRANSFORM_HPP
 #include "isotropy.hpp"
 #include "point_3d_concept.hpp"
 namespace boost { namespace polygon{
 // Transformation of Coordinate Systems
 // Enum meaning:
 // Select which direction_3d to change the positive direction of each
 // axis in the old coordinate system to map it to the new coordiante system.
 // The first direction_3d listed for each enum is the direction to map the
 // positive horizontal direction to.
 // The second direction_3d listed for each enum is the direction to map the
 // positive vertical direction to.
 // The third direction_3d listed for each enum is the direction to map the
 // positive proximal direction to.
 // The zero position bit (LSB) indicates whether the horizontal axis flips
 // when transformed.
 // The 1st postion bit indicates whether the vertical axis flips when
 // transformed.
 // The 2nd position bit indicates whether the horizontal and vertical axis
 // swap positions when transformed.
 // Note that the first eight values are the complete set of 2D transforms.
 // The 3rd position bit indicates whether the proximal axis flips when
 // transformed.
 // The 4th position bit indicates whether the proximal and horizontal axis are
 // swapped when transformed.  It changes the meaning of the 2nd position bit
 // to mean that the horizontal and vertical axis are swapped in their new
 // positions, naturally.
 // The 5th position bit (MSB) indicates whether the proximal and vertical axis
 // are swapped when transformed.  It is mutually exclusive with the 4th postion
 // bit, making the maximum legal value 48 (decimal).  It similarly changes the
 // meaning of the 2nd position bit to mean that the horizontal and vertical are
 // swapped in their new positions.
 // Enum Values:
 // 000000 EAST NORTH UP
 // 000001 WEST NORTH UP
 // 000010 EAST SOUTH UP
 // 000011 WEST SOUTH UP
 // 000100 NORTH EAST UP
 // 000101 SOUTH EAST UP
 // 000110 NORTH WEST UP
 // 000111 SOUTH WEST UP
 // 001000 EAST NORTH DOWN
 // 001001 WEST NORTH DOWN
 // 001010 EAST SOUTH DOWN
 // 001011 WEST SOUTH DOWN
 // 001100 NORTH EAST DOWN
 // 001101 SOUTH EAST DOWN
 // 001110 NORTH WEST DOWN
 // 001111 SOUTH WEST DOWN
 // 010000 UP NORTH EAST
 // 010001 DOWN NORTH EAST
 // 010010 UP SOUTH EAST
 // 010011 DOWN SOUTH EAST
 // 010100 NORTH UP EAST
 // 010101 SOUTH UP EAST
 // 010110 NORTH DOWN EAST
 // 010111 SOUTH DOWN EAST
 // 011000 UP NORTH WEST
 // 011001 DOWN NORTH WEST
 // 011010 UP SOUTH WEST
 // 011011 DOWN SOUTH WEST
 // 011100 NORTH UP WEST
 // 011101 SOUTH UP WEST
 // 011110 NORTH DOWN WEST
 // 011111 SOUTH DOWN WEST
 // 100000 EAST UP NORTH
 // 100001 WEST UP NORTH
 // 100010 EAST DOWN NORTH
 // 100011 WEST DOWN NORTH
 // 100100 UP EAST NORTH
 // 100101 DOWN EAST NORTH
 // 100110 UP WEST NORTH
 // 100111 DOWN WEST NORTH
 // 101000 EAST UP SOUTH
 // 101001 WEST UP SOUTH
 // 101010 EAST DOWN SOUTH
 // 101011 WEST DOWN SOUTH
 // 101100 UP EAST SOUTH
 // 101101 DOWN EAST SOUTH
 // 101110 UP WEST SOUTH
 // 101111 DOWN WEST SOUTH
 class axis_transformation {
 public:
   // Enum Names and values
   // NULL_TRANSFORM = 0, BEGIN_TRANSFORM = 0,
   // ENU = 0, EAST_NORTH_UP = 0, EN = 0, EAST_NORTH = 0,
   // WNU = 1, WEST_NORTH_UP = 1, WN = 1, WEST_NORTH = 1, FLIP_X = 1,
   // ESU = 2, EAST_SOUTH_UP = 2, ES = 2, EAST_SOUTH = 2, FLIP_Y = 2,
   // WSU = 3, WEST_SOUTH_UP = 3, WS = 3, WEST_SOUTH = 3,
   // NEU = 4, NORTH_EAST_UP = 4, NE = 4, NORTH_EAST = 4, SWAP_XY = 4,
   // SEU = 5, SOUTH_EAST_UP = 5, SE = 5, SOUTH_EAST = 5,
   // NWU = 6, NORTH_WEST_UP = 6, NW = 6, NORTH_WEST = 6,
   // SWU = 7, SOUTH_WEST_UP = 7, SW = 7, SOUTH_WEST = 7,
   // END_2D_TRANSFORM = 7,
   // END = 8, EAST_NORTH_DOWN = 8,
   // WND = 9, WEST_NORTH_DOWN = 9,
   // ESD = 10, EAST_SOUTH_DOWN = 10,
   // WSD = 11, WEST_SOUTH_DOWN = 11,
   // NED = 12, NORTH_EAST_DOWN = 12,
   // SED = 13, SOUTH_EAST_DOWN = 13,
   // NWD = 14, NORTH_WEST_DOWN = 14,
   // SWD = 15, SOUTH_WEST_DOWN = 15,
   // UNE = 16, UP_NORTH_EAST = 16,
   // DNE = 17, DOWN_NORTH_EAST = 17,
   // USE = 18, UP_SOUTH_EAST = 18,
   // DSE = 19, DOWN_SOUTH_EAST = 19,
   // NUE = 20, NORTH_UP_EAST = 20,
   // SUE = 21, SOUTH_UP_EAST = 21,
   // NDE = 22, NORTH_DOWN_EAST = 22,
   // SDE = 23, SOUTH_DOWN_EAST = 23,
   // UNW = 24, UP_NORTH_WEST = 24,
   // DNW = 25, DOWN_NORTH_WEST = 25,
   // USW = 26, UP_SOUTH_WEST = 26,
   // DSW = 27, DOWN_SOUTH_WEST = 27,
   // NUW = 28, NORTH_UP_WEST = 28,
   // SUW = 29, SOUTH_UP_WEST = 29,
   // NDW = 30, NORTH_DOWN_WEST = 30,
   // SDW = 31, SOUTH_DOWN_WEST = 31,
   // EUN = 32, EAST_UP_NORTH = 32,
   // WUN = 33, WEST_UP_NORTH = 33,
   // EDN = 34, EAST_DOWN_NORTH = 34,
   // WDN = 35, WEST_DOWN_NORTH = 35,
   // UEN = 36, UP_EAST_NORTH = 36,
   // DEN = 37, DOWN_EAST_NORTH = 37,
   // UWN = 38, UP_WEST_NORTH = 38,
   // DWN = 39, DOWN_WEST_NORTH = 39,
   // EUS = 40, EAST_UP_SOUTH = 40,
   // WUS = 41, WEST_UP_SOUTH = 41,
   // EDS = 42, EAST_DOWN_SOUTH = 42,
   // WDS = 43, WEST_DOWN_SOUTH = 43,
   // UES = 44, UP_EAST_SOUTH = 44,
   // DES = 45, DOWN_EAST_SOUTH = 45,
   // UWS = 46, UP_WEST_SOUTH = 46,
   // DWS = 47, DOWN_WEST_SOUTH = 47, END_TRANSFORM = 47
   enum ATR {
     NULL_TRANSFORM = 0, BEGIN_TRANSFORM = 0,
     ENU = 0, EAST_NORTH_UP = 0, EN = 0, EAST_NORTH = 0,
     WNU = 1, WEST_NORTH_UP = 1, WN = 1, WEST_NORTH = 1, FLIP_X       = 1,
     ESU = 2, EAST_SOUTH_UP = 2, ES = 2, EAST_SOUTH = 2, FLIP_Y       = 2,
     WSU = 3, WEST_SOUTH_UP = 3, WS = 3, WEST_SOUTH = 3, FLIP_XY      = 3,
     NEU = 4, NORTH_EAST_UP = 4, NE = 4, NORTH_EAST = 4, SWAP_XY      = 4,
     SEU = 5, SOUTH_EAST_UP = 5, SE = 5, SOUTH_EAST = 5, ROTATE_LEFT  = 5,
     NWU = 6, NORTH_WEST_UP = 6, NW = 6, NORTH_WEST = 6, ROTATE_RIGHT = 6,
     SWU = 7, SOUTH_WEST_UP = 7, SW = 7, SOUTH_WEST = 7, FLIP_SWAP_XY = 7, END_2D_TRANSFORM = 7,
     END = 8, EAST_NORTH_DOWN = 8, FLIP_Z = 8,
     WND = 9, WEST_NORTH_DOWN = 9,
     ESD = 10, EAST_SOUTH_DOWN = 10,
     WSD = 11, WEST_SOUTH_DOWN = 11,
     NED = 12, NORTH_EAST_DOWN = 12,
     SED = 13, SOUTH_EAST_DOWN = 13,
     NWD = 14, NORTH_WEST_DOWN = 14,
     SWD = 15, SOUTH_WEST_DOWN = 15,
     UNE = 16, UP_NORTH_EAST = 16,
     DNE = 17, DOWN_NORTH_EAST = 17,
     USE = 18, UP_SOUTH_EAST = 18,
     DSE = 19, DOWN_SOUTH_EAST = 19,
     NUE = 20, NORTH_UP_EAST = 20,
     SUE = 21, SOUTH_UP_EAST = 21,
     NDE = 22, NORTH_DOWN_EAST = 22,
     SDE = 23, SOUTH_DOWN_EAST = 23,
     UNW = 24, UP_NORTH_WEST = 24,
     DNW = 25, DOWN_NORTH_WEST = 25,
     USW = 26, UP_SOUTH_WEST = 26,
     DSW = 27, DOWN_SOUTH_WEST = 27,
     NUW = 28, NORTH_UP_WEST = 28,
     SUW = 29, SOUTH_UP_WEST = 29,
     NDW = 30, NORTH_DOWN_WEST = 30,
     SDW = 31, SOUTH_DOWN_WEST = 31,
     EUN = 32, EAST_UP_NORTH = 32,
     WUN = 33, WEST_UP_NORTH = 33,
     EDN = 34, EAST_DOWN_NORTH = 34,
     WDN = 35, WEST_DOWN_NORTH = 35,
     UEN = 36, UP_EAST_NORTH = 36,
     DEN = 37, DOWN_EAST_NORTH = 37,
     UWN = 38, UP_WEST_NORTH = 38,
     DWN = 39, DOWN_WEST_NORTH = 39,
     EUS = 40, EAST_UP_SOUTH = 40,
     WUS = 41, WEST_UP_SOUTH = 41,
     EDS = 42, EAST_DOWN_SOUTH = 42,
     WDS = 43, WEST_DOWN_SOUTH = 43,
     UES = 44, UP_EAST_SOUTH = 44,
     DES = 45, DOWN_EAST_SOUTH = 45,
     UWS = 46, UP_WEST_SOUTH = 46,
     DWS = 47, DOWN_WEST_SOUTH = 47, END_TRANSFORM = 47
   };

   // Individual axis enum values indicate which axis an implicit individual
   // axis will be mapped to.
   // The value of the enum paired with an axis provides the information
   // about what the axis will transform to.
   // Three individual axis values, one for each axis, are equivalent to one
   // ATR enum value, but easier to work with because they are independent.
   // Converting to and from the individual axis values from the ATR value
   // is a convenient way to implement tranformation related functionality.
   // Enum meanings:
   // PX: map to positive x axis
   // NX: map to negative x axis
   // PY: map to positive y axis
   // NY: map to negative y axis
   // PZ: map to positive z axis
   // NZ: map to negative z axis
   enum INDIVIDUAL_AXIS {
     PX = 0,
     NX = 1,
     PY = 2,
     NY = 3,
     PZ = 4,
     NZ = 5
   };

   inline axis_transformation() : atr_(NULL_TRANSFORM) {}
   inline axis_transformation(ATR atr) : atr_(atr) {}
   inline axis_transformation(const axis_transformation& atr) : atr_(atr.atr_) {}
   explicit axis_transformation(const orientation_3d& orient);
   explicit axis_transformation(const direction_3d& dir);
   explicit axis_transformation(const orientation_2d& orient);
   explicit axis_transformation(const direction_2d& dir);

   // assignment operator
   axis_transformation& operator=(const axis_transformation& a);

   // assignment operator
   axis_transformation& operator=(const ATR& atr);

   // equivalence operator
   bool operator==(const axis_transformation& a) const;

   // inequivalence operator
   bool operator!=(const axis_transformation& a) const;

   // ordering
   bool operator<(const axis_transformation& a) const;

   // concatenation operator
   axis_transformation operator+(const axis_transformation& a) const;

   // concatenate this with that
   axis_transformation& operator+=(const axis_transformation& a);

   // populate_axis_array writes the three INDIVIDUAL_AXIS values that the
   // ATR enum value of 'this' represent into axis_array
   void populate_axis_array(INDIVIDUAL_AXIS axis_array[]) const;

   // it is recommended that the directions stored in an array
   // in the caller code for easier isotropic access by orientation value
   inline void get_directions(direction_2d& horizontal_dir,
                              direction_2d& vertical_dir) const {
     bool bit2 = (atr_ & 4) != 0;
     bool bit1 = (atr_ & 2) != 0;
     bool bit0 = (atr_ & 1) != 0;
     vertical_dir = direction_2d((direction_2d_enum)(((int)(!bit2) << 1) + !bit1));
     horizontal_dir = direction_2d((direction_2d_enum)(((int)(bit2) << 1) + !bit0));
   }

   // it is recommended that the directions stored in an array
   // in the caller code for easier isotropic access by orientation value
   inline void get_directions(direction_3d& horizontal_dir,
                              direction_3d& vertical_dir,
                              direction_3d& proximal_dir) const {
     bool bit5 = (atr_ & 32) != 0;
     bool bit4 = (atr_ & 16) != 0;
     bool bit3 = (atr_ & 8) != 0;
     bool bit2 = (atr_ & 4) != 0;
     bool bit1 = (atr_ & 2) != 0;
     bool bit0 = (atr_ & 1) != 0;
     proximal_dir = direction_3d((direction_2d_enum)((((int)(!bit4 & !bit5)) << 2) +
                                                     ((int)(bit5) << 1) +
                                                     !bit3));
     vertical_dir = direction_3d((direction_2d_enum)((((int)((bit4 & bit2) | (bit5 & !bit2))) << 2)+
                                                     ((int)(!bit5 & !bit2) << 1) +
                                                     !bit1));
     horizontal_dir = direction_3d((direction_2d_enum)((((int)((bit5 & bit2) |
                                                               (bit4 & !bit2))) << 2) +
                                                       ((int)(bit2 & !bit5) << 1) +
                                                       !bit0));
   }

   // combine_axis_arrays concatenates this_array and that_array overwriting
   // the result into this_array
   static void combine_axis_arrays (INDIVIDUAL_AXIS this_array[],
                                    const INDIVIDUAL_AXIS that_array[]);

   // write_back_axis_array converts an array of three INDIVIDUAL_AXIS values
   // to the ATR enum value and sets 'this' to that value
   void write_back_axis_array(const INDIVIDUAL_AXIS this_array[]);

   // behavior is deterministic but undefined in the case where illegal
   // combinations of directions are passed in.
   axis_transformation& set_directions(const direction_2d& horizontal_dir,
                                  const direction_2d& vertical_dir);
   // behavior is deterministic but undefined in the case where illegal
   // combinations of directions are passed in.
   axis_transformation& set_directions(const direction_3d& horizontal_dir,
                                  const direction_3d& vertical_dir,
                                  const direction_3d& proximal_dir);

   // transform the two coordinates by reference using the 2D portion of this
   template <typename coordinate_type>
   void transform(coordinate_type& x, coordinate_type& y) const;

   // transform the three coordinates by reference
   template <typename coordinate_type>
   void transform(coordinate_type& x, coordinate_type& y, coordinate_type& z) const;

   // invert the 2D portion of this
   axis_transformation& invert_2d();

   // get the inverse of the 2D portion of this
   axis_transformation inverse_2d() const;

   // invert this axis_transformation
   axis_transformation& invert();

   // get the inverse axis_transformation of this
   axis_transformation inverse() const;

   //friend std::ostream& operator<< (std::ostream& o, const axis_transformation& r);
   //friend std::istream& operator>> (std::istream& i, axis_transformation& r);

 private:
   ATR atr_;
 };


 // Scaling object to be used to store the scale factor for each axis

 // For use by the transformation object, in that context the scale factor
 // is the amount that each axis scales by when transformed.
 // If the horizontal value of the Scale is 10 that means the horizontal
 // axis of the input is multiplied by 10 when the transformation is applied.
 template <typename scale_factor_type>
 class anisotropic_scale_factor {
 public:
   inline anisotropic_scale_factor()
 #ifndef BOOST_POLYGON_MSVC
     : scale_()
 #endif
   {
     scale_[0] = 1;
     scale_[1] = 1;
     scale_[2] = 1;
   }
   inline anisotropic_scale_factor(scale_factor_type xscale, scale_factor_type yscale)
 #ifndef BOOST_POLYGON_MSVC
     : scale_()
 #endif
   {
     scale_[0] = xscale;
     scale_[1] = yscale;
     scale_[2] = 1;
   }
   inline anisotropic_scale_factor(scale_factor_type xscale, scale_factor_type yscale, scale_factor_type zscale)
 #ifndef BOOST_POLYGON_MSVC
     : scale_()
 #endif
   {
     scale_[0] = xscale;
     scale_[1] = yscale;
     scale_[2] = zscale;
   }

   // get a component of the anisotropic_scale_factor by orientation
   scale_factor_type get(orientation_3d orient) const;
   scale_factor_type get(orientation_2d orient) const { return get(orientation_3d(orient)); }

   // set a component of the anisotropic_scale_factor by orientation
   void set(orientation_3d orient, scale_factor_type value);
   void set(orientation_2d orient, scale_factor_type value) { set(orientation_3d(orient), value); }

   scale_factor_type x() const;
   scale_factor_type y() const;
   scale_factor_type z() const;
   void x(scale_factor_type value);
   void y(scale_factor_type value);
   void z(scale_factor_type value);

   // concatination operator (convolve scale factors)
   anisotropic_scale_factor operator+(const anisotropic_scale_factor& s) const;

   // concatinate this with that
   const anisotropic_scale_factor& operator+=(const anisotropic_scale_factor& s);

   // transform this scale with an axis_transform
   anisotropic_scale_factor& transform(axis_transformation atr);

   // scale the two coordinates
   template <typename coordinate_type>
   void scale(coordinate_type& x, coordinate_type& y) const;

   // scale the three coordinates
   template <typename coordinate_type>
   void scale(coordinate_type& x, coordinate_type& y, coordinate_type& z) const;

   // invert this scale factor to give the reverse scale factor
   anisotropic_scale_factor& invert();

 private:
   scale_factor_type scale_[3];

   //friend std::ostream& operator<< (std::ostream& o, const Scale& r);
   //friend std::istream& operator>> (std::istream& i, Scale& r);
 };

 // Transformation object, stores and provides services for transformations

 // Transformation object stores an axistransformation, a scale factor and a translation.
 // The tranlation is the position of the origin of the new system of coordinates in the old system.
 // The scale scales the coordinates before they are transformed.
 template <typename coordinate_type>
 class transformation {
 public:
   transformation();
   transformation(axis_transformation atr);
   transformation(axis_transformation::ATR atr);
   template <typename point_type>
   transformation(const point_type& p);
   template <typename point_type>
   transformation(axis_transformation atr, const point_type& p);
   template <typename point_type>
   transformation(axis_transformation atr, const point_type& referencePt, const point_type& destinationPt);
   transformation(const transformation& tr);

   // equivalence operator
   bool operator==(const transformation& tr) const;

   // inequivalence operator
   bool operator!=(const transformation& tr) const;

   // ordering
   bool operator<(const transformation& tr) const;

   // concatenation operator
   transformation operator+(const transformation& tr) const;

   // concatenate this with that
   const transformation& operator+=(const transformation& tr);

   // get the axis_transformation portion of this
   inline axis_transformation get_axis_transformation() const {return atr_;}

   // set the axis_transformation portion of this
   void set_axis_transformation(const axis_transformation& atr);

   // get the translation portion of this as a point3d
   template <typename point_type>
   void get_translation(point_type& translation) const;

   // set the translation portion of this with a point3d
   template <typename point_type>
   void set_translation(const point_type& p);

   // apply the 2D portion of this transformation to the two coordinates given
   void transform(coordinate_type& x, coordinate_type& y) const;

   // apply this transformation to the three coordinates given
   void transform(coordinate_type& x, coordinate_type& y, coordinate_type& z) const;

   // invert this transformation
   transformation& invert();

   // get the inverse of this transformation
   transformation inverse() const;

   inline void get_directions(direction_2d& horizontal_dir,
                              direction_2d& vertical_dir) const {
     return atr_.get_directions(horizontal_dir, vertical_dir); }

   inline void get_directions(direction_3d& horizontal_dir,
                              direction_3d& vertical_dir,
                              direction_3d& proximal_dir) const {
     return atr_.get_directions(horizontal_dir, vertical_dir, proximal_dir); }

 private:
   axis_transformation atr_;
   point_3d_data<coordinate_type> p_;

   template <typename point_type>
   void construct_dispatch(axis_transformation atr, point_type p, point_concept tag);
   template <typename point_type>
   void construct_dispatch(axis_transformation atr, point_type p, point_3d_concept tag);
   template <typename point_type>
   void construct_dispatch(axis_transformation atr, point_type rp, point_type dp, point_concept tag);
   template <typename point_type>
   void construct_dispatch(axis_transformation atr, point_type rp, point_type dp, point_3d_concept tag);

   //friend std::ostream& operator<< (std::ostream& o, const transformation& tr);
   //friend std::istream& operator>> (std::istream& i, transformation& tr);
 };
 }
 }
 #include "detail/transform_detail.hpp"
 #endif
	/*
	Copyright 2008 Intel Corporation

	Use, modification and distribution are subject to the Boost Software License,
	Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
	http://www.boost.org/LICENSE_1_0.txt).
	*/
	#ifndef BOOST_POLYGON_TRANSFORM_HPP
	#define BOOST_POLYGON_TRANSFORM_HPP
	#include "isotropy.hpp"
	#include "point_3d_concept.hpp"
	namespace boost { namespace polygon{
	// Transformation of Coordinate Systems
	// Enum meaning:
	// Select which direction_3d to change the positive direction of each
	// axis in the old coordinate system to map it to the new coordiante system.
	// The first direction_3d listed for each enum is the direction to map the
	// positive horizontal direction to.
	// The second direction_3d listed for each enum is the direction to map the
	// positive vertical direction to.
	// The third direction_3d listed for each enum is the direction to map the
	// positive proximal direction to.
	// The zero position bit (LSB) indicates whether the horizontal axis flips
	// when transformed.
	// The 1st postion bit indicates whether the vertical axis flips when
	// transformed.
	// The 2nd position bit indicates whether the horizontal and vertical axis
	// swap positions when transformed.
	// Note that the first eight values are the complete set of 2D transforms.
	// The 3rd position bit indicates whether the proximal axis flips when
	// transformed.
	// The 4th position bit indicates whether the proximal and horizontal axis are
	// swapped when transformed. It changes the meaning of the 2nd position bit
	// to mean that the horizontal and vertical axis are swapped in their new
	// positions, naturally.
	// The 5th position bit (MSB) indicates whether the proximal and vertical axis
	// are swapped when transformed. It is mutually exclusive with the 4th postion
	// bit, making the maximum legal value 48 (decimal). It similarly changes the
	// meaning of the 2nd position bit to mean that the horizontal and vertical are
	// swapped in their new positions.
	// Enum Values:
	// 000000 EAST NORTH UP
	// 000001 WEST NORTH UP
	// 000010 EAST SOUTH UP
	// 000011 WEST SOUTH UP
	// 000100 NORTH EAST UP
	// 000101 SOUTH EAST UP
	// 000110 NORTH WEST UP
	// 000111 SOUTH WEST UP
	// 001000 EAST NORTH DOWN
	// 001001 WEST NORTH DOWN
	// 001010 EAST SOUTH DOWN
	// 001011 WEST SOUTH DOWN
	// 001100 NORTH EAST DOWN
	// 001101 SOUTH EAST DOWN
	// 001110 NORTH WEST DOWN
	// 001111 SOUTH WEST DOWN
	// 010000 UP NORTH EAST
	// 010001 DOWN NORTH EAST
	// 010010 UP SOUTH EAST
	// 010011 DOWN SOUTH EAST
	// 010100 NORTH UP EAST
	// 010101 SOUTH UP EAST
	// 010110 NORTH DOWN EAST
	// 010111 SOUTH DOWN EAST
	// 011000 UP NORTH WEST
	// 011001 DOWN NORTH WEST
	// 011010 UP SOUTH WEST
	// 011011 DOWN SOUTH WEST
	// 011100 NORTH UP WEST
	// 011101 SOUTH UP WEST
	// 011110 NORTH DOWN WEST
	// 011111 SOUTH DOWN WEST
	// 100000 EAST UP NORTH
	// 100001 WEST UP NORTH
	// 100010 EAST DOWN NORTH
	// 100011 WEST DOWN NORTH
	// 100100 UP EAST NORTH
	// 100101 DOWN EAST NORTH
	// 100110 UP WEST NORTH
	// 100111 DOWN WEST NORTH
	// 101000 EAST UP SOUTH
	// 101001 WEST UP SOUTH
	// 101010 EAST DOWN SOUTH
	// 101011 WEST DOWN SOUTH
	// 101100 UP EAST SOUTH
	// 101101 DOWN EAST SOUTH
	// 101110 UP WEST SOUTH
	// 101111 DOWN WEST SOUTH
	class axis_transformation {
	public:
	// Enum Names and values
	// NULL_TRANSFORM = 0, BEGIN_TRANSFORM = 0,
	// ENU = 0, EAST_NORTH_UP = 0, EN = 0, EAST_NORTH = 0,
	// WNU = 1, WEST_NORTH_UP = 1, WN = 1, WEST_NORTH = 1, FLIP_X = 1,
	// ESU = 2, EAST_SOUTH_UP = 2, ES = 2, EAST_SOUTH = 2, FLIP_Y = 2,
	// WSU = 3, WEST_SOUTH_UP = 3, WS = 3, WEST_SOUTH = 3,
	// NEU = 4, NORTH_EAST_UP = 4, NE = 4, NORTH_EAST = 4, SWAP_XY = 4,
	// SEU = 5, SOUTH_EAST_UP = 5, SE = 5, SOUTH_EAST = 5,
	// NWU = 6, NORTH_WEST_UP = 6, NW = 6, NORTH_WEST = 6,
	// SWU = 7, SOUTH_WEST_UP = 7, SW = 7, SOUTH_WEST = 7,
	// END_2D_TRANSFORM = 7,
	// END = 8, EAST_NORTH_DOWN = 8,
	// WND = 9, WEST_NORTH_DOWN = 9,
	// ESD = 10, EAST_SOUTH_DOWN = 10,
	// WSD = 11, WEST_SOUTH_DOWN = 11,
	// NED = 12, NORTH_EAST_DOWN = 12,
	// SED = 13, SOUTH_EAST_DOWN = 13,
	// NWD = 14, NORTH_WEST_DOWN = 14,
	// SWD = 15, SOUTH_WEST_DOWN = 15,
	// UNE = 16, UP_NORTH_EAST = 16,
	// DNE = 17, DOWN_NORTH_EAST = 17,
	// USE = 18, UP_SOUTH_EAST = 18,
	// DSE = 19, DOWN_SOUTH_EAST = 19,
	// NUE = 20, NORTH_UP_EAST = 20,
	// SUE = 21, SOUTH_UP_EAST = 21,
	// NDE = 22, NORTH_DOWN_EAST = 22,
	// SDE = 23, SOUTH_DOWN_EAST = 23,
	// UNW = 24, UP_NORTH_WEST = 24,
	// DNW = 25, DOWN_NORTH_WEST = 25,
	// USW = 26, UP_SOUTH_WEST = 26,
	// DSW = 27, DOWN_SOUTH_WEST = 27,
	// NUW = 28, NORTH_UP_WEST = 28,
	// SUW = 29, SOUTH_UP_WEST = 29,
	// NDW = 30, NORTH_DOWN_WEST = 30,
	// SDW = 31, SOUTH_DOWN_WEST = 31,
	// EUN = 32, EAST_UP_NORTH = 32,
	// WUN = 33, WEST_UP_NORTH = 33,
	// EDN = 34, EAST_DOWN_NORTH = 34,
	// WDN = 35, WEST_DOWN_NORTH = 35,
	// UEN = 36, UP_EAST_NORTH = 36,
	// DEN = 37, DOWN_EAST_NORTH = 37,
	// UWN = 38, UP_WEST_NORTH = 38,
	// DWN = 39, DOWN_WEST_NORTH = 39,
	// EUS = 40, EAST_UP_SOUTH = 40,
	// WUS = 41, WEST_UP_SOUTH = 41,
	// EDS = 42, EAST_DOWN_SOUTH = 42,
	// WDS = 43, WEST_DOWN_SOUTH = 43,
	// UES = 44, UP_EAST_SOUTH = 44,
	// DES = 45, DOWN_EAST_SOUTH = 45,
	// UWS = 46, UP_WEST_SOUTH = 46,
	// DWS = 47, DOWN_WEST_SOUTH = 47, END_TRANSFORM = 47
	enum ATR {
	NULL_TRANSFORM = 0, BEGIN_TRANSFORM = 0,
	ENU = 0, EAST_NORTH_UP = 0, EN = 0, EAST_NORTH = 0,
	WNU = 1, WEST_NORTH_UP = 1, WN = 1, WEST_NORTH = 1, FLIP_X = 1,
	ESU = 2, EAST_SOUTH_UP = 2, ES = 2, EAST_SOUTH = 2, FLIP_Y = 2,
	WSU = 3, WEST_SOUTH_UP = 3, WS = 3, WEST_SOUTH = 3, FLIP_XY = 3,
	NEU = 4, NORTH_EAST_UP = 4, NE = 4, NORTH_EAST = 4, SWAP_XY = 4,
	SEU = 5, SOUTH_EAST_UP = 5, SE = 5, SOUTH_EAST = 5, ROTATE_LEFT = 5,
	NWU = 6, NORTH_WEST_UP = 6, NW = 6, NORTH_WEST = 6, ROTATE_RIGHT = 6,
	SWU = 7, SOUTH_WEST_UP = 7, SW = 7, SOUTH_WEST = 7, FLIP_SWAP_XY = 7, END_2D_TRANSFORM = 7,
	END = 8, EAST_NORTH_DOWN = 8, FLIP_Z = 8,
	WND = 9, WEST_NORTH_DOWN = 9,
	ESD = 10, EAST_SOUTH_DOWN = 10,
	WSD = 11, WEST_SOUTH_DOWN = 11,
	NED = 12, NORTH_EAST_DOWN = 12,
	SED = 13, SOUTH_EAST_DOWN = 13,
	NWD = 14, NORTH_WEST_DOWN = 14,
	SWD = 15, SOUTH_WEST_DOWN = 15,
	UNE = 16, UP_NORTH_EAST = 16,
	DNE = 17, DOWN_NORTH_EAST = 17,
	USE = 18, UP_SOUTH_EAST = 18,
	DSE = 19, DOWN_SOUTH_EAST = 19,
	NUE = 20, NORTH_UP_EAST = 20,
	SUE = 21, SOUTH_UP_EAST = 21,
	NDE = 22, NORTH_DOWN_EAST = 22,
	SDE = 23, SOUTH_DOWN_EAST = 23,
	UNW = 24, UP_NORTH_WEST = 24,
	DNW = 25, DOWN_NORTH_WEST = 25,
	USW = 26, UP_SOUTH_WEST = 26,
	DSW = 27, DOWN_SOUTH_WEST = 27,
	NUW = 28, NORTH_UP_WEST = 28,
	SUW = 29, SOUTH_UP_WEST = 29,
	NDW = 30, NORTH_DOWN_WEST = 30,
	SDW = 31, SOUTH_DOWN_WEST = 31,
	EUN = 32, EAST_UP_NORTH = 32,
	WUN = 33, WEST_UP_NORTH = 33,
	EDN = 34, EAST_DOWN_NORTH = 34,
	WDN = 35, WEST_DOWN_NORTH = 35,
	UEN = 36, UP_EAST_NORTH = 36,
	DEN = 37, DOWN_EAST_NORTH = 37,
	UWN = 38, UP_WEST_NORTH = 38,
	DWN = 39, DOWN_WEST_NORTH = 39,
	EUS = 40, EAST_UP_SOUTH = 40,
	WUS = 41, WEST_UP_SOUTH = 41,
	EDS = 42, EAST_DOWN_SOUTH = 42,
	WDS = 43, WEST_DOWN_SOUTH = 43,
	UES = 44, UP_EAST_SOUTH = 44,
	DES = 45, DOWN_EAST_SOUTH = 45,
	UWS = 46, UP_WEST_SOUTH = 46,
	DWS = 47, DOWN_WEST_SOUTH = 47, END_TRANSFORM = 47
	};

	// Individual axis enum values indicate which axis an implicit individual
	// axis will be mapped to.
	// The value of the enum paired with an axis provides the information
	// about what the axis will transform to.
	// Three individual axis values, one for each axis, are equivalent to one
	// ATR enum value, but easier to work with because they are independent.
	// Converting to and from the individual axis values from the ATR value
	// is a convenient way to implement tranformation related functionality.
	// Enum meanings:
	// PX: map to positive x axis
	// NX: map to negative x axis
	// PY: map to positive y axis
	// NY: map to negative y axis
	// PZ: map to positive z axis
	// NZ: map to negative z axis
	enum INDIVIDUAL_AXIS {
	PX = 0,
	NX = 1,
	PY = 2,
	NY = 3,
	PZ = 4,
	NZ = 5
	};

	inline axis_transformation() : atr_(NULL_TRANSFORM) {}
	inline axis_transformation(ATR atr) : atr_(atr) {}
	inline axis_transformation(const axis_transformation& atr) : atr_(atr.atr_) {}
	explicit axis_transformation(const orientation_3d& orient);
	explicit axis_transformation(const direction_3d& dir);
	explicit axis_transformation(const orientation_2d& orient);
	explicit axis_transformation(const direction_2d& dir);

	// assignment operator
	axis_transformation& operator=(const axis_transformation& a);

	// assignment operator
	axis_transformation& operator=(const ATR& atr);

	// equivalence operator
	bool operator==(const axis_transformation& a) const;

	// inequivalence operator
	bool operator!=(const axis_transformation& a) const;

	// ordering
	bool operator<(const axis_transformation& a) const;

	// concatenation operator
	axis_transformation operator+(const axis_transformation& a) const;

	// concatenate this with that
	axis_transformation& operator+=(const axis_transformation& a);

	// populate_axis_array writes the three INDIVIDUAL_AXIS values that the
	// ATR enum value of 'this' represent into axis_array
	void populate_axis_array(INDIVIDUAL_AXIS axis_array[]) const;

	// it is recommended that the directions stored in an array
	// in the caller code for easier isotropic access by orientation value
	inline void get_directions(direction_2d& horizontal_dir,
	direction_2d& vertical_dir) const {
	bool bit2 = (atr_ & 4) != 0;
	bool bit1 = (atr_ & 2) != 0;
	bool bit0 = (atr_ & 1) != 0;
	vertical_dir = direction_2d((direction_2d_enum)(((int)(!bit2) << 1) + !bit1));
	horizontal_dir = direction_2d((direction_2d_enum)(((int)(bit2) << 1) + !bit0));
	}

	// it is recommended that the directions stored in an array
	// in the caller code for easier isotropic access by orientation value
	inline void get_directions(direction_3d& horizontal_dir,
	direction_3d& vertical_dir,
	direction_3d& proximal_dir) const {
	bool bit5 = (atr_ & 32) != 0;
	bool bit4 = (atr_ & 16) != 0;
	bool bit3 = (atr_ & 8) != 0;
	bool bit2 = (atr_ & 4) != 0;
	bool bit1 = (atr_ & 2) != 0;
	bool bit0 = (atr_ & 1) != 0;
	proximal_dir = direction_3d((direction_2d_enum)((((int)(!bit4 & !bit5)) << 2) +
	((int)(bit5) << 1) +
	!bit3));
	vertical_dir = direction_3d((direction_2d_enum)((((int)((bit4 & bit2) \| (bit5 & !bit2))) << 2)+
	((int)(!bit5 & !bit2) << 1) +
	!bit1));
	horizontal_dir = direction_3d((direction_2d_enum)((((int)((bit5 & bit2) \|
	(bit4 & !bit2))) << 2) +
	((int)(bit2 & !bit5) << 1) +
	!bit0));
	}

	// combine_axis_arrays concatenates this_array and that_array overwriting
	// the result into this_array
	static void combine_axis_arrays (INDIVIDUAL_AXIS this_array[],
	const INDIVIDUAL_AXIS that_array[]);

	// write_back_axis_array converts an array of three INDIVIDUAL_AXIS values
	// to the ATR enum value and sets 'this' to that value
	void write_back_axis_array(const INDIVIDUAL_AXIS this_array[]);

	// behavior is deterministic but undefined in the case where illegal
	// combinations of directions are passed in.
	axis_transformation& set_directions(const direction_2d& horizontal_dir,
	const direction_2d& vertical_dir);
	// behavior is deterministic but undefined in the case where illegal
	// combinations of directions are passed in.
	axis_transformation& set_directions(const direction_3d& horizontal_dir,
	const direction_3d& vertical_dir,
	const direction_3d& proximal_dir);

	// transform the two coordinates by reference using the 2D portion of this
	template <typename coordinate_type>
	void transform(coordinate_type& x, coordinate_type& y) const;

	// transform the three coordinates by reference
	template <typename coordinate_type>
	void transform(coordinate_type& x, coordinate_type& y, coordinate_type& z) const;

	// invert the 2D portion of this
	axis_transformation& invert_2d();

	// get the inverse of the 2D portion of this
	axis_transformation inverse_2d() const;

	// invert this axis_transformation
	axis_transformation& invert();

	// get the inverse axis_transformation of this
	axis_transformation inverse() const;

	//friend std::ostream& operator<< (std::ostream& o, const axis_transformation& r);
	//friend std::istream& operator>> (std::istream& i, axis_transformation& r);

	private:
	ATR atr_;
	};


	// Scaling object to be used to store the scale factor for each axis

	// For use by the transformation object, in that context the scale factor
	// is the amount that each axis scales by when transformed.
	// If the horizontal value of the Scale is 10 that means the horizontal
	// axis of the input is multiplied by 10 when the transformation is applied.
	template <typename scale_factor_type>
	class anisotropic_scale_factor {
	public:
	inline anisotropic_scale_factor()
	#ifndef BOOST_POLYGON_MSVC
	: scale_()
	#endif
	{
	scale_[0] = 1;
	scale_[1] = 1;
	scale_[2] = 1;
	}
	inline anisotropic_scale_factor(scale_factor_type xscale, scale_factor_type yscale)
	#ifndef BOOST_POLYGON_MSVC
	: scale_()
	#endif
	{
	scale_[0] = xscale;
	scale_[1] = yscale;
	scale_[2] = 1;
	}
	inline anisotropic_scale_factor(scale_factor_type xscale, scale_factor_type yscale, scale_factor_type zscale)
	#ifndef BOOST_POLYGON_MSVC
	: scale_()
	#endif
	{
	scale_[0] = xscale;
	scale_[1] = yscale;
	scale_[2] = zscale;
	}

	// get a component of the anisotropic_scale_factor by orientation
	scale_factor_type get(orientation_3d orient) const;
	scale_factor_type get(orientation_2d orient) const { return get(orientation_3d(orient)); }

	// set a component of the anisotropic_scale_factor by orientation
	void set(orientation_3d orient, scale_factor_type value);
	void set(orientation_2d orient, scale_factor_type value) { set(orientation_3d(orient), value); }

	scale_factor_type x() const;
	scale_factor_type y() const;
	scale_factor_type z() const;
	void x(scale_factor_type value);
	void y(scale_factor_type value);
	void z(scale_factor_type value);

	// concatination operator (convolve scale factors)
	anisotropic_scale_factor operator+(const anisotropic_scale_factor& s) const;

	// concatinate this with that
	const anisotropic_scale_factor& operator+=(const anisotropic_scale_factor& s);

	// transform this scale with an axis_transform
	anisotropic_scale_factor& transform(axis_transformation atr);

	// scale the two coordinates
	template <typename coordinate_type>
	void scale(coordinate_type& x, coordinate_type& y) const;

	// scale the three coordinates
	template <typename coordinate_type>
	void scale(coordinate_type& x, coordinate_type& y, coordinate_type& z) const;

	// invert this scale factor to give the reverse scale factor
	anisotropic_scale_factor& invert();

	private:
	scale_factor_type scale_[3];

	//friend std::ostream& operator<< (std::ostream& o, const Scale& r);
	//friend std::istream& operator>> (std::istream& i, Scale& r);
	};

	// Transformation object, stores and provides services for transformations

	// Transformation object stores an axistransformation, a scale factor and a translation.
	// The tranlation is the position of the origin of the new system of coordinates in the old system.
	// The scale scales the coordinates before they are transformed.
	template <typename coordinate_type>
	class transformation {
	public:
	transformation();
	transformation(axis_transformation atr);
	transformation(axis_transformation::ATR atr);
	template <typename point_type>
	transformation(const point_type& p);
	template <typename point_type>
	transformation(axis_transformation atr, const point_type& p);
	template <typename point_type>
	transformation(axis_transformation atr, const point_type& referencePt, const point_type& destinationPt);
	transformation(const transformation& tr);

	// equivalence operator
	bool operator==(const transformation& tr) const;

	// inequivalence operator
	bool operator!=(const transformation& tr) const;

	// ordering
	bool operator<(const transformation& tr) const;

	// concatenation operator
	transformation operator+(const transformation& tr) const;

	// concatenate this with that
	const transformation& operator+=(const transformation& tr);

	// get the axis_transformation portion of this
	inline axis_transformation get_axis_transformation() const {return atr_;}

	// set the axis_transformation portion of this
	void set_axis_transformation(const axis_transformation& atr);

	// get the translation portion of this as a point3d
	template <typename point_type>
	void get_translation(point_type& translation) const;

	// set the translation portion of this with a point3d
	template <typename point_type>
	void set_translation(const point_type& p);

	// apply the 2D portion of this transformation to the two coordinates given
	void transform(coordinate_type& x, coordinate_type& y) const;

	// apply this transformation to the three coordinates given
	void transform(coordinate_type& x, coordinate_type& y, coordinate_type& z) const;

	// invert this transformation
	transformation& invert();

	// get the inverse of this transformation
	transformation inverse() const;

	inline void get_directions(direction_2d& horizontal_dir,
	direction_2d& vertical_dir) const {
	return atr_.get_directions(horizontal_dir, vertical_dir); }

	inline void get_directions(direction_3d& horizontal_dir,
	direction_3d& vertical_dir,
	direction_3d& proximal_dir) const {
	return atr_.get_directions(horizontal_dir, vertical_dir, proximal_dir); }

	private:
	axis_transformation atr_;
	point_3d_data<coordinate_type> p_;

	template <typename point_type>
	void construct_dispatch(axis_transformation atr, point_type p, point_concept tag);
	template <typename point_type>
	void construct_dispatch(axis_transformation atr, point_type p, point_3d_concept tag);
	template <typename point_type>
	void construct_dispatch(axis_transformation atr, point_type rp, point_type dp, point_concept tag);
	template <typename point_type>
	void construct_dispatch(axis_transformation atr, point_type rp, point_type dp, point_3d_concept tag);

	//friend std::ostream& operator<< (std::ostream& o, const transformation& tr);
	//friend std::istream& operator>> (std::istream& i, transformation& tr);
	};
	}
	}
	#include "detail/transform_detail.hpp"
	#endif