examples/ar-vineyard/ar-simplex3d.h
 author Dmitriy Morozov Mon, 05 Jul 2010 23:51:26 -0700 branch dev changeset 211 347b3461965a parent 86 73a54447b54a permissions -rw-r--r--
Bug in the tutorial: simplices = [] -> simplices = Filtration()
```
/**
* Author: Dmitriy Morozov
* Department of Computer Science, Duke University, 2007
*/

#ifndef __ARSIMPLEX3D_H__
#define __ARSIMPLEX3D_H__

#include <CGAL/Exact_predicates_exact_constructions_kernel.h>
#include <CGAL/Delaunay_triangulation_3.h>
//#include <CGAL/Kernel/global_functions_3.h>			// FIXME: what do we include for circumcenter?
#include <CGAL/squared_distance_3.h>

#include <topology/simplex.h>
#include <utilities/types.h>

#include <vector>
#include <set>
#include <iostream>

struct K: CGAL::Exact_predicates_exact_constructions_kernel {};

typedef CGAL::Delaunay_triangulation_3<K>    		Delaunay;
typedef Delaunay::Point                				Point;
typedef Delaunay::Vertex            				Vertex;
typedef Delaunay::Vertex_handle            			Vertex_handle;
typedef Delaunay::Edge								Edge;
typedef Delaunay::Facet								Facet;
typedef Delaunay::Cell								Cell;
typedef Delaunay::Cell_handle						Cell_handle;

typedef Delaunay::Finite_vertices_iterator    		Vertex_iterator;
typedef Delaunay::Finite_edges_iterator        		Edge_iterator;
typedef Delaunay::Finite_facets_iterator        	Facet_iterator;
typedef Delaunay::Finite_cells_iterator        		Cell_iterator;
typedef Delaunay::Facet_circulator					Facet_circulator;

class ARSimplex3D: public SimplexWithVertices<Vertex_handle>
{
public:
typedef     K::FT										        RealValue;
typedef 	std::map<ARSimplex3D, RealValue>					SimplexPhiMap;
typedef		SimplexWithVertices<Vertex_handle>					Parent;
typedef		Parent::VertexContainer								VertexSet;
typedef		std::list<ARSimplex3D>								Cycle;

public:
ARSimplex3D()						{}
ARSimplex3D(const Parent& p):
Parent(p) 					{}
ARSimplex3D(const ARSimplex3D& s);

ARSimplex3D(const Parent::Vertex& v);
ARSimplex3D(const ::Vertex& v, const Point& z);

ARSimplex3D(const Edge& e);
ARSimplex3D(const Edge& e, const Point& z, SimplexPhiMap& simplices,
const Delaunay& Dt, Facet_circulator facet_bg);

ARSimplex3D(const Facet& f);
ARSimplex3D(const Facet& f, const Point& z, const SimplexPhiMap& simplices,
const Delaunay& Dt);

ARSimplex3D(const Cell& c, const Point& z);

RealType					value() const						{ return CGAL::to_double(alpha_); }
RealValue					alpha() const						{ return alpha_; }
RealValue					phi_const() const					{ return phi_const_; }
RealValue					rho() const							{ return rho_; }
RealValue					s() const							{ return s_; }
RealValue					v() const							{ return v_; }

bool						attached() const					{ return attached_; }
Cycle						boundary() const;

void						set_phi_const(RealValue phi_const)	{ phi_const_ = phi_const; }

// Ordering
struct AlphaOrder
{ bool operator()(const ARSimplex3D& first, const ARSimplex3D& second) const; };

std::ostream& 				operator<<(std::ostream& out) const;

private:
RealValue 					alpha_;		// alpha_ 	is the squared radius of the smallest _empty_ circumsphere
RealValue					rho_;		// rho_ 	is the squared radius of the smallest circumsphere
RealValue					s_;			// s_ 		is the squared distance from z to the affine hull of the simplex
RealValue					v_;			// v_ 		is the squared distance from z to the affine hull of the dual Voronoi cell
RealValue					phi_const_;	// see LHI paper, Appendices A and B
bool 						attached_;

// in paper's notation: s_ = v^2; v_ = d^2

};

typedef 			std::vector<ARSimplex3D>								ARSimplex3DVector;

void				update_simplex_phi_map(const ARSimplex3D& s, ARSimplex3D::SimplexPhiMap& simplices);
void 				fill_alpha_order(const Delaunay& Dt, const Point& z, ARSimplex3DVector& alpha_order);

std::ostream& 		operator<<(std::ostream& out, const ARSimplex3D& s)	{ return s.operator<<(out); }

#include "ar-simplex3d.hpp"

#endif // __ARSIMPLEX3D_H__
```