1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
|
// Copyright (c) 1999
// Utrecht University (The Netherlands),
// ETH Zurich (Switzerland),
// INRIA Sophia-Antipolis (France),
// Max-Planck-Institute Saarbruecken (Germany),
// and Tel-Aviv University (Israel). All rights reserved.
//
// This file is part of CGAL (www.cgal.org)
//
// $URL: https://github.com/CGAL/cgal/blob/v6.1/Homogeneous_kernel/include/CGAL/Homogeneous/PointH2.h $
// $Id: include/CGAL/Homogeneous/PointH2.h b26b07a1242 $
// SPDX-License-Identifier: LGPL-3.0-or-later OR LicenseRef-Commercial
//
//
// Author(s) : Stefan Schirra
#ifndef CGAL_HOMOGENEOUS_POINT_2_H
#define CGAL_HOMOGENEOUS_POINT_2_H
#include <CGAL/Origin.h>
#include <boost/mpl/and.hpp>
#include <boost/mpl/logical.hpp>
#include <type_traits>
namespace CGAL {
template < class R_ >
class PointH2
{
typedef typename R_::FT FT;
typedef typename R_::RT RT;
typedef typename R_::Vector_2 Vector_2;
typedef typename R_::Point_2 Point_2;
typedef typename R_::Direction_2 Direction_2;
typedef Rational_traits<FT> Rat_traits;
// Reference-counting is handled in Vector_2.
Vector_2 base;
public:
typedef FT Cartesian_coordinate_type;
typedef const RT& Homogeneous_coordinate_type;
typedef typename Vector_2::Cartesian_const_iterator Cartesian_const_iterator;
typedef R_ R;
PointH2() {}
PointH2(const Origin &)
: base(NULL_VECTOR) {}
template < typename Tx, typename Ty >
PointH2(const Tx & x, const Ty & y,
std::enable_if_t< std::is_convertible_v<Tx, RT> &&
std::is_convertible_v<Ty, RT> >* = 0)
: base(x, y) {}
PointH2(const FT& x, const FT& y)
: base(x, y) {}
PointH2(const RT& hx, const RT& hy, const RT& hw)
: base(hx, hy, hw) {}
typename R::Boolean operator==( const PointH2<R>& p) const;
typename R::Boolean operator!=( const PointH2<R>& p) const;
const RT & hx() const { return base.hx(); }
const RT & hy() const { return base.hy(); }
const RT & hw() const { return base.hw(); }
FT x() const { return FT(hx()) / FT(hw()); }
FT y() const { return FT(hy()) / FT(hw()); }
FT cartesian(int i) const;
FT operator[](int i) const;
const RT & homogeneous(int i) const;
Cartesian_const_iterator cartesian_begin() const
{
return base.cartesian_begin();
}
Cartesian_const_iterator cartesian_end() const
{
return base.cartesian_end();
}
int dimension() const;
Direction_2 direction() const;
};
template < class R >
inline
typename R::Boolean
PointH2<R>::operator==( const PointH2<R>& p) const
{
return base == p.base;
}
template < class R >
inline
typename R::Boolean
PointH2<R>::operator!=( const PointH2<R>& p) const
{ return !(*this == p); }
template < class R >
inline
typename PointH2<R>::FT
PointH2<R>::cartesian(int i) const
{
return base.cartesian(i);
}
template < class R >
inline
const typename PointH2<R>::RT &
PointH2<R>::homogeneous(int i) const
{
return base.homogeneous(i);
}
template < class R >
inline
typename PointH2<R>::FT
PointH2<R>::operator[](int i) const
{ return base[i]; }
template < class R >
inline
int
PointH2<R>::dimension() const
{ return base.dimension(); }
template < class R >
inline
typename PointH2<R>::Direction_2
PointH2<R>::direction() const
{ return typename PointH2<R>::Direction_2(*this); }
} //namespace CGAL
#endif // CGAL_HOMOGENEOUS_POINT_2_H
|
