mirror of https://github.com/CGAL/cgal
472 lines
12 KiB
C++
472 lines
12 KiB
C++
// Copyright (c) 1997 Tel-Aviv University (Israel).
|
|
// 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) : Eti Ezra <estere@post.tau.ac.il>
|
|
#ifndef CGAL_MAP_OVERLAY_DEFAULT_DCEL_H
|
|
#define CGAL_MAP_OVERLAY_DEFAULT_DCEL_H
|
|
|
|
#include <CGAL/basic.h> //CGAL definitions that need to be before anything else
|
|
#include <iostream.h>
|
|
#include <fstream.h>
|
|
#include <vector>
|
|
#include <list>
|
|
#include <string>
|
|
|
|
#ifndef CGAL_PM_DEFAULT_DCEL_H
|
|
#include<CGAL/Pm_default_dcel.h>
|
|
#endif
|
|
|
|
CGAL_BEGIN_NAMESPACE
|
|
|
|
///////////////////////////////////////////////////////////////
|
|
// OVERLAY DCEL
|
|
///////////////////////////////////////////////////////////////
|
|
|
|
template <class Face_base>
|
|
class Face_overlay : public Face_base {
|
|
public:
|
|
typedef Face_base face_base;
|
|
typedef Face_overlay face_overlay;
|
|
typedef const face_overlay const_face_overlay;
|
|
typedef const_face_overlay* const_pointer;
|
|
typedef const_face_overlay& const_ref;
|
|
typedef void* Face_pointer;
|
|
|
|
enum COLOR {WHITE=0, GRAY=1, BLACK=2};
|
|
|
|
Face_overlay() : face_base()
|
|
{
|
|
faces_above[0] = faces_above[1] = 0;
|
|
color = WHITE;
|
|
}
|
|
|
|
Face_overlay(const_pointer f) : face_base(*f)
|
|
{
|
|
set_first_face_above(f->get_first_face_above());
|
|
set_second_face_above(f->get_second_face_above());
|
|
set_color(f->get_color());
|
|
}
|
|
|
|
Face_overlay(const_ref f) : face_base(f)
|
|
{
|
|
set_first_face_above(f.get_first_face_above());
|
|
set_second_face_above(f.get_second_face_above());
|
|
set_color(f.get_color());
|
|
}
|
|
|
|
virtual ~Face_overlay() {}
|
|
|
|
const_ref operator=(const_ref f)
|
|
{
|
|
if (this == &f)
|
|
return *this;
|
|
|
|
face_base::assign(f);
|
|
reset();
|
|
|
|
set_first_face_above(f.get_first_face_above());
|
|
set_second_face_above(f.get_second_face_above());
|
|
set_color(f.get_color());
|
|
|
|
return *this;
|
|
}
|
|
|
|
void set_first_face_above(const void* const face)
|
|
{
|
|
// updating only if the value is not NULL and not already in the array.
|
|
if (face && faces_above[0] != face && faces_above[1] != face){
|
|
faces_above[0] = face;
|
|
}
|
|
}
|
|
|
|
void set_second_face_above(const void* const face)
|
|
{
|
|
// updating only if the value is not NULL and not already in the array.
|
|
if (face && faces_above[0] != face && faces_above[1] != face){
|
|
faces_above[1] = face;
|
|
}
|
|
}
|
|
|
|
const void* const get_first_face_above() const
|
|
{
|
|
return faces_above[0];
|
|
}
|
|
|
|
const void* const get_second_face_above() const
|
|
{
|
|
return faces_above[1];
|
|
}
|
|
|
|
void reset()
|
|
{
|
|
faces_above[0] = faces_above[1] = 0;
|
|
}
|
|
|
|
void set_color(COLOR c) { color = c;}
|
|
|
|
COLOR get_color() const { return color;}
|
|
|
|
virtual void assign(const_ref f)
|
|
{
|
|
operator=(f);
|
|
}
|
|
|
|
protected:
|
|
const void* faces_above[2];
|
|
COLOR color;
|
|
};
|
|
|
|
//template <class X_curve>
|
|
//class Pm_halfedge_overlay : public Pm_halfedge_base<X_curve>
|
|
|
|
template <class Halfedge_base>
|
|
class Halfedge_overlay : public Halfedge_base
|
|
{
|
|
public:
|
|
typedef Halfedge_base halfedge_base;
|
|
typedef Halfedge_overlay halfedge_overlay;
|
|
typedef const halfedge_overlay const_halfedge_overlay;
|
|
typedef const_halfedge_overlay* const_pointer;
|
|
typedef const_halfedge_overlay& const_ref;
|
|
typedef void* Halfedge_pointer;
|
|
|
|
Halfedge_overlay() : halfedge_base()
|
|
{
|
|
halfedges_above[0] = halfedges_above[1] = 0;
|
|
faces_above[0] = faces_above[1] = 0;
|
|
}
|
|
|
|
Halfedge_overlay(const_pointer e) : halfedge_base(*e)
|
|
{
|
|
set_first_halfedge_above(e->get_first_halfedge_above());
|
|
set_second_halfedge_above(e->get_second_halfedge_above());
|
|
|
|
set_first_face_above(e->get_first_face_above());
|
|
set_second_face_above(e->get_second_face_above());
|
|
|
|
//halfedges_above[0] = halfedges_above[1] = 0;
|
|
//faces_above[0] = faces_above[1] = 0;
|
|
}
|
|
|
|
Halfedge_overlay(const_ref e) : halfedge_base(e)
|
|
{
|
|
set_first_halfedge_above(e.get_first_halfedge_above());
|
|
set_second_halfedge_above(e.get_second_halfedge_above());
|
|
|
|
set_first_face_above(e.get_first_face_above());
|
|
set_second_face_above(e.get_second_face_above());
|
|
|
|
//faces_above[0] = faces_above[1] = 0;
|
|
}
|
|
|
|
virtual ~Halfedge_overlay() {}
|
|
|
|
const_ref operator=(const_ref e)
|
|
{
|
|
if (this == &e)
|
|
return *this;
|
|
|
|
halfedge_base::assign(e);
|
|
|
|
reset();
|
|
|
|
set_first_halfedge_above(e.get_first_halfedge_above());
|
|
set_second_halfedge_above(e.get_second_halfedge_above());
|
|
|
|
set_first_face_above(e.get_first_face_above());
|
|
set_second_face_above(e.get_second_face_above());
|
|
|
|
return *this;
|
|
}
|
|
|
|
void set_first_halfedge_above(const void* const halfedge)
|
|
{
|
|
// updating only if the value is not 0 and not already in the array.
|
|
if (halfedge && halfedges_above[0] != halfedge &&
|
|
halfedges_above[1] != halfedge)
|
|
{
|
|
halfedges_above[0] = halfedge;
|
|
}
|
|
}
|
|
|
|
void set_second_halfedge_above(const void* const halfedge)
|
|
{
|
|
// updating only if the value is not 0 and not already in the array.
|
|
if (halfedge && halfedges_above[0] != halfedge &&
|
|
halfedges_above[1] != halfedge)
|
|
{
|
|
halfedges_above[1] = halfedge;
|
|
}
|
|
}
|
|
|
|
const void* const get_first_halfedge_above() const
|
|
{
|
|
return halfedges_above[0];
|
|
}
|
|
|
|
const void* const get_second_halfedge_above() const
|
|
{
|
|
return halfedges_above[1];
|
|
}
|
|
|
|
// ---- add faces above halfedges (not to their sides).
|
|
void set_first_face_above(const void* face)
|
|
{
|
|
// updating only if the value is not 0 and not already in the array.
|
|
if (face && faces_above[0] != face && faces_above[1] != face)
|
|
{
|
|
faces_above[0] = face;
|
|
}
|
|
}
|
|
|
|
void set_second_face_above (const void* face)
|
|
{
|
|
// updating only if the value is not 0 and not already in the array.
|
|
if (face && faces_above[0] != face && faces_above[1] != face)
|
|
{
|
|
faces_above[1] = face;
|
|
}
|
|
}
|
|
|
|
void reset()
|
|
{
|
|
reset_halfedges_above();
|
|
reset_faces_above();
|
|
}
|
|
|
|
const void* const get_first_face_above() const
|
|
{
|
|
return faces_above[0];
|
|
}
|
|
|
|
const void* const get_second_face_above() const
|
|
{
|
|
return faces_above[1];
|
|
}
|
|
|
|
virtual void assign(const_ref e)
|
|
{
|
|
operator=(e);
|
|
}
|
|
|
|
protected:
|
|
|
|
void reset_halfedges_above()
|
|
{
|
|
halfedges_above[0] = halfedges_above[1] = 0;
|
|
}
|
|
|
|
void reset_faces_above()
|
|
{
|
|
faces_above[0] = faces_above[1] = 0;
|
|
}
|
|
|
|
const void* halfedges_above[2];
|
|
const void* faces_above[2];
|
|
};
|
|
|
|
|
|
template <class Vertex_base>
|
|
class Vertex_overlay : public Vertex_base
|
|
{
|
|
public:
|
|
typedef Vertex_base vertex_base;
|
|
typedef Vertex_overlay vertex_overlay;
|
|
typedef const vertex_overlay const_vertex_overlay;
|
|
typedef const_vertex_overlay* const_pointer;
|
|
typedef const_vertex_overlay& const_ref;
|
|
typedef void* Vertex_pointer;
|
|
|
|
Vertex_overlay() : vertex_base() {
|
|
vertices_above[0] = vertices_above[1] = 0;
|
|
halfedges_above[0] = halfedges_above[1] = 0;
|
|
faces_above[0] = faces_above[1] = 0;
|
|
}
|
|
|
|
Vertex_overlay(const_pointer v) : vertex_base(*v) {
|
|
set_first_vertex_above(v->get_first_vertex_above());
|
|
set_second_vertex_above(v->get_second_vertex_above());
|
|
|
|
set_first_halfedge_above(v->get_first_halfedge_above());
|
|
set_second_halfedge_above(v->get_second_halfedge_above());
|
|
|
|
set_first_face_above(v->get_first_face_above());
|
|
set_second_face_above(v->get_second_face_above());
|
|
}
|
|
|
|
Vertex_overlay(const_ref v) : vertex_base(v) {
|
|
set_first_vertex_above(v.get_first_vertex_above());
|
|
set_second_vertex_above(v.get_second_vertex_above());
|
|
|
|
set_first_halfedge_above(v.get_first_halfedge_above());
|
|
set_second_halfedge_above(v.get_second_halfedge_above());
|
|
|
|
set_first_face_above(v.get_first_face_above());
|
|
set_second_face_above(v.get_second_face_above());
|
|
}
|
|
|
|
virtual ~Vertex_overlay() {}
|
|
|
|
const_ref operator=(const_ref v)
|
|
{
|
|
if (this == &v)
|
|
return *this;
|
|
|
|
vertex_base::assign(v);
|
|
|
|
reset();
|
|
|
|
set_first_vertex_above(v.get_first_vertex_above());
|
|
set_second_vertex_above(v.get_second_vertex_above());
|
|
|
|
set_first_halfedge_above(v.get_first_halfedge_above());
|
|
set_second_halfedge_above(v.get_second_halfedge_above());
|
|
|
|
set_first_face_above(v.get_first_face_above());
|
|
set_second_face_above(v.get_second_face_above());
|
|
|
|
return *this;
|
|
}
|
|
|
|
void set_first_vertex_above(const void* const vertex)
|
|
{
|
|
// updating only if the value is not 0 and not already in the array.
|
|
if (vertex && vertices_above[0] != vertex && vertices_above[1] != vertex)
|
|
{
|
|
vertices_above[0] = vertex;
|
|
}
|
|
}
|
|
|
|
void set_second_vertex_above(const void* const vertex)
|
|
{
|
|
// updating only if the value is not 0 and not already in the array.
|
|
if (vertex && vertices_above[0] != vertex && vertices_above[1] != vertex)
|
|
{
|
|
vertices_above[1] = vertex;
|
|
}
|
|
}
|
|
|
|
const void* const get_first_vertex_above() const
|
|
{
|
|
return vertices_above[0];
|
|
}
|
|
|
|
const void* const get_second_vertex_above() const
|
|
{
|
|
return vertices_above[1];
|
|
}
|
|
|
|
void set_first_halfedge_above(const void* const halfedge)
|
|
{
|
|
|
|
if (halfedge && halfedges_above[0] != halfedge &&
|
|
halfedges_above[1] != halfedge){
|
|
halfedges_above[0] = halfedge;
|
|
}
|
|
}
|
|
|
|
void set_second_halfedge_above(const void* const halfedge)
|
|
{
|
|
if (halfedge && halfedges_above[0] != halfedge &&
|
|
halfedges_above[1] != halfedge){
|
|
halfedges_above[1] = halfedge;
|
|
}
|
|
}
|
|
|
|
const void* const get_first_halfedge_above() const
|
|
{
|
|
return halfedges_above[0];
|
|
}
|
|
|
|
const void* const get_second_halfedge_above() const
|
|
{
|
|
return halfedges_above[1];
|
|
}
|
|
|
|
void set_first_face_above(const void* face)
|
|
{
|
|
// updating only if the value is not 0 and not already in the array.
|
|
if (face && faces_above[0] != face && faces_above[1] != face){
|
|
faces_above[0] = face;
|
|
}
|
|
}
|
|
|
|
void set_second_face_above (const void* face)
|
|
{
|
|
// updating only if the value is not 0 and not already in the array.
|
|
if (face && faces_above[0] != face && faces_above[1] != face){
|
|
faces_above[1] = face;
|
|
}
|
|
}
|
|
|
|
const void* const get_first_face_above() const
|
|
{
|
|
return faces_above[0];
|
|
}
|
|
|
|
const void* const get_second_face_above() const
|
|
{
|
|
return faces_above[1];
|
|
}
|
|
|
|
void reset()
|
|
{
|
|
vertices_above[0] = vertices_above[1] = 0;
|
|
halfedges_above[0] = halfedges_above[1] = 0;
|
|
faces_above[0] = faces_above[1] = 0;
|
|
}
|
|
|
|
virtual void assign(const_ref v)
|
|
{
|
|
operator=(v);
|
|
}
|
|
|
|
protected:
|
|
const void* vertices_above[2];
|
|
const void* halfedges_above[2];
|
|
const void* faces_above[2];
|
|
};
|
|
|
|
template <class Traits,
|
|
class Vertex_base = Pm_vertex_base<typename Traits::Point>,
|
|
class Halfedge_base = Pm_halfedge_base<typename Traits::X_curve> ,
|
|
class Face_base = Pm_face_base>
|
|
class Map_overlay_default_dcel : public Pm_dcel<Vertex_overlay<Vertex_base> ,
|
|
Halfedge_overlay<Halfedge_base>,
|
|
Face_overlay<Face_base> >
|
|
{
|
|
public: // CREATION
|
|
Map_overlay_default_dcel() {}
|
|
};
|
|
|
|
CGAL_END_NAMESPACE
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|