From d682c43451882fd95bcc73b9848becd9ba09404a Mon Sep 17 00:00:00 2001 From: Laurent Rineau Date: Mon, 28 Jan 2008 14:13:52 +0000 Subject: [PATCH] Add two files needed by new features of revision r41873: they are model of a new concept of point, that stores: - the lowest dimension of all psc elements that contain it, - the index of the psc elements of lowest dimension that contains it. Two files: include/CGAL/Point_with_psc_localisation.h include/CGAL/Weighted_point_with_psc_localisation.h with bvious names: one is for Delaunay triangulations, and the other is for regular triangulations. --- .../CGAL/Point_with_psc_localisation.h | 149 +++++++++++++++++ .../Weighted_point_with_psc_localisation.h | 153 ++++++++++++++++++ 2 files changed, 302 insertions(+) create mode 100644 Surface_mesher/include/CGAL/Point_with_psc_localisation.h create mode 100644 Surface_mesher/include/CGAL/Weighted_point_with_psc_localisation.h diff --git a/Surface_mesher/include/CGAL/Point_with_psc_localisation.h b/Surface_mesher/include/CGAL/Point_with_psc_localisation.h new file mode 100644 index 00000000000..3cd210d2e84 --- /dev/null +++ b/Surface_mesher/include/CGAL/Point_with_psc_localisation.h @@ -0,0 +1,149 @@ +// Copyright (c) 2005-2006 INRIA Sophia-Antipolis (France). +// All rights reserved. +// +// This file is part of CGAL (www.cgal.org); you may redistribute it under +// the terms of the Q Public License version 1.0. +// See the file LICENSE.QPL distributed with CGAL. +// +// Licensees holding a valid commercial license may use this file in +// accordance with the commercial license agreement provided with the software. +// +// This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE +// WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. +// +// $URL$ +// $Id$ +// +// +// Author(s) : Laurent RINEAU + +#ifndef CGAL_POINT_WITH_PSC_LOCALISATION_H +#define CGAL_POINT_WITH_PSC_LOCALISATION_H + +#include + +#include + +namespace CGAL { + +template +class Point_with_psc_localisation : public Point +{ + typedef CGAL::Point_traits Point_traits; + typedef typename Point_traits::Bare_point Bare_point; + typedef typename Kernel_traits::Kernel Kernel; + typedef typename Kernel::FT FT; + typedef Point_with_psc_localisation Self; + +public: + Point_with_psc_localisation() : Point(), index(-1), dim(-1) {} + + Point_with_psc_localisation(const Point& p) : Point(p), index(-1), 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(-1), dim(-1) {} + + const int& element_index() const + { + return Self::index; + } + + void set_element_index(const int i) + { + Self::index = i; + } + + void set_dimension(const int d) + { + dim = d; + } + + const int& dimension() const + { + return dim; + } + + void set_on_surface(const int i) + { + CGAL_assertion(i>=0); + set_element_index(i); + set_dimension(2); + } + + void set_on_curve(const int i) + { + CGAL_assertion(i>=0); + set_element_index(i); + set_dimension(1); + } + + void set_on_vertex(const int 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()() + "+i+i"; + } +#endif +private: + int index; + int dim; +}; // end class Point_with_psc_localisation + +template +class Point_traits > + : public Point_traits +{ +}; + +template +class Is_weighted > + : public Is_weighted +{ +}; + +template +std::ostream& +operator<<(std::ostream &os, const Point_with_psc_localisation& p) +{ + os << static_cast(p); + if(is_ascii(os)) + os << ' ' << p.dimension() << ' ' << p.element_index(); + else { + write(os, p.dimension()); + write(os, p.element_index()); + } + return os; +} + +template +std::istream& +operator>>(std::istream &is, Point_with_psc_localisation& p) +{ + is >> static_cast(p); + int index, dim; + if(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 diff --git a/Surface_mesher/include/CGAL/Weighted_point_with_psc_localisation.h b/Surface_mesher/include/CGAL/Weighted_point_with_psc_localisation.h new file mode 100644 index 00000000000..960a68f4d39 --- /dev/null +++ b/Surface_mesher/include/CGAL/Weighted_point_with_psc_localisation.h @@ -0,0 +1,153 @@ +// Copyright (c) 2005-2006 INRIA Sophia-Antipolis (France). +// All rights reserved. +// +// This file is part of CGAL (www.cgal.org); you may redistribute it under +// the terms of the Q Public License version 1.0. +// See the file LICENSE.QPL distributed with CGAL. +// +// Licensees holding a valid commercial license may use this file in +// accordance with the commercial license agreement provided with the software. +// +// This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE +// WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. +// +// $URL$ +// $Id$ +// +// +// Author(s) : Laurent RINEAU + +#ifndef CGAL_POINT_WITH_PSC_LOCALISATION_H +#define CGAL_POINT_WITH_PSC_LOCALISATION_H + +#include + +#include + +namespace CGAL { + +template +class Weighted_point_with_psc_localisation : public Weighted_point +{ + typedef CGAL::Point_traits Point_traits; + typedef typename Point_traits::Bare_point Bare_point; + typedef typename Kernel_traits::Kernel Kernel; + typedef typename Kernel::FT FT; + +public: + Weighted_point_with_psc_localisation() : Weighted_point(), index(-1), dim(-1) {} + + Weighted_point_with_psc_localisation(const Weighted_point& p) : Weighted_point(p), index(-1), dim(-1) {} + + Weighted_point_with_psc_localisation(const Bare_point& p) : Weighted_point(p), index(-1), dim(-1) {} + +// Weighted_point_with_psc_localisation(const typename Kernel::Point_3& p) : Weighted_point(p), index(-1), dim(-1) {} + + Weighted_point_with_psc_localisation(const typename Kernel::Point_3& p, + const FT& w) : Weighted_point(p, w), index(-1), dim(-1) {} + + Weighted_point_with_psc_localisation(const Weighted_point_with_psc_localisation& p) + : Weighted_point(p), index(p.element_index()), dim(p.dimension()) {} + + Weighted_point_with_psc_localisation(const FT& x, const FT& y, const FT& z, const FT& w = FT(1)) + : Weighted_point(Point_traits().point(Bare_point(x, y, z, w))), index(-1), dim(-1) {} + + const int& element_index() const + { + return index; + } + + void set_element_index(const int i) + { + index = i; + } + + void set_dimension(const int d) + { + dim = d; + } + + const int& dimension() const + { + return dim; + } + + void set_on_surface(const int i) + { + CGAL_assertion(i>=0); + set_element_index(i); + set_dimension(2); + } + + void set_on_curve(const int i) + { + CGAL_assertion(i>=0); + set_element_index(i); + set_dimension(1); + } + + void set_on_vertex(const int 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()() + "+i+i"; + } +#endif +private: + int index; + int dim; +}; // end class Weighted_point_with_psc_localisation + +template +class Point_traits > + : public Point_traits +{ +}; + +template +class Is_weighted > + : public Is_weighted +{ +}; + +template +std::ostream& +operator<<(std::ostream &os, const Weighted_point_with_psc_localisation& p) +{ + os << static_cast(p); + if(is_ascii(os)) + os << ' ' << p.dimension() << ' ' << p.element_index(); + else { + write(os, p.dimension()); + write(os, p.element_index()); + } + return os; +} + +template +std::istream& +operator>>(std::istream &is, Weighted_point_with_psc_localisation& p) +{ + is >> static_cast(p); + int index, dim; + if(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