Subject: [Boost-commit] svn:boost r84549 - in trunk/boost/geometry/extensions/algebra: . algorithms core geometries geometries/concepts
From: adam.wulkiewicz_at_[hidden]
Date: 2013-05-29 19:18:09
Author: awulkiew
Date: 2013-05-29 19:18:08 EDT (Wed, 29 May 2013)
New Revision: 84549
URL: http://svn.boost.org/trac/boost/changeset/84549
Log:
geometry extensions: Added rotation_quaternion, rotation(), transform_geometrically(), etc.
Added:
trunk/boost/geometry/extensions/algebra/algorithms/rotation.hpp (contents, props changed)
trunk/boost/geometry/extensions/algebra/algorithms/transform.hpp (contents, props changed)
trunk/boost/geometry/extensions/algebra/geometries/concepts/rotation_quaternion_concept.hpp (contents, props changed)
trunk/boost/geometry/extensions/algebra/geometries/rotation_quaternion.hpp (contents, props changed)
Text files modified:
trunk/boost/geometry/extensions/algebra/algebra.hpp | 5 ++++-
trunk/boost/geometry/extensions/algebra/core/access.hpp | 25 +++++++++++++++++++++++++
trunk/boost/geometry/extensions/algebra/core/coordinate_dimension.hpp | 5 +++++
trunk/boost/geometry/extensions/algebra/core/coordinate_system.hpp | 15 +++++++++++----
trunk/boost/geometry/extensions/algebra/core/coordinate_type.hpp | 15 +++++++++++----
trunk/boost/geometry/extensions/algebra/core/tags.hpp | 2 +-
trunk/boost/geometry/extensions/algebra/core/topological_dimension.hpp | 8 +++++---
trunk/boost/geometry/extensions/algebra/geometries/concepts/check.hpp | 10 ++++++++++
8 files changed, 72 insertions(+), 13 deletions(-)
Modified: trunk/boost/geometry/extensions/algebra/algebra.hpp
==============================================================================
--- trunk/boost/geometry/extensions/algebra/algebra.hpp (original)
+++ trunk/boost/geometry/extensions/algebra/algebra.hpp 2013-05-29 19:18:08 EDT (Wed, 29 May 2013)
@@ -23,15 +23,18 @@
#include <boost/geometry/extensions/algebra/core/topological_dimension.hpp>
#include <boost/geometry/extensions/algebra/geometries/concepts/vector_concept.hpp>
+#include <boost/geometry/extensions/algebra/geometries/concepts/rotation_quaternion_concept.hpp>
#include <boost/geometry/extensions/algebra/geometries/concepts/check.hpp>
#include <boost/geometry/extensions/algebra/geometries/vector.hpp>
+#include <boost/geometry/extensions/algebra/geometries/rotation_quaternion.hpp>
#include <boost/geometry/extensions/algebra/algorithms/assign.hpp>
#include <boost/geometry/extensions/algebra/algorithms/clear.hpp>
#include <boost/geometry/extensions/algebra/algorithms/num_points.hpp>
#include <boost/geometry/extensions/algebra/algorithms/translation.hpp>
-#include <boost/geometry/extensions/algebra/algorithms/translate.hpp>
+#include <boost/geometry/extensions/algebra/algorithms/rotation.hpp>
+#include <boost/geometry/extensions/algebra/algorithms/transform.hpp>
#endif // BOOST_GEOMETRY_EXTENSIONS_ALGEBRA_ALGEBRA_HPP
Added: trunk/boost/geometry/extensions/algebra/algorithms/rotation.hpp
==============================================================================
--- (empty file)
+++ trunk/boost/geometry/extensions/algebra/algorithms/rotation.hpp 2013-05-29 19:18:08 EDT (Wed, 29 May 2013)
@@ -0,0 +1,146 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2013 Adam Wulkiewicz, Lodz, Poland.
+
+// Use, modification and distribution is 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_GEOMETRY_EXTENSIONS_ALGEBRA_ALGORITHMS_ROTATION_HPP
+#define BOOST_GEOMETRY_EXTENSIONS_ALGEBRA_ALGORITHMS_ROTATION_HPP
+
+#include <boost/geometry/extensions/algebra/geometries/concepts/rotation_quaternion_concept.hpp>
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace dispatch {
+
+template <typename V1, typename V2, typename Rotation,
+ typename Tag = typename tag<V1>::type,
+ typename RTag = typename tag<Rotation>::type
+>
+struct rotation
+{
+ BOOST_MPL_ASSERT_MSG(false, NOT_IMPLEMENTED_FOR_THOSE_TAGS, (Tag, Rotation));
+};
+
+template <typename V1, typename V2, typename Rotation>
+struct rotation<V1, V2, Rotation, vector_tag, rotation_quaternion_tag>
+{
+ static const bool cs_check =
+ ::boost::is_same<typename traits::coordinate_system<V1>::type, cs::cartesian>::value &&
+ ::boost::is_same<typename traits::coordinate_system<V2>::type, cs::cartesian>::value;
+
+ BOOST_MPL_ASSERT_MSG(cs_check, NOT_IMPLEMENTED_FOR_THOSE_SYSTEMS, (V1, V2));
+
+ typedef typename select_most_precise<
+ typename traits::coordinate_type<V1>::type,
+ typename traits::coordinate_type<V2>::type
+ >::type cv_type;
+
+ typedef typename select_most_precise<
+ cv_type,
+ typename traits::coordinate_type<Rotation>::type
+ >::type cr_type;
+
+ typedef model::vector<cv_type, 3> vector_type;
+
+ inline static void apply(V1 const& v1, V2 const& v2, Rotation & r)
+ {
+ // TODO - should store coordinates in more precise variables before the normalization?
+
+ // half angle
+ cv_type d = dot(v1, v2);
+ cv_type w = ::sqrt(dot(v1, v1) * dot(v2, v2)) + d;
+
+ // rotation angle 0 or pi
+ if ( -std::numeric_limits<cv_type>::epsilon() <= w && w <= std::numeric_limits<cv_type>::epsilon() )
+ {
+ // rotation angle == 0
+ if ( 0 <= d )
+ {
+ set<0>(r, 1); set<0>(r, 0); set<0>(r, 0); set<0>(r, 0);
+ }
+ // rotation angle == pi
+ else
+ {
+ set<0>(r, 0);
+ // find arbitrary rotation axis perpendicular to v1
+ assign_cross(vector_type(1, 0, 0), v1, r);
+ if ( length_sqr(r) < std::numeric_limits<cr_type>::epsilon() )
+ assign_cross(vector_type(0, 1, 0), v1, r);
+
+ // normalize axis
+ cr_type lsqr = length_sqr(r);
+ if ( std::numeric_limits<cr_type>::epsilon() < lsqr )
+ scale(r, 1.0f / ::sqrt(lsqr));
+ }
+ }
+ else
+ {
+ set<0>(r, w);
+ // rotation axis
+ assign_cross(v1, v2, r);
+
+ // normalize
+ cr_type lsqr = length_sqr(r);
+ if ( std::numeric_limits<cr_type>::epsilon() < lsqr )
+ scale(r, 1.0f / ::sqrt(lsqr));
+ }
+ }
+
+ // TODO - should return more precise type?
+ template <typename V1, typename V2>
+ inline static cv_type dot(V1 const& v1, V2 const& v2)
+ {
+ return get<0>(v1)*get<0>(v2) + get<1>(v1)*get<1>(v2) + get<2>(v1)*get<2>(v2);
+ }
+
+ // TODO - should return more precise type?
+ inline static cr_type length_sqr(Rotation const& r)
+ {
+ return get<0>(r)*get<0>(r) + get<1>(r)*get<1>(r) + get<2>(r)*get<2>(r) + get<3>(r)*get<3>(r);
+ }
+
+ inline static void assign_cross(V1 const& v1, V2 const& v2, Rotation & r)
+ {
+ set<1>(r, get<1>(v1)*get<2>(v2) - get<2>(v1)*get<1>(v2));
+ set<2>(r, get<2>(v1)*get<0>(v2) - get<0>(v1)*get<2>(v2));
+ set<3>(r, get<0>(v1)*get<1>(v2) - get<1>(v1)*get<0>(v2));
+ }
+
+ inline static void scale(Rotation & r, cr_type const& v)
+ {
+ set<0>(r, get<0>(r) * v);
+ set<1>(r, get<1>(r) * v);
+ set<2>(r, get<2>(r) * v);
+ set<3>(r, get<3>(r) * v);
+ }
+};
+
+} // namespace dispatch
+#endif // DOXYGEN_NO_DISPATCH
+
+template <typename V1, typename V2, typename Rotation>
+inline void rotation(V1 const& v1, V2 const& v2, Rotation & r)
+{
+ concept::check_concepts_and_equal_dimensions<V1 const, V2 const>();
+ // TODO - replace the following by check_equal_dimensions
+ concept::check_concepts_and_equal_dimensions<V1 const, Rotation>();
+
+ dispatch::rotation<V1, V2, Rotation>::apply(v1, v2, r);
+}
+
+template <typename Rotation, typename V1, typename V2>
+inline Rotation return_rotation(V1 const& v1, V2 const& v2)
+{
+ Rotation r;
+ translation(v1, v2, r);
+ return r;
+}
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_EXTENSIONS_ALGEBRA_ALGORITHMS_ROTATION_HPP
Added: trunk/boost/geometry/extensions/algebra/algorithms/transform.hpp
==============================================================================
--- (empty file)
+++ trunk/boost/geometry/extensions/algebra/algorithms/transform.hpp 2013-05-29 19:18:08 EDT (Wed, 29 May 2013)
@@ -0,0 +1,174 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2013 Adam Wulkiewicz, Lodz, Poland.
+
+// Use, modification and distribution is 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_GEOMETRY_EXTENSIONS_ALGEBRA_ALGORITHMS_TRANSFORM_HPP
+#define BOOST_GEOMETRY_EXTENSIONS_ALGEBRA_ALGORITHMS_TRANSFORM_HPP
+
+#include <boost/geometry/extensions/algebra/geometries/concepts/vector_concept.hpp>
+#include <boost/geometry/extensions/algebra/geometries/concepts/rotation_quaternion_concept.hpp>
+#include <boost/geometry/arithmetic/arithmetic.hpp>
+
+namespace boost { namespace geometry {
+
+namespace detail { namespace transform_geometrically {
+
+template <typename Box, typename Vector, std::size_t Dimension>
+struct box_vector_cartesian
+{
+ BOOST_MPL_ASSERT_MSG((0 < Dimension), INVALID_DIMENSION, (Box));
+
+ static inline void apply(Box & box, Vector const& vector)
+ {
+ box_vector_cartesian<Box, Vector, Dimension-1>::apply(box, vector);
+ set<min_corner, Dimension-1>(box, get<min_corner, Dimension-1>(box) + get<Dimension-1>(vector));
+ set<max_corner, Dimension-1>(box, get<max_corner, Dimension-1>(box) + get<Dimension-1>(vector));
+ }
+};
+
+template <typename Box, typename Vector>
+struct box_vector_cartesian<Box, Vector, 1>
+{
+ static inline void apply(Box & box, Vector const& vector)
+ {
+ set<min_corner, 0>(box, get<min_corner, 0>(box) + get<0>(vector));
+ set<max_corner, 0>(box, get<max_corner, 0>(box) + get<0>(vector));
+ }
+};
+
+}} // namespace detail::transform
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace dispatch {
+
+template <typename Geometry, typename Transform,
+ typename GTag = typename tag<Geometry>::type,
+ typename TTag = typename tag<Transform>::type>
+struct transform_geometrically
+{
+ BOOST_MPL_ASSERT_MSG(false, NOT_IMPLEMENTED_FOR_THOSE_TAGS, (GTag, TTag));
+};
+
+// Point translation by Vector
+template <typename Point, typename Vector>
+struct transform_geometrically<Point, Vector, point_tag, vector_tag>
+{
+ BOOST_CONCEPT_ASSERT( (concept::Point<Point>) );
+ BOOST_CONCEPT_ASSERT( (concept::Vector<Vector>) );
+
+ static inline void apply(Point & point, Vector const& vector)
+ {
+ typedef boost::mpl::bool_<
+ boost::is_same<
+ typename traits::coordinate_system<Point>::type,
+ cs::cartesian
+ >::value
+ > is_cartesian;
+ apply(point, vector, is_cartesian());
+ }
+
+ static inline void apply(Point & point, Vector const& vector, boost::mpl::bool_<true> /*is_cartesian*/)
+ {
+ for_each_coordinate(point, detail::point_operation<Vector, std::plus>(vector));
+ }
+
+ static inline void apply(Point & point, Vector const& vector, boost::mpl::bool_<false> /*is_cartesian*/)
+ {
+ typedef typename traits::coordinate_system<Point>::type cs;
+ BOOST_MPL_ASSERT_MSG(false, NOT_IMPLEMENTED_FOR_THIS_CS, (cs));
+ }
+};
+
+// Box translation by Vector
+template <typename Box, typename Vector>
+struct transform_geometrically<Box, Vector, box_tag, vector_tag>
+{
+ typedef typename traits::point_type<Box>::type point_type;
+
+ BOOST_CONCEPT_ASSERT( (concept::Point<point_type>) );
+ BOOST_CONCEPT_ASSERT( (concept::Vector<Vector>) );
+
+ static inline void apply(Box & box, Vector const& vector)
+ {
+ typedef boost::mpl::bool_<
+ boost::is_same<
+ typename traits::coordinate_system<point_type>::type,
+ cs::cartesian
+ >::value
+ > is_cartesian;
+ apply(box, vector, is_cartesian());
+ }
+
+ static inline void apply(Box & box, Vector const& vector, boost::mpl::bool_<true> /*is_cartesian*/)
+ {
+ geometry::detail::transform_geometrically::box_vector_cartesian<
+ Box, Vector, traits::dimension<point_type>::value
+ >::apply(box, vector);
+ }
+
+ static inline void apply(Box & box, Vector const& vector, boost::mpl::bool_<false> /*is_cartesian*/)
+ {
+ typedef typename traits::coordinate_system<point_type>::type cs;
+ BOOST_MPL_ASSERT_MSG(false, NOT_IMPLEMENTED_FOR_THIS_CS, (cs));
+ }
+};
+
+// Vector rotation by Quaternion
+template <typename Vector, typename RotationQuaternion>
+struct transform_geometrically<Vector, RotationQuaternion, vector_tag, rotation_quaternion_tag>
+{
+ static inline void apply(Vector & v, RotationQuaternion const& r)
+ {
+ concept::check_concepts_and_equal_dimensions<Vector, RotationQuaternion const>();
+
+ // TODO - choose more precise type?
+
+ typedef typename select_most_precise<
+ typename traits::coordinate_type<Vector>::type,
+ typename traits::coordinate_type<RotationQuaternion>::type
+ >::type T;
+
+ T a = /*get<0>(r) * 0 */- get<1>(r) * get<0>(v) - get<2>(r) * get<1>(v) - get<3>(r) * get<2>(v);
+ T b = get<0>(r) * get<0>(v)/* + get<1>(r) * 0*/ + get<2>(r) * get<2>(v) - get<3>(r) * get<1>(v);
+ T c = get<0>(r) * get<1>(v) - get<1>(r) * get<2>(v)/* + get<2>(r) * 0*/ + get<3>(r) * get<0>(v);
+ T d = get<0>(r) * get<2>(v) + get<1>(r) * get<1>(v) - get<2>(r) * get<0>(v)/* + get<3>(r) * 0*/;
+
+ set<0>(v, - a * get<1>(r) + b * get<0>(r) - c * get<3>(r) + d * get<2>(r));
+ set<1>(v, - a * get<2>(r) + b * get<3>(r) + c * get<0>(r) - d * get<1>(r));
+ set<2>(v, - a * get<3>(r) - b * get<2>(r) + c * get<1>(r) + d * get<0>(r));
+ }
+};
+
+// TODO - other geometries and transformations
+
+} // namespace dispatch
+#endif // DOXYGEN_NO_DISPATCH
+
+template <typename Geometry, typename Transformation>
+inline void transform_geometrically(Geometry & g, Transformation const& t)
+{
+ dispatch::transform_geometrically<Geometry, Transformation>::apply(g, t);
+}
+
+template <typename GeometrySrc, typename Transformation, typename GeometryDst>
+inline void transformed_geometrically(GeometrySrc const& gsrc, Transformation const& t, GeometryDst & gdst)
+{
+ geometry::convert(gsrc, gdst);
+ geometry::transform_geometrically(gdst, t);
+}
+
+template <typename GeometryDst, typename GeometrySrc, typename Transformation>
+inline GeometryDst return_transformed_geometrically(GeometrySrc const& gsrc, Transformation const& t)
+{
+ GeometryDst res;
+ transformed_geometrically(gsrc, t, res);
+ return res;
+}
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_EXTENSIONS_ALGEBRA_ALGORITHMS_TRANSFORM_HPP
Modified: trunk/boost/geometry/extensions/algebra/core/access.hpp
==============================================================================
--- trunk/boost/geometry/extensions/algebra/core/access.hpp (original)
+++ trunk/boost/geometry/extensions/algebra/core/access.hpp 2013-05-29 19:18:08 EDT (Wed, 29 May 2013)
@@ -55,6 +55,31 @@
}
};
+template <typename Q, typename CoordinateType, std::size_t Dimension>
+struct access<rotation_quaternion_tag, Q, CoordinateType, Dimension, boost::false_type>
+{
+ static inline CoordinateType get(Q const& v)
+ {
+ return traits::access<Q, Dimension>::get(v);
+ }
+ static inline void set(Q& v, CoordinateType const& value)
+ {
+ traits::access<Q, Dimension>::set(v, value);
+ }
+};
+
+template <typename Q, typename CoordinateType, std::size_t Dimension>
+struct access<rotation_quaternion_tag, Q, CoordinateType, Dimension, boost::true_type>
+{
+ static inline CoordinateType get(Q const* v)
+ {
+ return traits::access<typename boost::remove_pointer<Q>::type, Dimension>::get(*v);
+ }
+ static inline void set(Q* v, CoordinateType const& value)
+ {
+ traits::access<typename boost::remove_pointer<Q>::type, Dimension>::set(*v, value);
+ }
+};
} // namespace core_dispatch
#endif // DOXYGEN_NO_DISPATCH
Modified: trunk/boost/geometry/extensions/algebra/core/coordinate_dimension.hpp
==============================================================================
--- trunk/boost/geometry/extensions/algebra/core/coordinate_dimension.hpp (original)
+++ trunk/boost/geometry/extensions/algebra/core/coordinate_dimension.hpp 2013-05-29 19:18:08 EDT (Wed, 29 May 2013)
@@ -29,6 +29,11 @@
: traits::dimension<typename geometry::util::bare_type<V>::type>
{};
+template <typename G>
+struct dimension<rotation_quaternion_tag, G>
+ : traits::dimension<typename geometry::util::bare_type<G>::type>
+{};
+
} // namespace core_dispatch
#endif // DOXYGEN_NO_DISPATCH
Modified: trunk/boost/geometry/extensions/algebra/core/coordinate_system.hpp
==============================================================================
--- trunk/boost/geometry/extensions/algebra/core/coordinate_system.hpp (original)
+++ trunk/boost/geometry/extensions/algebra/core/coordinate_system.hpp 2013-05-29 19:18:08 EDT (Wed, 29 May 2013)
@@ -27,10 +27,17 @@
template <typename Vector>
struct coordinate_system<vector_tag, Vector>
{
- typedef typename traits::coordinate_system
- <
- typename geometry::util::bare_type<Vector>::type
- >::type type;
+ typedef typename traits::coordinate_system<
+ typename geometry::util::bare_type<Vector>::type
+ >::type type;
+};
+
+template <typename G>
+struct coordinate_system<rotation_quaternion_tag, G>
+{
+ typedef typename traits::coordinate_system<
+ typename geometry::util::bare_type<G>::type
+ >::type type;
};
} // namespace core_dispatch
Modified: trunk/boost/geometry/extensions/algebra/core/coordinate_type.hpp
==============================================================================
--- trunk/boost/geometry/extensions/algebra/core/coordinate_type.hpp (original)
+++ trunk/boost/geometry/extensions/algebra/core/coordinate_type.hpp 2013-05-29 19:18:08 EDT (Wed, 29 May 2013)
@@ -27,10 +27,17 @@
template <typename Vector>
struct coordinate_type<vector_tag, Vector>
{
- typedef typename traits::coordinate_type
- <
- typename geometry::util::bare_type<Vector>::type
- >::type type;
+ typedef typename traits::coordinate_type<
+ typename geometry::util::bare_type<Vector>::type
+ >::type type;
+};
+
+template <typename G>
+struct coordinate_type<rotation_quaternion_tag, G>
+{
+ typedef typename traits::coordinate_type<
+ typename geometry::util::bare_type<G>::type
+ >::type type;
};
} // namespace core_dispatch
Modified: trunk/boost/geometry/extensions/algebra/core/tags.hpp
==============================================================================
--- trunk/boost/geometry/extensions/algebra/core/tags.hpp (original)
+++ trunk/boost/geometry/extensions/algebra/core/tags.hpp 2013-05-29 19:18:08 EDT (Wed, 29 May 2013)
@@ -21,7 +21,7 @@
struct vector_tag {};
-
+struct rotation_quaternion_tag {};
}} // namespace boost::geometry
Modified: trunk/boost/geometry/extensions/algebra/core/topological_dimension.hpp
==============================================================================
--- trunk/boost/geometry/extensions/algebra/core/topological_dimension.hpp (original)
+++ trunk/boost/geometry/extensions/algebra/core/topological_dimension.hpp 2013-05-29 19:18:08 EDT (Wed, 29 May 2013)
@@ -30,9 +30,11 @@
{
-template <>
-struct top_dim<vector_tag> : boost::mpl::int_<0> {};
-
+//template <>
+//struct top_dim<vector_tag> : boost::mpl::int_<0> {};
+//
+//template <>
+//struct top_dim<rotation_quaternion_tag> : boost::mpl::int_<0> {};
} // namespace core_dispatch
#endif
Modified: trunk/boost/geometry/extensions/algebra/geometries/concepts/check.hpp
==============================================================================
--- trunk/boost/geometry/extensions/algebra/geometries/concepts/check.hpp (original)
+++ trunk/boost/geometry/extensions/algebra/geometries/concepts/check.hpp 2013-05-29 19:18:08 EDT (Wed, 29 May 2013)
@@ -38,6 +38,16 @@
: detail::concept_check::check<concept::Vector<Geometry> >
{};
+template <typename Geometry>
+struct check<Geometry, rotation_quaternion_tag, true>
+ : detail::concept_check::check<concept::ConstRotationQuaternion<Geometry> >
+{};
+
+template <typename Geometry>
+struct check<Geometry, rotation_quaternion_tag, false>
+ : detail::concept_check::check<concept::RotationQuaternion<Geometry> >
+{};
+
} // namespace dispatch
#endif
Added: trunk/boost/geometry/extensions/algebra/geometries/concepts/rotation_quaternion_concept.hpp
==============================================================================
--- (empty file)
+++ trunk/boost/geometry/extensions/algebra/geometries/concepts/rotation_quaternion_concept.hpp 2013-05-29 19:18:08 EDT (Wed, 29 May 2013)
@@ -0,0 +1,111 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+// Copyright (c) 2013 Adam Wulkiewicz, Lodz, Poland.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// Use, modification and distribution is 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_GEOMETRY_EXTENSIONS_ALGEBRA_GEOMETRIES_CONCEPTS_ROTATION_QUATERNION_CONCEPT_HPP
+#define BOOST_GEOMETRY_EXTENSIONS_ALGEBRA_GEOMETRIES_CONCEPTS_ROTATION_QUATERNION_CONCEPT_HPP
+
+#include <boost/concept_check.hpp>
+
+#include <boost/geometry/core/coordinate_dimension.hpp>
+#include <boost/geometry/core/access.hpp>
+
+namespace boost { namespace geometry { namespace concept {
+
+template <typename Geometry>
+class RotationQuaternion
+{
+#ifndef DOXYGEN_NO_CONCEPT_MEMBERS
+
+ typedef typename coordinate_type<Geometry>::type ctype;
+ typedef typename coordinate_system<Geometry>::type csystem;
+
+ template <typename G, std::size_t I, std::size_t N>
+ struct dimension_checker
+ {
+ static void apply()
+ {
+ G* g = 0;
+ geometry::set<I>(*g, geometry::get<I>(*g));
+ dimension_checker<G, I+1, N>::apply();
+ }
+ };
+
+
+ template <typename G, std::size_t N>
+ struct dimension_checker<G, N, N>
+ {
+ static void apply() {}
+ };
+
+public:
+
+ /// BCCL macro to apply the Vector concept
+ BOOST_CONCEPT_USAGE(RotationQuaternion)
+ {
+ static const bool dim_check = dimension<Geometry>::value == 3;
+ BOOST_MPL_ASSERT_MSG(dim_check, INVALID_DIMENSION, (RotationQuaternion));
+ static const bool cs_check = ::boost::is_same<csystem, cs::cartesian>::value;
+ BOOST_MPL_ASSERT_MSG(cs_check, NOT_IMPLEMENTED_FOR_THIS_CS, (csystem));
+
+ dimension_checker<Geometry, 0, 4>::apply();
+ }
+#endif
+};
+
+
+template <typename Geometry>
+class ConstRotationQuaternion
+{
+#ifndef DOXYGEN_NO_CONCEPT_MEMBERS
+
+ typedef typename coordinate_type<Geometry>::type ctype;
+ typedef typename coordinate_system<Geometry>::type csystem;
+
+ template <typename G, std::size_t I, std::size_t N>
+ struct dimension_checker
+ {
+ static void apply()
+ {
+ const G* g = 0;
+ ctype coord(geometry::get<I>(*g));
+ boost::ignore_unused_variable_warning(coord);
+ dimension_checker<G, I+1, N>::apply();
+ }
+ };
+
+
+ template <typename G, std::size_t N>
+ struct dimension_checker<G, N, N>
+ {
+ static void apply() {}
+ };
+
+public:
+
+ /// BCCL macro to apply the ConstVector concept
+ BOOST_CONCEPT_USAGE(ConstRotationQuaternion)
+ {
+ static const bool dim_check = dimension<Geometry>::value == 3;
+ BOOST_MPL_ASSERT_MSG(dim_check, INVALID_DIMENSION, (ConstRotationQuaternion));
+ static const bool cs_check = ::boost::is_same<csystem, cs::cartesian>::value;
+ BOOST_MPL_ASSERT_MSG(cs_check, NOT_IMPLEMENTED_FOR_THIS_CS, (csystem));
+
+ dimension_checker<Geometry, 0, 4>::apply();
+ }
+#endif
+};
+
+}}} // namespace boost::geometry::concept
+
+#endif // BOOST_GEOMETRY_EXTENSIONS_ALGEBRA_GEOMETRIES_CONCEPTS_ROTATION_QUATERNION_CONCEPT_HPP
Added: trunk/boost/geometry/extensions/algebra/geometries/rotation_quaternion.hpp
==============================================================================
--- (empty file)
+++ trunk/boost/geometry/extensions/algebra/geometries/rotation_quaternion.hpp 2013-05-29 19:18:08 EDT (Wed, 29 May 2013)
@@ -0,0 +1,130 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+// Copyright (c) 2013 Adam Wulkiewicz, Lodz, Poland.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// Use, modification and distribution is 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_GEOMETRY_EXTENSIONS_ALGEBRA_GEOMETRIES_ROTATION_QUATERNION_HPP
+#define BOOST_GEOMETRY_EXTENSIONS_ALGEBRA_GEOMETRIES_ROTATION_QUATERNION_HPP
+
+#include <cstddef>
+
+#include <boost/geometry/extensions/algebra/core/tags.hpp>
+#include <boost/geometry/extensions/algebra/geometries/concepts/rotation_quaternion_concept.hpp>
+
+namespace boost { namespace geometry
+{
+
+namespace model
+{
+
+template <typename T>
+class rotation_quaternion
+{
+ BOOST_CONCEPT_ASSERT( (concept::RotationQuaternion<rotation_quaternion>) );
+
+public:
+
+ /// @brief Default constructor, no initialization
+ inline rotation_quaternion()
+ {}
+
+ /// @brief Constructor to set components
+ inline rotation_quaternion(T const& w, T const& x, T const& y, T const& z)
+ {
+ m_values[0] = w;
+ m_values[1] = w;
+ m_values[2] = w;
+ m_values[3] = w;
+ }
+
+ /// @brief Get a coordinate
+ /// @tparam K coordinate to get
+ /// @return the coordinate
+ template <std::size_t K>
+ inline T const& get() const
+ {
+ BOOST_STATIC_ASSERT(K < 4);
+ return m_values[K];
+ }
+
+ /// @brief Set a coordinate
+ /// @tparam K coordinate to set
+ /// @param value value to set
+ template <std::size_t K>
+ inline void set(T const& value)
+ {
+ BOOST_STATIC_ASSERT(K < 4);
+ m_values[K] = value;
+ }
+
+private:
+
+ T m_values[4];
+};
+
+
+} // namespace model
+
+#ifndef DOXYGEN_NO_TRAITS_SPECIALIZATIONS
+namespace traits
+{
+
+template <typename CoordinateType>
+struct tag<model::rotation_quaternion<CoordinateType> >
+{
+ typedef rotation_quaternion_tag type;
+};
+
+template <typename CoordinateType>
+struct coordinate_type<model::rotation_quaternion<CoordinateType> >
+{
+ typedef CoordinateType type;
+};
+
+template <typename CoordinateType>
+struct coordinate_system<model::rotation_quaternion<CoordinateType> >
+{
+ typedef cs::cartesian type;
+};
+
+template <typename CoordinateType>
+struct dimension<model::rotation_quaternion<CoordinateType> >
+ : boost::mpl::int_<3>
+{};
+
+template
+<
+ typename CoordinateType,
+ std::size_t Dimension
+>
+struct access<model::rotation_quaternion<CoordinateType>, Dimension>
+{
+ static inline CoordinateType get(
+ model::rotation_quaternion<CoordinateType> const& v)
+ {
+ return v.template get<Dimension>();
+ }
+
+ static inline void set(
+ model::rotation_quaternion<CoordinateType> & v,
+ CoordinateType const& value)
+ {
+ v.template set<Dimension>(value);
+ }
+};
+
+} // namespace traits
+#endif // DOXYGEN_NO_TRAITS_SPECIALIZATIONS
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_EXTENSIONS_ALGEBRA_GEOMETRIES_ROTATION_QUATERNION_HPP