stabilize build system: depends, installer, boost/bdb fixes, cross targets groundwork
This commit is contained in:
+57
@@ -0,0 +1,57 @@
|
||||
// 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.
|
||||
|
||||
// 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_STRATEGIES_TRANSFORM_INVERSE_TRANSFORMER_HPP
|
||||
#define BOOST_GEOMETRY_STRATEGIES_TRANSFORM_INVERSE_TRANSFORMER_HPP
|
||||
|
||||
#include <boost/qvm/mat.hpp>
|
||||
#include <boost/qvm/mat_operations.hpp>
|
||||
|
||||
#include <boost/geometry/strategies/transform/matrix_transformers.hpp>
|
||||
|
||||
|
||||
namespace boost { namespace geometry
|
||||
{
|
||||
|
||||
namespace strategy { namespace transform
|
||||
{
|
||||
|
||||
/*!
|
||||
\brief Transformation strategy to do an inverse transformation in a Cartesian coordinate system
|
||||
\ingroup strategies
|
||||
*/
|
||||
template
|
||||
<
|
||||
typename CalculationType,
|
||||
std::size_t Dimension1,
|
||||
std::size_t Dimension2
|
||||
>
|
||||
class inverse_transformer
|
||||
: public matrix_transformer<CalculationType, Dimension1, Dimension2>
|
||||
{
|
||||
public :
|
||||
template <typename Transformer>
|
||||
inline inverse_transformer(Transformer const& input)
|
||||
{
|
||||
this->m_matrix = boost::qvm::inverse(input.matrix());
|
||||
}
|
||||
|
||||
};
|
||||
|
||||
|
||||
}} // namespace strategy::transform
|
||||
|
||||
|
||||
}} // namespace boost::geometry
|
||||
|
||||
#endif // BOOST_GEOMETRY_STRATEGIES_TRANSFORM_INVERSE_TRANSFORMER_HPP
|
||||
+172
@@ -0,0 +1,172 @@
|
||||
// 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.
|
||||
|
||||
// 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_STRATEGIES_TRANSFORM_MAP_TRANSFORMER_HPP
|
||||
#define BOOST_GEOMETRY_STRATEGIES_TRANSFORM_MAP_TRANSFORMER_HPP
|
||||
|
||||
|
||||
#include <cstddef>
|
||||
|
||||
#include <boost/geometry/strategies/transform/matrix_transformers.hpp>
|
||||
|
||||
namespace boost { namespace geometry
|
||||
{
|
||||
|
||||
// Silence warning C4127: conditional expression is constant
|
||||
#if defined(_MSC_VER)
|
||||
#pragma warning(push)
|
||||
#pragma warning(disable : 4127)
|
||||
#endif
|
||||
|
||||
namespace strategy { namespace transform
|
||||
{
|
||||
|
||||
/*!
|
||||
\brief Transformation strategy to map from one to another Cartesian coordinate system
|
||||
\ingroup strategies
|
||||
\tparam Mirror if true map is mirrored upside-down (in most cases pixels
|
||||
are from top to bottom, while map is from bottom to top)
|
||||
*/
|
||||
template
|
||||
<
|
||||
typename CalculationType,
|
||||
std::size_t Dimension1,
|
||||
std::size_t Dimension2,
|
||||
bool Mirror = false,
|
||||
bool SameScale = true
|
||||
>
|
||||
class map_transformer
|
||||
: public matrix_transformer<CalculationType, Dimension1, Dimension2>
|
||||
{
|
||||
typedef boost::qvm::mat<CalculationType, Dimension1 + 1, Dimension2 + 1> M;
|
||||
typedef boost::qvm::mat<CalculationType, 3, 3> matrix33;
|
||||
|
||||
public :
|
||||
template <typename B, typename D>
|
||||
explicit inline map_transformer(B const& box, D const& width, D const& height)
|
||||
{
|
||||
set_transformation(
|
||||
get<min_corner, 0>(box), get<min_corner, 1>(box),
|
||||
get<max_corner, 0>(box), get<max_corner, 1>(box),
|
||||
width, height);
|
||||
}
|
||||
|
||||
template <typename W, typename D>
|
||||
explicit inline map_transformer(W const& wx1, W const& wy1, W const& wx2, W const& wy2,
|
||||
D const& width, D const& height)
|
||||
{
|
||||
set_transformation(wx1, wy1, wx2, wy2, width, height);
|
||||
}
|
||||
|
||||
|
||||
private :
|
||||
template <typename W, typename P, typename S>
|
||||
inline void set_transformation_point(W const& wx, W const& wy,
|
||||
P const& px, P const& py,
|
||||
S const& scalex, S const& scaley)
|
||||
{
|
||||
|
||||
// Translate to a coordinate system centered on world coordinates (-wx, -wy)
|
||||
matrix33 t1;
|
||||
qvm::A<0,0>(t1) = 1; qvm::A<0,1>(t1) = 0; qvm::A<0,2>(t1) = -wx;
|
||||
qvm::A<1,0>(t1) = 0; qvm::A<1,1>(t1) = 1; qvm::A<1,2>(t1) = -wy;
|
||||
qvm::A<2,0>(t1) = 0; qvm::A<2,1>(t1) = 0; qvm::A<2,2>(t1) = 1;
|
||||
|
||||
// Scale the map
|
||||
matrix33 s;
|
||||
qvm::A<0,0>(s) = scalex; qvm::A<0,1>(s) = 0; qvm::A<0,2>(s) = 0;
|
||||
qvm::A<1,0>(s) = 0; qvm::A<1,1>(s) = scaley; qvm::A<1,2>(s) = 0;
|
||||
qvm::A<2,0>(s) = 0; qvm::A<2,1>(s) = 0; qvm::A<2,2>(s) = 1;
|
||||
|
||||
// Translate to a coordinate system centered on the specified pixels (+px, +py)
|
||||
matrix33 t2;
|
||||
qvm::A<0,0>(t2) = 1; qvm::A<0,1>(t2) = 0; qvm::A<0,2>(t2) = px;
|
||||
qvm::A<1,0>(t2) = 0; qvm::A<1,1>(t2) = 1; qvm::A<1,2>(t2) = py;
|
||||
qvm::A<2,0>(t2) = 0; qvm::A<2,1>(t2) = 0; qvm::A<2,2>(t2) = 1;
|
||||
|
||||
// Calculate combination matrix in two steps
|
||||
this->m_matrix = s * t1;
|
||||
this->m_matrix = t2 * this->m_matrix;
|
||||
}
|
||||
|
||||
|
||||
template <typename W, typename D>
|
||||
void set_transformation(W const& wx1, W const& wy1, W const& wx2, W const& wy2,
|
||||
D const& width, D const& height)
|
||||
{
|
||||
D px1 = 0;
|
||||
D py1 = 0;
|
||||
D px2 = width;
|
||||
D py2 = height;
|
||||
|
||||
// Get the same type, but at least a double
|
||||
typedef typename select_most_precise<D, double>::type type;
|
||||
|
||||
|
||||
// Calculate appropriate scale, take min because whole box must fit
|
||||
// Scale is in PIXELS/MAPUNITS (meters)
|
||||
W wdx = wx2 - wx1;
|
||||
W wdy = wy2 - wy1;
|
||||
type sx = (px2 - px1) / boost::numeric_cast<type>(wdx);
|
||||
type sy = (py2 - py1) / boost::numeric_cast<type>(wdy);
|
||||
|
||||
if (SameScale)
|
||||
{
|
||||
type scale = (std::min)(sx, sy);
|
||||
sx = scale;
|
||||
sy = scale;
|
||||
}
|
||||
|
||||
// Calculate centerpoints
|
||||
W wtx = wx1 + wx2;
|
||||
W wty = wy1 + wy2;
|
||||
W two = 2;
|
||||
W wmx = wtx / two;
|
||||
W wmy = wty / two;
|
||||
type pmx = (px1 + px2) / 2.0;
|
||||
type pmy = (py1 + py2) / 2.0;
|
||||
|
||||
set_transformation_point(wmx, wmy, pmx, pmy, sx, sy);
|
||||
|
||||
if (Mirror)
|
||||
{
|
||||
// Mirror in y-direction
|
||||
matrix33 m;
|
||||
qvm::A<0,0>(m) = 1; qvm::A<0,1>(m) = 0; qvm::A<0,2>(m) = 0;
|
||||
qvm::A<1,0>(m) = 0; qvm::A<1,1>(m) = -1; qvm::A<1,2>(m) = 0;
|
||||
qvm::A<2,0>(m) = 0; qvm::A<2,1>(m) = 0; qvm::A<2,2>(m) = 1;
|
||||
|
||||
// Translate in y-direction such that it fits again
|
||||
matrix33 y;
|
||||
qvm::A<0,0>(y) = 1; qvm::A<0,1>(y) = 0; qvm::A<0,2>(y) = 0;
|
||||
qvm::A<1,0>(y) = 0; qvm::A<1,1>(y) = 1; qvm::A<1,2>(y) = height;
|
||||
qvm::A<2,0>(y) = 0; qvm::A<2,1>(y) = 0; qvm::A<2,2>(y) = 1;
|
||||
|
||||
// Calculate combination matrix in two steps
|
||||
this->m_matrix = m * this->m_matrix;
|
||||
this->m_matrix = y * this->m_matrix;
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
}} // namespace strategy::transform
|
||||
|
||||
#if defined(_MSC_VER)
|
||||
#pragma warning(pop)
|
||||
#endif
|
||||
|
||||
}} // namespace boost::geometry
|
||||
|
||||
|
||||
#endif // BOOST_GEOMETRY_STRATEGIES_TRANSFORM_MAP_TRANSFORMER_HPP
|
||||
+399
@@ -0,0 +1,399 @@
|
||||
// Boost.Geometry (aka GGL, Generic Geometry Library)
|
||||
|
||||
// Copyright (c) 2007-2015 Barend Gehrels, Amsterdam, the Netherlands.
|
||||
// Copyright (c) 2008-2015 Bruno Lalande, Paris, France.
|
||||
// Copyright (c) 2009-2015 Mateusz Loskot, London, UK.
|
||||
|
||||
// This file was modified by Oracle on 2015.
|
||||
// Modifications copyright (c) 2015 Oracle and/or its affiliates.
|
||||
|
||||
// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
|
||||
|
||||
// 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_STRATEGIES_TRANSFORM_MATRIX_TRANSFORMERS_HPP
|
||||
#define BOOST_GEOMETRY_STRATEGIES_TRANSFORM_MATRIX_TRANSFORMERS_HPP
|
||||
|
||||
|
||||
#include <cstddef>
|
||||
|
||||
#include <boost/qvm/mat.hpp>
|
||||
#include <boost/qvm/mat_access.hpp>
|
||||
#include <boost/qvm/mat_operations.hpp>
|
||||
|
||||
#include <boost/geometry/core/access.hpp>
|
||||
#include <boost/geometry/core/coordinate_dimension.hpp>
|
||||
#include <boost/geometry/core/cs.hpp>
|
||||
#include <boost/geometry/util/math.hpp>
|
||||
#include <boost/geometry/util/promote_floating_point.hpp>
|
||||
#include <boost/geometry/util/select_coordinate_type.hpp>
|
||||
#include <boost/geometry/util/select_most_precise.hpp>
|
||||
|
||||
|
||||
namespace boost { namespace geometry
|
||||
{
|
||||
|
||||
namespace strategy { namespace transform
|
||||
{
|
||||
|
||||
/*!
|
||||
\brief Affine transformation strategy in Cartesian system.
|
||||
\details The strategy serves as a generic definition of affine transformation matrix
|
||||
and procedure of application it to given point.
|
||||
\see http://en.wikipedia.org/wiki/Affine_transformation
|
||||
and http://www.devmaster.net/wiki/Transformation_matrices
|
||||
\ingroup strategies
|
||||
\tparam Dimension1 number of dimensions to transform from
|
||||
\tparam Dimension2 number of dimensions to transform to
|
||||
*/
|
||||
template
|
||||
<
|
||||
typename CalculationType,
|
||||
std::size_t Dimension1,
|
||||
std::size_t Dimension2
|
||||
>
|
||||
class matrix_transformer
|
||||
{
|
||||
};
|
||||
|
||||
|
||||
template <typename CalculationType>
|
||||
class matrix_transformer<CalculationType, 2, 2>
|
||||
{
|
||||
protected :
|
||||
typedef CalculationType ct;
|
||||
typedef boost::qvm::mat<ct, 3, 3> matrix_type;
|
||||
matrix_type m_matrix;
|
||||
|
||||
public :
|
||||
|
||||
inline matrix_transformer(
|
||||
ct const& m_0_0, ct const& m_0_1, ct const& m_0_2,
|
||||
ct const& m_1_0, ct const& m_1_1, ct const& m_1_2,
|
||||
ct const& m_2_0, ct const& m_2_1, ct const& m_2_2)
|
||||
{
|
||||
qvm::A<0,0>(m_matrix) = m_0_0; qvm::A<0,1>(m_matrix) = m_0_1; qvm::A<0,2>(m_matrix) = m_0_2;
|
||||
qvm::A<1,0>(m_matrix) = m_1_0; qvm::A<1,1>(m_matrix) = m_1_1; qvm::A<1,2>(m_matrix) = m_1_2;
|
||||
qvm::A<2,0>(m_matrix) = m_2_0; qvm::A<2,1>(m_matrix) = m_2_1; qvm::A<2,2>(m_matrix) = m_2_2;
|
||||
}
|
||||
|
||||
inline matrix_transformer(matrix_type const& matrix)
|
||||
: m_matrix(matrix)
|
||||
{}
|
||||
|
||||
|
||||
inline matrix_transformer() {}
|
||||
|
||||
template <typename P1, typename P2>
|
||||
inline bool apply(P1 const& p1, P2& p2) const
|
||||
{
|
||||
assert_dimension_greater_equal<P1, 2>();
|
||||
assert_dimension_greater_equal<P2, 2>();
|
||||
|
||||
ct const& c1 = get<0>(p1);
|
||||
ct const& c2 = get<1>(p1);
|
||||
|
||||
ct p2x = c1 * qvm::A<0,0>(m_matrix) + c2 * qvm::A<0,1>(m_matrix) + qvm::A<0,2>(m_matrix);
|
||||
ct p2y = c1 * qvm::A<1,0>(m_matrix) + c2 * qvm::A<1,1>(m_matrix) + qvm::A<1,2>(m_matrix);
|
||||
|
||||
typedef typename geometry::coordinate_type<P2>::type ct2;
|
||||
set<0>(p2, boost::numeric_cast<ct2>(p2x));
|
||||
set<1>(p2, boost::numeric_cast<ct2>(p2y));
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
matrix_type const& matrix() const { return m_matrix; }
|
||||
};
|
||||
|
||||
|
||||
// It IS possible to go from 3 to 2 coordinates
|
||||
template <typename CalculationType>
|
||||
class matrix_transformer<CalculationType, 3, 2> : public matrix_transformer<CalculationType, 2, 2>
|
||||
{
|
||||
typedef CalculationType ct;
|
||||
|
||||
public :
|
||||
inline matrix_transformer(
|
||||
ct const& m_0_0, ct const& m_0_1, ct const& m_0_2,
|
||||
ct const& m_1_0, ct const& m_1_1, ct const& m_1_2,
|
||||
ct const& m_2_0, ct const& m_2_1, ct const& m_2_2)
|
||||
: matrix_transformer<CalculationType, 2, 2>(
|
||||
m_0_0, m_0_1, m_0_2,
|
||||
m_1_0, m_1_1, m_1_2,
|
||||
m_2_0, m_2_1, m_2_2)
|
||||
{}
|
||||
|
||||
inline matrix_transformer()
|
||||
: matrix_transformer<CalculationType, 2, 2>()
|
||||
{}
|
||||
};
|
||||
|
||||
|
||||
template <typename CalculationType>
|
||||
class matrix_transformer<CalculationType, 3, 3>
|
||||
{
|
||||
protected :
|
||||
typedef CalculationType ct;
|
||||
typedef boost::qvm::mat<ct, 4, 4> matrix_type;
|
||||
matrix_type m_matrix;
|
||||
|
||||
public :
|
||||
inline matrix_transformer(
|
||||
ct const& m_0_0, ct const& m_0_1, ct const& m_0_2, ct const& m_0_3,
|
||||
ct const& m_1_0, ct const& m_1_1, ct const& m_1_2, ct const& m_1_3,
|
||||
ct const& m_2_0, ct const& m_2_1, ct const& m_2_2, ct const& m_2_3,
|
||||
ct const& m_3_0, ct const& m_3_1, ct const& m_3_2, ct const& m_3_3
|
||||
)
|
||||
{
|
||||
qvm::A<0,0>(m_matrix) = m_0_0; qvm::A<0,1>(m_matrix) = m_0_1; qvm::A<0,2>(m_matrix) = m_0_2; qvm::A<0,3>(m_matrix) = m_0_3;
|
||||
qvm::A<1,0>(m_matrix) = m_1_0; qvm::A<1,1>(m_matrix) = m_1_1; qvm::A<1,2>(m_matrix) = m_1_2; qvm::A<1,3>(m_matrix) = m_1_3;
|
||||
qvm::A<2,0>(m_matrix) = m_2_0; qvm::A<2,1>(m_matrix) = m_2_1; qvm::A<2,2>(m_matrix) = m_2_2; qvm::A<2,3>(m_matrix) = m_2_3;
|
||||
qvm::A<3,0>(m_matrix) = m_3_0; qvm::A<3,1>(m_matrix) = m_3_1; qvm::A<3,2>(m_matrix) = m_3_2; qvm::A<3,3>(m_matrix) = m_3_3;
|
||||
}
|
||||
|
||||
inline matrix_transformer() {}
|
||||
|
||||
template <typename P1, typename P2>
|
||||
inline bool apply(P1 const& p1, P2& p2) const
|
||||
{
|
||||
ct const& c1 = get<0>(p1);
|
||||
ct const& c2 = get<1>(p1);
|
||||
ct const& c3 = get<2>(p1);
|
||||
|
||||
typedef typename geometry::coordinate_type<P2>::type ct2;
|
||||
|
||||
set<0>(p2, boost::numeric_cast<ct2>(
|
||||
c1 * m_matrix(0,0) + c2 * m_matrix(0,1) + c3 * m_matrix(0,2) + m_matrix(0,3)));
|
||||
set<1>(p2, boost::numeric_cast<ct2>(
|
||||
c1 * m_matrix(1,0) + c2 * m_matrix(1,1) + c3 * m_matrix(1,2) + m_matrix(1,3)));
|
||||
set<2>(p2, boost::numeric_cast<ct2>(
|
||||
c1 * m_matrix(2,0) + c2 * m_matrix(2,1) + c3 * m_matrix(2,2) + m_matrix(2,3)));
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
matrix_type const& matrix() const { return m_matrix; }
|
||||
};
|
||||
|
||||
|
||||
/*!
|
||||
\brief Strategy of translate transformation in Cartesian system.
|
||||
\details Translate moves a geometry a fixed distance in 2 or 3 dimensions.
|
||||
\see http://en.wikipedia.org/wiki/Translation_%28geometry%29
|
||||
\ingroup strategies
|
||||
\tparam Dimension1 number of dimensions to transform from
|
||||
\tparam Dimension2 number of dimensions to transform to
|
||||
*/
|
||||
template
|
||||
<
|
||||
typename CalculationType,
|
||||
std::size_t Dimension1,
|
||||
std::size_t Dimension2
|
||||
>
|
||||
class translate_transformer
|
||||
{
|
||||
};
|
||||
|
||||
|
||||
template<typename CalculationType>
|
||||
class translate_transformer<CalculationType, 2, 2> : public matrix_transformer<CalculationType, 2, 2>
|
||||
{
|
||||
public :
|
||||
// To have translate transformers compatible for 2/3 dimensions, the
|
||||
// constructor takes an optional third argument doing nothing.
|
||||
inline translate_transformer(CalculationType const& translate_x,
|
||||
CalculationType const& translate_y,
|
||||
CalculationType const& = 0)
|
||||
: matrix_transformer<CalculationType, 2, 2>(
|
||||
1, 0, translate_x,
|
||||
0, 1, translate_y,
|
||||
0, 0, 1)
|
||||
{}
|
||||
};
|
||||
|
||||
|
||||
template <typename CalculationType>
|
||||
class translate_transformer<CalculationType, 3, 3> : public matrix_transformer<CalculationType, 3, 3>
|
||||
{
|
||||
public :
|
||||
inline translate_transformer(CalculationType const& translate_x,
|
||||
CalculationType const& translate_y,
|
||||
CalculationType const& translate_z)
|
||||
: matrix_transformer<CalculationType, 3, 3>(
|
||||
1, 0, 0, translate_x,
|
||||
0, 1, 0, translate_y,
|
||||
0, 0, 1, translate_z,
|
||||
0, 0, 0, 1)
|
||||
{}
|
||||
|
||||
};
|
||||
|
||||
|
||||
/*!
|
||||
\brief Strategy of scale transformation in Cartesian system.
|
||||
\details Scale scales a geometry up or down in all its dimensions.
|
||||
\see http://en.wikipedia.org/wiki/Scaling_%28geometry%29
|
||||
\ingroup strategies
|
||||
\tparam Dimension1 number of dimensions to transform from
|
||||
\tparam Dimension2 number of dimensions to transform to
|
||||
*/
|
||||
template
|
||||
<
|
||||
typename CalculationType,
|
||||
std::size_t Dimension1,
|
||||
std::size_t Dimension2
|
||||
>
|
||||
class scale_transformer
|
||||
{
|
||||
};
|
||||
|
||||
|
||||
template <typename CalculationType>
|
||||
class scale_transformer<CalculationType, 2, 2> : public matrix_transformer<CalculationType, 2, 2>
|
||||
{
|
||||
|
||||
public :
|
||||
inline scale_transformer(CalculationType const& scale_x,
|
||||
CalculationType const& scale_y,
|
||||
CalculationType const& = 0)
|
||||
: matrix_transformer<CalculationType, 2, 2>(
|
||||
scale_x, 0, 0,
|
||||
0, scale_y, 0,
|
||||
0, 0, 1)
|
||||
{}
|
||||
|
||||
|
||||
inline scale_transformer(CalculationType const& scale)
|
||||
: matrix_transformer<CalculationType, 2, 2>(
|
||||
scale, 0, 0,
|
||||
0, scale, 0,
|
||||
0, 0, 1)
|
||||
{}
|
||||
};
|
||||
|
||||
|
||||
template <typename CalculationType>
|
||||
class scale_transformer<CalculationType, 3, 3> : public matrix_transformer<CalculationType, 3, 3>
|
||||
{
|
||||
public :
|
||||
inline scale_transformer(CalculationType const& scale_x,
|
||||
CalculationType const& scale_y,
|
||||
CalculationType const& scale_z)
|
||||
: matrix_transformer<CalculationType, 3, 3>(
|
||||
scale_x, 0, 0, 0,
|
||||
0, scale_y, 0, 0,
|
||||
0, 0, scale_z, 0,
|
||||
0, 0, 0, 1)
|
||||
{}
|
||||
|
||||
|
||||
inline scale_transformer(CalculationType const& scale)
|
||||
: matrix_transformer<CalculationType, 3, 3>(
|
||||
scale, 0, 0, 0,
|
||||
0, scale, 0, 0,
|
||||
0, 0, scale, 0,
|
||||
0, 0, 0, 1)
|
||||
{}
|
||||
};
|
||||
|
||||
|
||||
#ifndef DOXYGEN_NO_DETAIL
|
||||
namespace detail
|
||||
{
|
||||
|
||||
|
||||
template <typename DegreeOrRadian>
|
||||
struct as_radian
|
||||
{};
|
||||
|
||||
|
||||
template <>
|
||||
struct as_radian<radian>
|
||||
{
|
||||
template <typename T>
|
||||
static inline T get(T const& value)
|
||||
{
|
||||
return value;
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct as_radian<degree>
|
||||
{
|
||||
template <typename T>
|
||||
static inline T get(T const& value)
|
||||
{
|
||||
typedef typename promote_floating_point<T>::type promoted_type;
|
||||
return value * math::d2r<promoted_type>();
|
||||
}
|
||||
|
||||
};
|
||||
|
||||
|
||||
template
|
||||
<
|
||||
typename CalculationType,
|
||||
std::size_t Dimension1,
|
||||
std::size_t Dimension2
|
||||
>
|
||||
class rad_rotate_transformer
|
||||
: public matrix_transformer<CalculationType, Dimension1, Dimension2>
|
||||
{
|
||||
public :
|
||||
inline rad_rotate_transformer(CalculationType const& angle)
|
||||
: matrix_transformer<CalculationType, Dimension1, Dimension2>(
|
||||
cos(angle), sin(angle), 0,
|
||||
-sin(angle), cos(angle), 0,
|
||||
0, 0, 1)
|
||||
{}
|
||||
};
|
||||
|
||||
|
||||
} // namespace detail
|
||||
#endif // DOXYGEN_NO_DETAIL
|
||||
|
||||
|
||||
/*!
|
||||
\brief Strategy for rotate transformation in Cartesian coordinate system.
|
||||
\details Rotate rotates a geometry of specified angle about a fixed point (e.g. origin).
|
||||
\see http://en.wikipedia.org/wiki/Rotation_%28mathematics%29
|
||||
\ingroup strategies
|
||||
\tparam DegreeOrRadian degree/or/radian, type of rotation angle specification
|
||||
\note A single angle is needed to specify a rotation in 2D.
|
||||
Not yet in 3D, the 3D version requires special things to allow
|
||||
for rotation around X, Y, Z or arbitrary axis.
|
||||
\todo The 3D version will not compile.
|
||||
*/
|
||||
template
|
||||
<
|
||||
typename DegreeOrRadian,
|
||||
typename CalculationType,
|
||||
std::size_t Dimension1,
|
||||
std::size_t Dimension2
|
||||
>
|
||||
class rotate_transformer : public detail::rad_rotate_transformer<CalculationType, Dimension1, Dimension2>
|
||||
{
|
||||
|
||||
public :
|
||||
inline rotate_transformer(CalculationType const& angle)
|
||||
: detail::rad_rotate_transformer
|
||||
<
|
||||
CalculationType, Dimension1, Dimension2
|
||||
>(detail::as_radian<DegreeOrRadian>::get(angle))
|
||||
{}
|
||||
};
|
||||
|
||||
|
||||
}} // namespace strategy::transform
|
||||
|
||||
|
||||
}} // namespace boost::geometry
|
||||
|
||||
|
||||
#endif // BOOST_GEOMETRY_STRATEGIES_TRANSFORM_MATRIX_TRANSFORMERS_HPP
|
||||
Reference in New Issue
Block a user