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
147
148
149
150
151
|
// Copyright (c) 2005-2006 INRIA Sophia-Antipolis (France).
// All rights reserved.
//
// This file is part of CGAL (www.cgal.org).
//
// $URL: https://github.com/CGAL/cgal/blob/v6.1.1/Surface_mesher/include/CGAL/Point_with_psc_localisation.h $
// $Id: include/CGAL/Point_with_psc_localisation.h 08b27d3db14 $
// SPDX-License-Identifier: GPL-3.0-or-later OR LicenseRef-Commercial
//
//
// Author(s) : Laurent RINEAU
#ifndef CGAL_POINT_WITH_PSC_LOCALISATION_H
#define CGAL_POINT_WITH_PSC_LOCALISATION_H
#include <CGAL/license/Surface_mesher.h>
#define CGAL_DEPRECATED_HEADER "<CGAL/Point_with_psc_localisation.h>"
#define CGAL_DEPRECATED_MESSAGE_DETAILS \
"The 3D Mesh Generation package (see https://doc.cgal.org/latest/Mesh_3/) should be used instead."
#include <CGAL/Installation/internal/deprecation_warning.h>
#include <CGAL/Point_traits.h>
#include <string>
namespace CGAL {
template <class Point, typename Index_type = int>
class Point_with_psc_localisation : public Point
{
typedef CGAL::Point_traits<Point> Point_traits;
typedef typename Point_traits::Bare_point Bare_point;
typedef typename Kernel_traits<Bare_point>::Kernel Kernel;
typedef typename Kernel::FT FT;
typedef Point_with_psc_localisation<Point> Self;
public:
typedef Tag_true Set_on_surface_tag;
Point_with_psc_localisation() : Point(), index(), dim(-1) {}
Point_with_psc_localisation(const Point& p) : Point(p), index(), dim(-1) {}
// Point_with_psc_localisation(const typename Kernel::Point_3& p) : Point(p), index(0) {}
Point_with_psc_localisation(const Point_with_psc_localisation& p)
: Point(p), index(p.element_index()), dim(p.dimension()) {}
Point_with_psc_localisation(const FT& x, const FT& y, const FT& z, const FT& w = FT(1))
: Point(Point_traits().point(Bare_point(x, y, z, w))), index(), dim(-1) {}
const Index_type& element_index() const
{
return index;
}
void set_element_index(const Index_type i)
{
index = i;
}
void set_dimension(const int d)
{
dim = d;
}
const int& dimension() const
{
return dim;
}
void set_on_surface(const Index_type i)
{
// CGAL_assertion(i>=0);
set_element_index(i);
set_dimension(2);
}
void set_on_curve(const Index_type i)
{
// CGAL_assertion(i>=0);
set_element_index(i);
set_dimension(1);
}
void set_on_vertex(const Index_type i)
{
// CGAL_assertion(i>=0);
set_element_index(i);
set_dimension(0);
}
#ifdef CGAL_MESH_3_IO_H
static
std::string io_signature()
{
return Get_io_signature<Point>()() + "+i+i";
}
#endif
private:
Index_type index;
int dim;
}; // end class Point_with_psc_localisation
template <class Point>
class Point_traits<Point_with_psc_localisation<Point> >
: public Point_traits<Point>
{
};
template <class Point>
struct Is_weighted<Point_with_psc_localisation<Point> >
: public Is_weighted<Point>
{
};
template <class Point>
std::ostream&
operator<<(std::ostream &os, const Point_with_psc_localisation<Point>& p)
{
os << static_cast<const Point&>(p);
if(IO::is_ascii(os))
os << ' ' << p.dimension() << ' ' << p.element_index();
else {
write(os, p.dimension());
write(os, p.element_index());
}
return os;
}
template <class Point>
std::istream&
operator>>(std::istream &is, Point_with_psc_localisation<Point>& p)
{
is >> static_cast<Point&>(p);
int index, dim;
if(IO::is_ascii(is))
is >> dim >> index;
else {
read(is, dim);
read(is, index);
}
p.set_dimension(dim);
p.set_element_index(index);
return is;
}
} // end namespace CGAL
#endif
|
