DGtal
1.3.beta
src
DGtal
images
RigidTransformation2D.h
1
17
#pragma once
18
29
#if defined(RigidTransformation2D_RECURSES)
30
#error Recursive header files inclusion detected in RigidTransformation2D.h
31
#else // defined(RigidTransformation2D_RECURSES)
32
33
#define RigidTransformation2D_RECURSES
34
35
#if !defined RigidTransformation2D_h
36
37
#define RigidTransformation2D_h
38
40
// Inclusions
41
#include <iostream>
42
#include <cmath>
43
#include <climits>
44
#include <utility>
45
#include "DGtal/base/Common.h"
46
#include "DGtal/kernel/BasicPointFunctors.h"
47
#include <DGtal/helpers/StdDefs.h>
48
#include <DGtal/kernel/domains/CDomain.h>
49
#include <DGtal/kernel/CSpace.h>
51
52
namespace
DGtal
53
{
54
namespace
functors
55
{
57
// Template class ForwardRigidTransformation2D
70
template
<
typename
TSpace,
typename
TInputValue =
typename
TSpace::RealPoint
,
typename
TOutputValue =
typename
TSpace::Point
,
71
typename
TFunctor = VectorRounding < TInputValue, TOutputValue > >
72
class
ForwardRigidTransformation2D
73
{
75
BOOST_CONCEPT_ASSERT
((
concepts::CSpace<TSpace>
));
76
BOOST_STATIC_ASSERT
(( TSpace::dimension == 2 ));
77
BOOST_STATIC_ASSERT
(( TOutputValue::dimension == 2 ));
78
BOOST_STATIC_ASSERT
(( TInputValue::dimension == 2 ));
79
80
// ----------------------- Types ------------------------------
81
public
:
82
typedef
typename
TSpace::RealPoint
RealPoint
;
83
typedef
typename
TSpace::RealVector
RealVector
;
84
85
// ----------------------- Interface --------------------------------------
86
public
:
93
ForwardRigidTransformation2D
(
const
RealPoint
& aOrigin,
const
double
& angle,
const
RealVector
& aTranslate )
94
:
origin
(aOrigin),
translation
(aTranslate)
95
{
96
t_sin
= std::sin ( angle );
97
t_cos
= std::cos ( angle );
98
}
99
105
inline
106
TOutputValue
operator()
(
const
TInputValue & aInput )
const
107
{
108
RealPoint
p;
109
p[0] = ( (
t_cos
* ( aInput[0] -
origin
[0] ) -
110
t_sin
* ( aInput[1] -
origin
[1] ) ) +
translation
[0] ) +
origin
[0];
111
112
p[1] = ( (
t_sin
* ( aInput[0] -
origin
[0] ) +
113
t_cos
* ( aInput[1] -
origin
[1] ) ) +
translation
[1] ) +
origin
[1];
114
return
functor
( p );
115
}
116
117
// ------------------------- Protected Datas ------------------------------
118
protected
:
119
RealPoint
origin
;
120
double
t_sin
;
121
double
t_cos
;
122
RealVector
translation
;
123
TFunctor
functor
;
124
};
125
127
// Template class BackwardRigidTransformation2D
140
template
<
typename
TSpace,
typename
TInputValue =
typename
TSpace::RealPoint
,
typename
TOutputValue =
typename
TSpace::Point
,
141
typename
TFunctor =
VectorRounding < TInputValue, TOutputValue >
>
142
class
BackwardRigidTransformation2D
143
{
145
BOOST_CONCEPT_ASSERT
((
concepts::CSpace<TSpace>
));
146
BOOST_STATIC_ASSERT
(( TSpace::dimension == 2 ));
147
BOOST_STATIC_ASSERT
(( TOutputValue::dimension == 2 ));
148
BOOST_STATIC_ASSERT
(( TInputValue::dimension == 2 ));
149
150
// ----------------------- Types ------------------------------
151
public
:
152
typedef
typename
TSpace::RealPoint
RealPoint
;
153
typedef
typename
TSpace::RealVector
RealVector
;
154
155
// ----------------------- Interface --------------------------------------
156
public
:
163
BackwardRigidTransformation2D
(
const
RealPoint
& aOrigin,
const
double
& angle,
const
RealVector
& aTranslate )
164
:
origin
(aOrigin),
translation
(aTranslate)
165
{
166
t_sin
= std::sin ( angle );
167
t_cos
= std::cos ( angle );
168
}
169
175
inline
176
TOutputValue
operator()
(
const
TInputValue & aInput )
const
177
{
178
RealPoint
p;
179
p[0] = (
t_cos
* (aInput[0] -
translation
[0] -
origin
[0] ) +
180
t_sin
* ( aInput[1] -
translation
[1] -
origin
[1] ) ) +
origin
[0];
181
182
p[1] = ( -
t_sin
* ( aInput[0] -
translation
[0] -
origin
[0] ) +
183
t_cos
* ( aInput[1] -
translation
[1] -
origin
[1] ) ) +
origin
[1];
184
return
functor
( p);
185
}
186
187
// ------------------------- Protected Datas ------------------------------
188
protected
:
189
RealPoint
origin
;
190
double
t_sin
;
191
double
t_cos
;
192
RealVector
translation
;
193
TFunctor
functor
;
194
};
195
197
// Template class DomainRigidTransformation2D
207
template
<
typename
TDomain,
typename
TRig
id
TransformFunctor >
208
class
DomainRigidTransformation2D
209
{
211
BOOST_STATIC_ASSERT
(( TDomain::dimension == 2 ));
212
BOOST_CONCEPT_ASSERT
((
concepts::CDomain<TDomain>
));
213
214
// ----------------------- Types ------------------------------
215
public
:
216
typedef
std::pair < typename TDomain::Space::Point, typename TDomain::Space::Point >
Bounds
;
217
218
// ----------------------- Interface --------------------------------------
219
public
:
224
DomainRigidTransformation2D
(
const
TRigidTransformFunctor & aRigidFunctor ) : transform ( aRigidFunctor ) {}
225
231
inline
232
Bounds
operator()
(
const
TDomain & aInput )
const
233
{
234
typedef
typename
TDomain::Point
Point
;
235
Point
points[4];
236
points[0] =
transform
( aInput.lowerBound() );
237
points[1] =
transform
( aInput.upperBound() );
238
points[2] =
transform
(
Point
( aInput.upperBound()[0], aInput.lowerBound()[1] ) );
239
points[3] =
transform
(
Point
( aInput.lowerBound()[0], aInput.upperBound()[1] ) );
240
241
Point
t_min ( INT_MAX, INT_MAX ), t_max ( INT_MIN, INT_MIN );
242
for
(
unsigned
int
i = 0; i < 4 ; i++ )
243
{
244
if
( points[i][0] < t_min[0] )
245
t_min[0] = points[i][0];
246
if
( points[i][1] < t_min[1] )
247
t_min[1] = points[i][1];
248
249
if
( points[i][0] > t_max[0] )
250
t_max[0] = points[i][0];
251
if
( points[i][1] > t_max[1] )
252
t_max[1] = points[i][1];
253
}
254
255
Bounds
bounds;
256
bounds.first = t_min;
257
bounds.second = t_max;
258
return
bounds;
259
}
260
261
// ------------------------- Protected Datas ------------------------------
262
protected
:
263
const
TRigidTransformFunctor &
transform
;
264
};
265
266
}
// namespace DGtal::functors
267
}
// namespace DGtal
268
269
#endif // !defined RigidTransformation2D_h
270
271
#undef RigidTransformation2D_RECURSES
272
#endif // else defined(RigidTransformation2D_RECURSES)
273
DGtal::functors::ForwardRigidTransformation2D
Aim: implements forward rigid transformation of point in the 2D integer space. Warring: This version ...
Definition:
RigidTransformation2D.h:72
DGtal::functors::ForwardRigidTransformation2D::t_cos
double t_cos
Definition:
RigidTransformation2D.h:121
DGtal::functors::BackwardRigidTransformation2D::BackwardRigidTransformation2D
BackwardRigidTransformation2D(const RealPoint &aOrigin, const double &angle, const RealVector &aTranslate)
Definition:
RigidTransformation2D.h:163
DGtal::functors::BackwardRigidTransformation2D::BOOST_CONCEPT_ASSERT
BOOST_CONCEPT_ASSERT((concepts::CSpace< TSpace >))
Checking concepts.
DGtal::functors::BackwardRigidTransformation2D::RealVector
TSpace::RealVector RealVector
Definition:
RigidTransformation2D.h:153
DGtal::functors::BackwardRigidTransformation2D::translation
RealVector translation
Definition:
RigidTransformation2D.h:192
DGtal::functors::BackwardRigidTransformation2D::operator()
TOutputValue operator()(const TInputValue &aInput) const
Definition:
RigidTransformation2D.h:176
DGtal::concepts::CSpace
Aim: Defines the concept describing a digital space, ie a cartesian product of integer lines.
Definition:
CSpace.h:105
DGtal::functors::BackwardRigidTransformation2D::origin
RealPoint origin
Definition:
RigidTransformation2D.h:189
DGtal::functors::DomainRigidTransformation2D::Bounds
std::pair< typename TDomain::Space::Point, typename TDomain::Space::Point > Bounds
Definition:
RigidTransformation2D.h:216
DGtal::functors::ForwardRigidTransformation2D::functor
TFunctor functor
Definition:
RigidTransformation2D.h:123
DGtal::functors::BackwardRigidTransformation2D::BOOST_STATIC_ASSERT
BOOST_STATIC_ASSERT((TSpace::dimension==2))
DGtal::functors::VectorRounding
Definition:
BasicPointFunctors.h:812
DGtal::functors::ForwardRigidTransformation2D::translation
RealVector translation
Definition:
RigidTransformation2D.h:122
DGtal::functors::DomainRigidTransformation2D::BOOST_CONCEPT_ASSERT
BOOST_CONCEPT_ASSERT((concepts::CDomain< TDomain >))
DGtal::functors::ForwardRigidTransformation2D::operator()
TOutputValue operator()(const TInputValue &aInput) const
Definition:
RigidTransformation2D.h:106
DGtal::functors::DomainRigidTransformation2D::transform
const TRigidTransformFunctor & transform
Definition:
RigidTransformation2D.h:263
DGtal::concepts::CDomain
Aim: This concept represents a digital domain, i.e. a non mutable subset of points of the given digit...
Definition:
CDomain.h:129
DGtal
DGtal is the top-level namespace which contains all DGtal functions and types.
DGtal::functors::BackwardRigidTransformation2D
Aim: implements backward rigid transformation of point in the 2D integer space. Warring: This version...
Definition:
RigidTransformation2D.h:142
DGtal::functors::DomainRigidTransformation2D
Aim: implements bounds of transformed domain.
Definition:
RigidTransformation2D.h:208
DGtal::functors::DomainRigidTransformation2D::DomainRigidTransformation2D
DomainRigidTransformation2D(const TRigidTransformFunctor &aRigidFunctor)
Definition:
RigidTransformation2D.h:224
DGtal::functors::BackwardRigidTransformation2D::functor
TFunctor functor
Definition:
RigidTransformation2D.h:193
DGtal::functors::ForwardRigidTransformation2D::RealPoint
TSpace::RealPoint RealPoint
Definition:
RigidTransformation2D.h:82
DGtal::functors::DomainRigidTransformation2D::BOOST_STATIC_ASSERT
BOOST_STATIC_ASSERT((TDomain::dimension==2))
Checking concepts.
DGtal::functors::ForwardRigidTransformation2D::BOOST_CONCEPT_ASSERT
BOOST_CONCEPT_ASSERT((concepts::CSpace< TSpace >))
Checking concepts.
DGtal::functors::ForwardRigidTransformation2D::RealVector
TSpace::RealVector RealVector
Definition:
RigidTransformation2D.h:83
DGtal::functors::ForwardRigidTransformation2D::BOOST_STATIC_ASSERT
BOOST_STATIC_ASSERT((TSpace::dimension==2))
RealVector
Space::RealVector RealVector
Definition:
fullConvexitySphereGeodesics.cpp:113
DGtal::functors::BackwardRigidTransformation2D::RealPoint
TSpace::RealPoint RealPoint
Definition:
RigidTransformation2D.h:152
DGtal::functors::ForwardRigidTransformation2D::t_sin
double t_sin
Definition:
RigidTransformation2D.h:120
DGtal::functors::ForwardRigidTransformation2D::ForwardRigidTransformation2D
ForwardRigidTransformation2D(const RealPoint &aOrigin, const double &angle, const RealVector &aTranslate)
Definition:
RigidTransformation2D.h:93
DGtal::functors::BackwardRigidTransformation2D::t_sin
double t_sin
Definition:
RigidTransformation2D.h:190
DGtal::functors::ForwardRigidTransformation2D::origin
RealPoint origin
Definition:
RigidTransformation2D.h:119
Point
MyPointD Point
Definition:
testClone2.cpp:383
RealPoint
Z2i::RealPoint RealPoint
Definition:
testAstroid2D.cpp:46
DGtal::functors::BackwardRigidTransformation2D::t_cos
double t_cos
Definition:
RigidTransformation2D.h:191
DGtal::functors::DomainRigidTransformation2D::operator()
Bounds operator()(const TDomain &aInput) const
Definition:
RigidTransformation2D.h:232
Generated on Mon Jun 20 2022 18:23:55 for DGtal by
1.8.17