zcy
/
dust3d
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
dust3d/thirdparty/cgal/CGAL-4.13/include/CGAL/Width_3.h

1599 lines
56 KiB
C++
Executable File
Raw Blame History

// Copyright (c) 1997-2000 ETH Zurich (Switzerland).
// All rights reserved.
//
// This file is part of CGAL (www.cgal.org).
// You can redistribute it and/or modify it under the terms of the GNU
// General Public License as published by the Free Software Foundation,
// either version 3 of the License, or (at your option) any later version.
//
// 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$
// SPDX-License-Identifier: GPL-3.0+
//
//
// Author(s) : Thomas Herrmann, Lutz Kettner
#ifndef CGAL_WIDTH_3_H
#define CGAL_WIDTH_3_H
#include <CGAL/license/Polytope_distance_d.h>
#include <CGAL/basic.h>
#include <cstdlib>
#include <iostream>
#include <CGAL/convex_hull_3.h>
#include <CGAL/Polyhedron_3.h>
#include <CGAL/HalfedgeDS_list.h>
#include <CGAL/assertions.h>
#include <CGAL/Width_polyhedron_3.h>
#include <CGAL/width_assertions.h>
namespace CGAL {
template<class Traits_>
class Width_3 {
// +----------------------------------------------------------------------+
// | Typedef Area |
// +----------------------------------------------------------------------+
private:
typedef Traits_ Traits;
typedef typename Traits::Point_3 Point_3;
typedef typename Traits::Vector_3 Vector_3;
typedef typename Traits::Plane_3 Plane_3;
typedef typename Traits::RT RT;
// +----------------------------------------------------------------------+
// | Variable Declaration |
// +----------------------------------------------------------------------+
private:
//the current best plane coefficients: e1:Ax+By+Cz+1=0
// e2:Ax+By+Cz+D=0
RT A,B,C,D,K;
// Width itself
RT WNum,WDenom;
// Planes and directions are derived from these variables
// A list with all quadruples A/K, B/K, C/K, D/K
std::vector< std::vector<RT> > allsolutions;
// A list with all quadruples that give an optimal solution
std::vector< std::vector<RT> > alloptimal;
//The traits class object
Traits tco;
//The new origin to know how to translate back
Point_3 neworigin;
// +----------------------------------------------------------------------+
// | Access to Private Variables |
// +----------------------------------------------------------------------+
public:
void get_width_coefficients(RT& a, RT& b, RT& c, RT& d, RT& k) {
d=-A*neworigin.hx()-B*neworigin.hy()-C*neworigin.hz()+D*neworigin.hw();
k=-A*neworigin.hx()-B*neworigin.hy()-C*neworigin.hz()+K*neworigin.hw();
a=A*neworigin.hw();
b=B*neworigin.hw();
c=C*neworigin.hw();
#ifdef GCD_COMPUTATION
simplify_solution(a,b,c,d,k);
#endif
}
void get_squared_width(RT& num, RT& denom) {
num=WNum;
denom=WDenom;
}
Vector_3 get_build_direction() {
return tco.make_vector(A,B,C);
}
void get_width_planes(Plane_3& e1, Plane_3& e2) {
RT a,b,c,d,k;
get_width_coefficients(a,b,c,d,k);
e1=tco.make_plane(a,b,c,d);
e2=tco.make_plane(a,b,c,k);
}
void get_all_build_directions(std::vector<Vector_3>& alldir) {
typename std::vector< std::vector<RT> >::iterator it=alloptimal.begin();
RT a,b,c;
while(it!=alloptimal.end()) {
a=(*it)[0];
b=(*it)[1];
c=(*it)[2];
#ifdef GCD_COMPUTATION
RT dummy1=0;
RT dummy2=0;
simplify_solution(a,b,c,dummy1,dummy2);
#endif
Vector_3 dir=tco.make_vector(a,b,c);
alldir.push_back(dir);
++it;
}
}
int get_number_of_optimal_solutions() {
return int(alloptimal.size());
}
int get_number_of_possible_solutions() {
return int(allsolutions.size());
}
void get_all_possible_solutions(std::vector< std::vector<RT> >& allsol) {
allsol.clear();
typename std::vector< std::vector<RT> >::iterator it=allsolutions.begin();
while(it!=allsolutions.end()) {
RT d=-((*it)[0])*neworigin.hx()-((*it)[1])*neworigin.hy()
-((*it)[2])*neworigin.hz()+((*it)[3])*neworigin.hw();
RT k=-((*it)[0])*neworigin.hx()-((*it)[1])*neworigin.hy()
-((*it)[2])*neworigin.hz()+((*it)[4])*neworigin.hw();
RT a=((*it)[0])*neworigin.hw();
RT b=((*it)[1])*neworigin.hw();
RT c=((*it)[2])*neworigin.hw();
#ifdef GCD_COMPUTATION
simplify_solution(a,b,c,d,k);
#endif
std::vector<RT> sol;
sol.push_back(a);
sol.push_back(b);
sol.push_back(c);
sol.push_back(d);
sol.push_back(k);
allsol.push_back(sol);
++it;
}
}
// +----------------------------------------------------------------------+
// | The Con- and Destructors |
// +----------------------------------------------------------------------+
public:
Width_3(): A(0), B(0), C(0), D(2), K(1), WNum(0), WDenom(1) {}
template<class InputIterator>
Width_3( InputIterator begin, InputIterator beyond):
A(0), B(0), C(0), D(2), K(1), WNum(0), WDenom(1) {
INFOMSG(INFO,"Waiting for new HDS to build class Width_Polyhedron!"
<<std::endl<<"Working with extern additional data structures.");
typedef typename Traits::ChullTraits CHT;
typedef Width_polyhedron_items_3 Items;
typedef Polyhedron_3< Traits, Items, HalfedgeDS_list> LocalPolyhedron;
LocalPolyhedron P;
convex_hull_3( begin, beyond, P, CHT());
width_3_convex(P);
}
template <class InputPolyhedron>
Width_3(InputPolyhedron& Poly):
A(0), B(0), C(0), D(2), K(1), WNum(0), WDenom(1) {
// Compute convex hull with new width_polyhedron structure
INFOMSG(INFO,"Working with extern additional data structures.");
width_3_convex(Poly);
}
~Width_3() {
allsolutions.clear();
alloptimal.clear();
}
// +----------------------------------------------------------------------+
// | Begin of private function area |
// +----------------------------------------------------------------------+
private:
// Just to remember:
// E1: -axh - byh - czh - kwh <= 0 axh + byh + czh + kwh >= 0
// E2: axh + byh + czh + dwh <= 0
// VF-pair: 3xE1 + 1xE2
// EE-pair: 2xE1 + 2xE2
// plane equation in facets: Ax + By + Cz + 1 = 0
// ax + by + cz + k = 0 (A=a/k,...)
//-----------------------------
//---Combinatorial functions---
//-----------------------------
// *** PREPARATION_CHECK ***
//---------------------------
//This function determines the next facet if the halfedge e is a
//valable halfedge over which we can rotate. If so fnext is returned.
//PRECONDITION: e is the LAST edge in the go_on or impassable list!
template <class InputDA, class Halfedge_handle_, class Facet_handle_>
bool preparation_check(InputDA& dao,
Halfedge_handle_& e,
Facet_handle_& fnext,
std::vector<Halfedge_handle_>& go_on,
std::vector<Halfedge_handle_>& imp)
{
//If the halfedge flag impassable is set then we can pop e from the stack
//of the possibale go_on edges
DEBUGMSG(PREPARATION_CHECK,"\nBegin PREPARATION_CHECK");
DEBUGENDL(PREPARATION_CHECK,"Edge e: "<<e->opposite()->vertex()->point()
<<" --> ",e->vertex()->point());
CGAL_precondition(go_on.back()==e);
DEBUGMSG(ASSERTION_OUTPUT,"e is last element on stack go_on. "
<<"ASSERTION OK.");
if ( dao.is_impassable(e) ) {
DEBUGMSG(PREPARATION_CHECK," is impassable. Erase from go_on.");
go_on.pop_back();
DEBUGMSG(PREPARATION_CHECK,"End PREPARATION_CHECK");
return false;
} else {
//If the opposite halfedge of e is already visited, then we insert
//e in the impassable list an pop e from the stack of the go_on edges
typename InputDA::Halfedge_handle h=e->opposite();
if(dao.is_visited(h)) {
DEBUGMSG(PREPARATION_CHECK," has a visited opposite edge. Set "
<<"impassable flag, push on impassable stack and erase"
<<" from go_on");
imp.push_back(e);
dao.set_impassable_flag(h,true);
go_on.pop_back();
DEBUGMSG(PREPARATION_CHECK,"End PREPARATION_CHECK");
return false;
} else {
DEBUGMSG(PREPARATION_CHECK," is a valable candidate. Compute next "
<<"facet and erase from go_on. Set visited flag of all to "
<<"fnext incident edges.");
//e is a valable candidate. Thus set fnext to the next facet we visit
fnext=h->facet();
//Delete e from go_on and insert the edges of fnext (except opposite
//of e) in the go_on list
go_on.pop_back();
typename InputDA::Halfedge_handle h0=h;
h=h->next();
while ( h!=h0) {
DEBUGENDL(PREPARATION_CHECK,"Adding edge to go_on stack: ",
h->opposite()->vertex()->point()<<" --> "
<<h->vertex()->point());
go_on.push_back(h);
dao.set_visited_flag(h,true);
h=h->next();
}
DEBUGMSG(PREPARATION_CHECK,"End PREPARATION_CHECK");
return true;
}
}
}
// *** NEIGHBORS_OF ***
//----------------------
//To compute the neighbors of a vertex. The vertex is implicitely given
//as the vertex the halfedge points to.
template <class Halfedge_handle_, class Vertex_handle_>
void neighbors_of(const Halfedge_handle_& h,
std::vector<Vertex_handle_>& V) {
DEBUGMSG(NEIGHBORS_OF,"\nBegin NEIGHBORS_OF");
DEBUGENDL(NEIGHBORS_OF,"Determining the neighbors of: ",
h->vertex()->point());
Halfedge_handle_ e=h;
Halfedge_handle_ e0=e->opposite();
V.clear();
V.push_back(e0->vertex());
e=e->next();
//Now go around the vertex and store the neighbor vertices
while ( e!=e0 ) {
V.push_back(e->vertex());
e=e->opposite()->next();
}
#if NEIGHBORS_OF
typename std::vector<Vertex_handle_>::iterator vtxit=V.begin();
while(vtxit!=V.end()) {
DEBUGENDL(NEIGHBORS_OF,"Neighbor: ",(*vtxit)->point());
++vtxit;
}
#endif
DEBUGMSG(NEIGHBORS_OF,"End NEIGHBORS_OF");
}
//During the algorithm we have to build union and minus set
//of two sets and check wheater two sets are cutting each othe ror not
// *** SETMINUS ***
//------------------
//Builds the set A\B where the set A is changed
template <class Vertex_handle_>
void setminus(std::vector<Vertex_handle_>& res,
const std::vector<Vertex_handle_>&
without) {
DEBUGMSG(SETMINUS,"\nBegin SETMINUS");
typename std::vector<Vertex_handle_>::iterator resit;
typename std::vector<Vertex_handle_>::const_iterator
withoutit=without.begin();
//Scan through all elements of without and check if they are also in res.
//If so delete the element from res.
while(withoutit!=without.end()) {
resit=std::find(res.begin(),res.end(),*withoutit);
if ( resit!=res.end() ) {
CGAL_assertion((*resit)->point()==(*withoutit)->point());
DEBUGMSG(ASSERTION_OUTPUT,"Found an element to erase. ASSERTION OK.");
DEBUGENDL(SETMINUS,"Erase point: ",(*resit)->point());
res.erase(resit);
}
++withoutit;
}
DEBUGMSG(SETMINUS,"End SETMINUS");
}
// *** SETUNION ***
//------------------
//Builds the union of two sets A and B. The result is stored in A
//POSTCONDITION: Every element in A is stored once.
template <class Vertex_handle_>
void setunion(std::vector<Vertex_handle_>&res,
std::vector<Vertex_handle_>& uni) {
DEBUGMSG(SETUNION,"\nBegin SETUNION");
typename std::vector<Vertex_handle_>::iterator
uniit=uni.begin();
typename std::vector<Vertex_handle_>::iterator resit;
//Scan the uni set and add every new element in res
while(uniit!=uni.end()) {
resit=std::find(res.begin(),res.end(),*uniit);
if ( resit==res.end() ) {
DEBUGENDL(SETUNION,"Insert new point: ",(*uniit)->point());
res.push_back(*uniit);
}
++uniit;
}
DEBUGMSG(SETUNION,"End SETUNION");
}
// *** SETCUT ***
//----------------
//Checks if two sets are cutting each other or not (the common elements are
//not determined
template <class Vertex_handle_>
bool setcut(std::vector<Vertex_handle_>& AA,
std::vector<Vertex_handle_>& BB) {
DEBUGMSG(SETCUT,"\nBegin SETCUT");
typename std::vector<Vertex_handle_>::iterator
Ait=AA.begin();
typename std::vector<Vertex_handle_>::iterator Bfindit;
while(Ait!=AA.end()) {
Bfindit=std::find(BB.begin(),BB.end(),*Ait);
if (Bfindit!=BB.end()) {
DEBUGMSG(SETCUT,"The sets are cutting each other. Return true.");
DEBUGMSG(SETCUT,"End SETCUT");
return true;
}
++Ait;
}
DEBUGMSG(SETCUT,"No common element detected. Return false");
DEBUGMSG(SETCUT,"End SETCUT");
return false;
}
// ---Numerical functions---
// *************************
// *** COMPUTE_PLANE_EQUATION ***
//--------------------------------
//We don't take the standard plane equation computation from CGAL,
//because in the context of the width the coefficients have to
//satisfy a system of linear inequations.
//PRECONDITION: (0,0,0) is strictly inside the convex hull
//POSTCONDITION:(0,0,0) is on the positive side of the plane <==> the normal
// vector of the plane points to the side where (0,0,0) lies
template<class InputDA, class Facet_handle_>
void compute_plane_equation(InputDA,
const Facet_handle_& f) {
DEBUGMSG(COMPUTE_PLANE_EQUATION,"\nBegin COMPUTE_PLANE_EQUATION");
DEBUGENDL(COMPUTE_PLANE_EQUATION,"Compute plane equations of facet f: ("
<<f->halfedge()->opposite()->vertex()->point()<<"), (",
f->halfedge()->vertex()->point()<<"), ("
<<f->halfedge()->next()->vertex()->point()<<")");
typename InputDA::Halfedge_handle e = f->halfedge();
typename InputDA::PolyPoint p,q,r;
q = e -> opposite() -> vertex() -> point();
p = e -> vertex() -> point();
r = e -> next() -> vertex() -> point();
CGAL_assertion(r!=p && r!=q && p!=q);
DEBUGMSG(ASSERTION_OUTPUT,"There are 3 different points. ASSERTION OK.");
RT a,b,c,k;
solve_3x3(InputDA(),p,q,r,a,b,c,k);
f->plane()=tco.make_plane(a,b,c,k);
DEBUGENDL(COMPUTE_PLANE_EQUATION,"Plane Coefficients: ",f->plane());
DEBUGMSG(COMPUTE_PLANE_EQUATION,"End COMPUTE_PLANE_EQUATION");
}
// *** SOLVE_3X3 ***
//-------------------
//To solve a special 3x3 system. The rows of the coefficient matrix
//are the (homogeneous) x,y,z-coordinates of points and the right
//hand side is the homogeneous part of the point times the provided
//coefficient. The system is solved with Cramer's Rule. The sign of
//the coefficients is chosen in a way that (0,0,0) lies on the positive
//side of the plane.
template<class InputDA, class PolyPoint_>
void solve_3x3(InputDA,
const PolyPoint_& p,
const PolyPoint_& q,
const PolyPoint_& r,
RT& a, RT& b, RT& c, RT& k) {
DEBUGMSG(SOLVE_3X3,"\nBegin SOLVE_3X3");
RT px,py,pz,ph;
tco.get_point_coordinates(p,px,py,pz,ph);
RT qx,qy,qz,qh;
tco.get_point_coordinates(q,qx,qy,qz,qh);
RT rx,ry,rz,rh;
tco.get_point_coordinates(r,rx,ry,rz,rh);
CGAL_assertion(ph>0 && qh>0 && rh>0);
DEBUGMSG(ASSERTION_OUTPUT,"All homogeneous parts >0. ASSERTION OK.");
DEBUGMSG(SOLVE_3X3,"Matrix:");
DEBUGENDL(SOLVE_3X3,"",px<<" "<<py<<" "<<pz<<" : "<<-ph);
DEBUGENDL(SOLVE_3X3,"",qx<<" "<<qy<<" "<<qz<<" : "<<-qh);
DEBUGENDL(SOLVE_3X3,"",rx<<" "<<ry<<" "<<rz<<" : "<<-rh);
k=px*(qy*rz-ry*qz)-qx*(py*rz-ry*pz)+rx*(py*qz-qy*pz);
RT sig(1);
if (k<=0) {
if(k<0) {
sig=-1;
k=-k;
}
else
CGAL_assertion_msg(k!=0,"Couldn't solve plane equation system");
}
a=sig*(-ph*(qy*rz-ry*qz)+qh*(py*rz-ry*pz)-rh*(py*qz-qy*pz));
b=sig*(px*(rh*qz-qh*rz)-qx*(rh*pz-ph*rz)+rx*(qh*pz-ph*qz));
c=sig*(px*(ry*qh-qy*rh)-qx*(ry*ph-py*rh)+rx*(qy*ph-py*qh));
#ifdef GCD_COMPUTATION
RT dummy=0;
DEBUGENDL(SOLVE_3X3,"Solution of 3x3 (before GCD computation):\n",a
<<std::endl
<<b<<std::endl<<c<<std::endl<<k<<std::endl);
simplify_solution(a,b,c,k,dummy);
#endif
DEBUGENDL(SOLVE_3X3,"Solution of 3x3:\n",a<<std::endl
<<b<<std::endl<<c<<std::endl<<k<<std::endl);
DEBUGMSG(SOLVE_3X3,"End SOLVE_3X3");
}
// *** SOLVE_4X4 ***
//-------------------
//To enumerate EE-pairs we need to solve a 4x4 linear equation system
//The rows of the coefficient matrix
//are the (homogeneous) x,y,z-coordinates of points and the right
//hand side is the homogeneous part of the point times the provided
//coefficient. The system is solved with Cramer's Rule.
template<class InputDA, class PolyPoint_>
bool solve_4x4(InputDA,
const PolyPoint_& p,
const PolyPoint_& q,
const PolyPoint_& r,
const PolyPoint_& v,
RT& a, RT& b, RT& c, RT& d, RT& k) {
DEBUGMSG(SOLVE_4X4,"\nBegin SOLVE_4X4");
RT px,py,pz,ph;
tco.get_point_coordinates(p,px,py,pz,ph);
RT qx,qy,qz,qh;
tco.get_point_coordinates(q,qx,qy,qz,qh);
RT rx,ry,rz,rh;
tco.get_point_coordinates(r,rx,ry,rz,rh);
RT vx,vy,vz,vh;
tco.get_point_coordinates(v,vx,vy,vz,vh);
CGAL_assertion(ph>0 && qh>0 && vh>0 && rh>0);
DEBUGMSG(ASSERTION_OUTPUT,"All homogeneous parts >0. ASSERTION OK.");
DEBUGMSG(SOLVE_4X4,"Matrix: ");
DEBUGENDL(SOLVE_4X4,"",px<<" "<<py<<" "<<pz<<" 0 : "<<-ph);
DEBUGENDL(SOLVE_4X4,"",qx<<" "<<qy<<" "<<qz<<" 0 : "<<-qh);
DEBUGENDL(SOLVE_4X4,"",rx<<" "<<ry<<" "<<rz<<" "<<rh<<" : 0");
DEBUGENDL(SOLVE_4X4,"",vx<<" "<<vy<<" "<<vz<<" "<<vh<<" : 0");
k=-rh*(px*(qy*vz-vy*qz)-qx*(py*vz-vy*pz)+vx*(py*qz-qy*pz))
+vh*(px*(qy*rz-ry*qz)-qx*(py*rz-ry*pz)+rx*(py*qz-qy*pz));
RT sig(1);
if (k<=0) {
if (k<0) {
sig=-1;
k=-k;
DEBUGMSG(SOLVE_4X4,"Sign of k (and of all other coefficients) "
<<"changed.");
} else {
DEBUGMSG(SOLVE_4X4,"No proper solution.");
return false;
}
}
a=sig*(-ph*(qy*(rz*vh-vz*rh)-ry*qz*vh+vy*qz*rh)
+qh*(py*(rz*vh-vz*rh)-ry*pz*vh+vy*pz*rh));
b=sig*(ph*(qx*(rz*vh-vz*rh)-rx*qz*vh+vx*qz*rh)
-qh*(px*(rz*vh-vz*rh)-rx*pz*vh+vx*pz*rh));
c=sig*(-ph*(qx*(ry*vh-vy*rh)-rx*qy*vh+vx*qy*rh)
+qh*(px*(ry*vh-vy*rh)-rx*py*vh+vx*py*rh));
d=sig*(ph*(qx*(ry*vz-vy*rz)-rx*(qy*vz-vy*qz)+vx*(qy*rz-ry*qz))
-qh*(px*(ry*vz-vy*rz)-rx*(py*vz-vy*pz)+vx*(py*rz-ry*pz)));
if (d>k) {
DEBUGMSG(SOLVE_4X4,"d>k: Interchange d and k");
RT tmp=d;
d=k;
k=tmp;
CGAL_assertion(a*px+b*py+c*pz+d*ph==0);
CGAL_assertion(a*qx+b*qy+c*qz+d*qh==0);
CGAL_assertion(a*rx+b*ry+c*rz+k*rh==0);
CGAL_assertion(a*vx+b*vy+c*vz+k*vh==0);
DEBUGMSG(ASSERTION_OUTPUT,"Interchanged k and d. All Assertions ok.");
}
if (a==0 && b==0 && c==0) {
DEBUGENDL(SOLVE_4X4,"Solution of 4x4:\n ",a<<std::endl<<b<<std::endl<<c
<<std::endl
<<d<<std::endl<<k);
CGAL_assertion(a!=0);
CGAL_error();
} else {
#ifdef GCD_COMPUTATION
DEBUGENDL(SOLVE_4X4,"Unique Solution of 4x4 (before GCD computation):\n",
a<<std::endl<<b<<std::endl<<c<<std::endl<<d<<std::endl<<k);
simplify_solution(a,b,c,d,k);
#endif
DEBUGENDL(SOLVE_4X4,"Unique Solution of 4x4:\n",
a<<std::endl<<b<<std::endl<<c<<std::endl<<d<<std::endl<<k);
DEBUGMSG(SOLVE_4X4,"End SOLVE_4X4");
}
return true;
}
// *** CHECK_FEASIBILITY ***
//---------------------------
//This function checks the feasibility of a provided quadruple A/K, B/K,
//C/K and D/K. Because we do not want to check the feasibility for all
//the points the list of points is also expected.
template<class InputDA, class Vertex_handle_>
bool check_feasibility(InputDA,
const RT& a, const RT& b, const RT& c,
const RT& d, const RT& k,
const std::vector<Vertex_handle_>& V) {
DEBUGMSG(CHECK_FEASIBILITY,"\nBegin CHECK_FEASIBILITY");
if (d==k) {
DEBUGMSG(CHECK_FEASIBILITY,"The planes e1 and e2 are the same. "
<<"Not a feasible solution.");
DEBUGMSG(CHECK_FEASIBILITY,"End CHECK_FEASIBILITY");
return false;
}
typename std::vector<Vertex_handle_>::const_iterator
it=V.begin();
RT tmp;
while ( it!=V.end() ) {
RT px,py,pz,ph;
tco.get_point_coordinates((*it)->point(),px,py,pz,ph);
tmp = a*px+b*py+c*pz;
//Check if the restrictions according to p are satisfied
if (tmp+k*ph < 0 || tmp + d*ph > 0) {
#if CHECK_FEASIBILITY
DEBUGENDL(CHECK_FEASIBILITY,"Restriction to point ",
(*it)->point()<<" failed.");
if (tmp+k*ph < 0){
DEBUGENDL(CHECK_FEASIBILITY,"E1 not satisfied: ",tmp+k*ph);
} else {
DEBUGENDL(CHECK_FEASIBILITY,"E2 not satisfied: ",tmp+d*ph);
}
#endif
DEBUGMSG(CHECK_FEASIBILITY,"Feasibility Check failed.");
DEBUGMSG(CHECK_FEASIBILITY,"End CHECK_FEASIBILITY");
return false;
}
++it;
}
//All restrictions are satisfied, thus the check returns true
DEBUGMSG(CHECK_FEASIBILITY,"Feasibility Check was successful.");
DEBUGMSG(CHECK_FEASIBILITY,"End CHECK_FEASIBILITY");
return true;
}
#if GCD_COMPUTATION
// *** GCD ***
//-------------
//To compute the gcd of 2 integer numbers
//PRECONDITION: abs(IntNum) must be defined!
// %-operator must be defined!
template<class IntNum>
IntNum gcd(const IntNum& a, const IntNum& b) {
DEBUGMSG(GCD_OUTPUT,"\nBegin GCD");
DEBUGENDL(GCD_OUTPUT,"Compute gcd of ",a<<" and "<<b);
IntNum r,s,t;
if (abs(a)<abs(b)) {
r=abs(b);
s=abs(a);
} else {
r=abs(a);
s=abs(b);
}
if (s==0) {
DEBUGMSG(GCD_OUTPUT,"End GCD");
return r;
}
t=r%s;
while(t!=0){
r=s;
s=t;
DEBUGENDL(GCD_OUTPUT,"New r: ",r<<" and new s: "<<s);
t=r%s;
}
DEBUGENDL(GCD_OUTPUT,"Return gcd: ",s);
DEBUGMSG(GCD_OUTPUT,"End GCD");
return s;
}
// *** SIMPLIFY_SOLUTION ***
//---------------------------
//To simplify the solutions
template<class IntNum>
void simplify_solution(IntNum& a, IntNum& b, IntNum& c, IntNum& d,
IntNum& k) {
DEBUGMSG(SIMPLIFY_SOLUTION,"\nBegin SIMPLIFY_SOLUTION");
IntNum r=gcd(a,b);
IntNum s=gcd(c,d);
IntNum t=gcd(r,s);
IntNum g=gcd(t,k);
CGAL_assertion(g*(a/g)==a);
a=a/g;
CGAL_assertion(g*(b/g)==b);
b=b/g;
CGAL_assertion(g*(c/g)==c);
c=c/g;
CGAL_assertion(g*(d/g)==d);
d=d/g;
CGAL_assertion(g*(k/g)==k);
k=k/g;
DEBUGENDL(SIMPLIFY_SOLUTION,"Simplified solutions: ",a<<" "<<b<<" "<<c
<<" "<<d<<" "<<k);
DEBUGMSG(SIMPLIFY_SOLUTION,"End SIMPLIFY_SOLUTION");
}
#endif
// ---Width functions---
// *********************
// *** INITIAL_VF_PAIR ***
//-------------------------
//After the first initialization phase we have to compute an initial
//Vertex-Facet pair to start with the enumeration
//PRECONDITION: Normal of initial plane points to the interior of the
// convex hull
template<class InputDA, class Facet_handle_, class Polyhedron_,
class Halfedge_handle_>
void initial_VF_pair(InputDA& dao,
Facet_handle_& f,
Polyhedron_& P,
std::vector<Halfedge_handle_>& go_on)
{
DEBUGMSG(INITIAL_VF_PAIR,"\nBegin INITIAL_VF_PAIR");
DEBUGENDL(INITIAL_VF_PAIR,"Compute initial VF-pair with facet f: ("
<<f->halfedge()->opposite()->vertex()->point()<<"), (",
f->halfedge()->vertex()->point()<<"), ("
<<f->halfedge()->next()->vertex()->point()<<")");
typedef typename InputDA::Vertex_handle Vertex_handle;
//Compute the facet. ==> e2 is fixed
tco.get_plane_coefficients(f->plane(),A,B,C,K);
CGAL_assertion(K>0);
DEBUGMSG(ASSERTION_OUTPUT,"K greater (strictly) than 0. ASSERTION OK.");
//Start with an impossible configuration for the still unknown
//coefficient D=K, ie plane E1 == plane E2
D=K;
DEBUGENDL(INITIAL_VF_PAIR,"Starting with values:\nA:",A<<std::endl
<<"B: "<<B<<std::endl<<"C: "<<C<<std::endl<<"D: "
<<D<<std::endl<<"K: "<<K);
std::vector<Vertex_handle> apv;
#if !(defined(CGAL_KERNEL_NO_ASSERTIONS) || defined(CGAL_NO_ASSERTIONS) \
|| (!defined(CGAL_KERNEL_CHECK_EXPENSIVE) && !defined(CGAL_CHECK_EXPENSIVE))\
|| defined(NDEBUG))
typename InputDA::Vertex_iterator vtxitass = P.vertices_begin();
while(vtxitass!=P.vertices_end()) {
RT px,py,pz,ph;
tco.get_point_coordinates((*vtxitass).point(),px,py,pz,ph);
CGAL_expensive_assertion(ph>0);
CGAL_expensive_assertion(A*px+B*py+C*pz+K*ph>=0);
++vtxitass;
}
DEBUGMSG(ASSERTION_OUTPUT,"All points satisfy restriction "
<<"type E1. ASSERTION OK>");
#endif
typename InputDA::Vertex_iterator vtxit=P.vertices_begin();
RT maxdist=0;
RT hompart=1;
//Try every point to be an/the antipodal vertex of the facet f. Take the
//one with the bigest distance from E1
DEBUGENDL(INITIAL_VF_PAIR,"Plane E1:",f->plane());
while (vtxit != P.vertices_end() ) {
RT pix, piy, piz, pih;
tco.get_point_coordinates((*vtxit).point(),pix,piy,piz,pih);
DEBUGENDL(INITIAL_VF_PAIR,"Try Point: ",(*vtxit).point());
//Compute the sign of the distance from pi to the current plane e2
RT distpie1=A*pix + B*piy + C*piz;
DEBUGENDL(INITIAL_VF_PAIR,"Distance from p to current plane e1: ",
distpie1*hompart);
//If pi is not between e1 and e2, compute a new plane e2 through pi
//If pi is also ON the current plane e2, then insert pi in the list
//of current antipodal vertices of the facet f
if (hompart*distpie1 >= pih*maxdist) {
DEBUGMSG(INITIAL_VF_PAIR,"Distance of this point is greater (or equal)"
<<" than all the distances before."
<<"Change plane antipodal vertices.");
if (hompart*distpie1 > pih*maxdist) {
DEBUGMSG(INITIAL_VF_PAIR,"Compute new plane e2!");
apv.clear();
hompart=pih;
maxdist=distpie1;
}
apv.push_back(vtxit);
}
++vtxit;
}
A=A*hompart;
B=B*hompart;
C=C*hompart;
D=-maxdist;
K=K*hompart;
#ifdef GCD_COMPUTATION
simplify_solution(A,B,C,D,K);
#endif
DEBUGENDL(INITIAL_VF_PAIR,"Initial Plane E1: ",A<<" "<<B<<" "<<C<<" "<<K);
DEBUGENDL(INITIAL_VF_PAIR,"Initial Plane E2: ",A<<" "<<B<<" "<<C<<" "<<D);
#if !(defined(CGAL_KERNEL_NO_ASSERTIONS) || defined(CGAL_NO_ASSERTIONS) \
|| (!defined(CGAL_KERNEL_CHECK_EXPENSIVE) && !defined(CGAL_CHECK_EXPENSIVE))\
|| defined(NDEBUG))
CGAL_expensive_assertion(D!=K && D!=0);
DEBUGMSG(ASSERTION_OUTPUT,"A real plane E2 has been computed. "
<<"ASSERTION OK.");
vtxit=P.vertices_begin();
while (vtxit != P.vertices_end() ) {
RT px, py, pz, ph;
tco.get_point_coordinates((*vtxit).point(),px,py,pz,ph);
CGAL_expensive_assertion(A*px+B*py+C*pz+K*ph>=0);
CGAL_expensive_assertion(A*px+B*py+C*pz+D*ph<=0);
DEBUGENDL(ASSERTION_OUTPUT,"Restriction values: E1:",
A*px+B*py+C*pz+K*ph<<" and E2: "<<A*px+B*py+C*pz+D*ph);
DEBUGENDL(ASSERTION_OUTPUT,"Restrictions E1 and E2 according to "
<<"point "<<(*vtxit).point()
<<" are both satisfied.","ASSERTION OK.");
++vtxit;
}
DEBUGMSG(ASSERTION_OUTPUT,"All restrictions satisfied. "
<<"ASSERTION OK.");
#endif
DEBUGENDL(INITIAL_VF_PAIR,"Initial plane E1:",A<<" "<<B<<" "<<C<<" "<<K);
DEBUGENDL(INITIAL_VF_PAIR,"Initial plane E2:",A<<" "<<B<<" "<<C<<" "<<D);
//set the list of antipodal vertices of f definitly
dao.set_antipodal_vertices(f,apv);
//All solutions
std::vector <RT> sol;
sol.push_back(A);
sol.push_back(B);
sol.push_back(C);
sol.push_back(D);
sol.push_back(K);
allsolutions.push_back(sol);
alloptimal.push_back(sol);
//Compute the squared width with the determined coefficients
WNum=(K-D)*(K-D);
WDenom=A*A+B*B+C*C;
DEBUGENDL(INITIAL_VF_PAIR,"Initial squared width: ",
WNum<<"/"<<WDenom);
//Set all halfedges of f to be possible edges for a rotation
//The set of these edges is used in the third phase of the algorithm
typename InputDA::Halfedge_handle e = f->halfedge();
go_on.push_back(e);
dao.set_visited_flag(e,true);
typename InputDA::Halfedge_handle e0 = e;
e = e->next();
while ( e != e0 ) {
go_on.push_back(e);
dao.set_visited_flag(e,true);
e=e->next();
}
DEBUGMSG(INITIAL_VF_PAIR,"End INITIAL_VF_PAIR");
}
// *** CHECK_ABOUT_VF_PAIRS ***
//------------------------------
//This function checks if a facet and a subset of a given set of vertices
//build a vertex facet pair
template<class InputDA, class Facet_handle_, class Vertex_handle_>
bool
check_about_VF_pairs(InputDA& dao,
Facet_handle_& f,
const std::vector<Vertex_handle_>& V)
{
DEBUGMSG(CHECK_ABOUT_VF_PAIRS,"\nBegin CHECK_ABOUT_VF_PAIRS");
DEBUGMSG(CHECK_ABOUT_VF_PAIRS,"Check, if f has antipodal vertices in "
<<"a set.");
RT a,b,c,d,k;
typename std::vector<typename InputDA::Vertex_handle>
::const_iterator vtxit=V.begin();
std::vector<typename InputDA::Vertex_handle> W;
typename std::vector<typename InputDA::Vertex_handle>
::iterator neighborit;
bool feasible=false;
std::vector<typename InputDA::Vertex_handle> apv;
std::vector<typename InputDA::Vertex_handle> visited_points;
while (vtxit!=V.end()) {
RT vx,vy,vz,vh;
tco.get_point_coordinates((*vtxit)->point(),vx,vy,vz,vh);
tco.get_plane_coefficients(f->plane(),a,b,c,k);
//assume plane e2 parallel to e1 through v: e2:axh+byh+czh+d=0
d = -a*vx - b*vy - c*vz;
CGAL_assertion(vh > 0);
DEBUGMSG(ASSERTION_OUTPUT,"vh is greater than zero (strictly). "
<<"ASSERTION OK.");
a=tco.get_a(f->plane())*vh;
b=tco.get_b(f->plane())*vh;
c=tco.get_c(f->plane())*vh;
k=tco.get_d(f->plane())*vh;
CGAL_assertion(a*vx+b*vy+c*vz+k*vh>=0);
CGAL_assertion(a*vx+b*vy+c*vz+d*vh==0);
DEBUGMSG(ASSERTION_OUTPUT,"Checked: Point on the right side of e1, and "
<<"on e2. ASSERTION OK>");
//If v lies on plane e1 then we can continue (v is not antipodal)
if (d == k) {
CGAL_assertion(a*vx+b*vy+c*vz+k*vh==0);
DEBUGENDL(CHECK_ABOUT_VF_PAIRS,"Point "<<(*vtxit)->point()
<<" lies on plane ",f->plane()<<". Continue.");
++vtxit;
continue;
}
CGAL_assertion(a*vx+b*vy+c*vz+k*vh>0);
DEBUGMSG(ASSERTION_OUTPUT,"v not on e1. ASSERTION OK.");
//Else we look if we can find a witness in the neighborhood of v that
//shows that v is not an antipodal vertex of f
neighbors_of((*vtxit)->halfedge(),W);
//Assume there is no witness for infeasibility
feasible = true;
//Scan all possible witnesses
while(!W.empty()) {
neighborit=W.begin();
visited_points.push_back(*neighborit);
RT nx,ny,nz,nh;
tco.get_point_coordinates((*neighborit)->point(),nx,ny,nz,nh);
//Check if n (neighbor of v) satisfies restriction type e2
//with the presumed plane e2, ie anx+bny+cnz-Dv<=0
CGAL_assertion(a*nx+b*ny+c*nz+k*nh>=0);
DEBUGMSG(ASSERTION_OUTPUT,"Restrictions E1 is satisfied. "
<<"ASSERTION OK.");
if ( a*nx+b*ny+c*nz+d*nh >= 0 ) {
//Could be a violation. Now check if v and n lie on the
//same plane. If so no violation, othervise we can break
if (a*nx+b*ny+c*nz+d*nh == 0 ) {
DEBUGMSG(CHECK_ABOUT_VF_PAIRS,"Additional Antipodal Vertex "
<<"found. Expanding "<<"set of witnesses.");
//v and n are both (so far) antipodal vertices ==>EF-pair
apv.push_back(*neighborit);
//There could now be more witnesses that give violating
//restrictions. Therefore compute the new neighbors of n
std::vector<typename InputDA::Vertex_handle> Wnew;
neighbors_of((*neighborit)->halfedge(),Wnew);
//Erase v from the vertices to be considered as new witnesses
typename
std::vector<typename InputDA::Vertex_handle>
::iterator res= std::find(Wnew.begin(),Wnew.end(),*vtxit);
if ( res!=Wnew.end() )
Wnew.erase(res);
//Erase all the elements we already considered from the new
//set of witnesses
setminus(Wnew,visited_points);
//Erase the neighbor vertex itself from the set of witnesses
W.erase(neighborit);
//Compute the new whole set of witnesses, that is add the
//remaining new ones to the old set of witnesses
setunion(W,Wnew);
} else {
DEBUGENDL(CHECK_ABOUT_VF_PAIRS,"Violation found. Not a feasible "
<<"solution. Violated Point:",(*neighborit)->point());
//there is a violation, so do a break
feasible = false;
break;
}
} else {
DEBUGENDL(CHECK_ABOUT_VF_PAIRS,"Restriction E2 also satisfied by "
<<"point:",(*neighborit)->point());
//There is no violating restriction according to the vertex n
//Erase it from the set of witnesses
W.erase(neighborit);
}
} //end while(!W.empty())
//Now we can determine if we have a feasible solution or not. Because
//the feasible flag can only be set to false during the while-loop
//we can be sure of the feasibility of our solution (no witness found)
//if feasible is false then we have found a witness that v is not an
//antipodal vertex. So we go on in the list of possible antipodal
//vertices otherwise.
if (feasible == true) {
DEBUGMSG(CHECK_ABOUT_VF_PAIRS,"All witnesses checked. "
<<"Update width and antipodal vertices. Return true");
apv.push_back(*vtxit);
#ifdef GCD_COMPUTATION
simplify_solution(a,b,c,d,k);
#endif
update_width(a,b,c,d,k);
dao.set_antipodal_vertices(f,apv);
#ifdef VF_PAIR_OUTPUT
DEBUGENDL(VF_PAIR_OUTPUT,"Antipodal vertices of plane: ",
f->plane());
typename std::vector<Vertex_handle_>::iterator cavfpit=apv.begin();
while(cavfpit!=apv.end()) {
DEBUGENDL(VF_PAIR_OUTPUT,"Antipodal Vertex: ",
(*cavfpit)->point());
++cavfpit;
}
#endif
DEBUGMSG(CHECK_ABOUT_VF_PAIRS,"End CHECK_ABOUT_VF_PAIRS");
return true;
}
++vtxit;
}//end while(vtxit!=V.end())
//If we could not return with antipodal vertices we return false
DEBUGMSG(CHECK_ABOUT_VF_PAIRS,"No new VF-pair found. Return false.");
DEBUGMSG(CHECK_ABOUT_VF_PAIRS,"End CHECK_ABOUT_VF_PAIRS");
return false;
}
// *** UPDATE_WIDTH ***
//----------------------
//This function we use to update the current best width. The old width is
//compared with a new provided one and the better solution will we taken
//as the new width. This function also saves all the possible quadruples
//to be the width of the point set.
void update_width(RT& a, RT& b, RT& c, RT& d, RT& k) {
//Update the list of all possible solutions
DEBUGMSG(UPDATE_WIDTH,"\nBegin UPDATE_WIDTH");
std::vector<RT> sol;
sol.push_back(a);
sol.push_back(b);
sol.push_back(c);
sol.push_back(d);
sol.push_back(k);
allsolutions.push_back(sol);
//Compute the squared width provided by the new solution
RT tocompareNum=(k-d)*(k-d);
RT tocompareDenom=(a*a+b*b+c*c);
DEBUGENDL(UPDATE_WIDTH,"New possible width: ",tocompareNum
<<" / "<<tocompareDenom);
//Compare with old width
if (WNum*tocompareDenom >= tocompareNum*WDenom) {
if (WNum*tocompareDenom > tocompareNum*WDenom){
DEBUGMSG(UPDATE_WIDTH,"Optimal width changes");
WNum=tocompareNum;
WDenom=tocompareDenom;
alloptimal.clear();
alloptimal.push_back(sol);
A=a;
B=b;
C=c;
D=d;
K=k;
} else {
//now we have an additional optimal solution
alloptimal.push_back(sol);
}
}//end if equal or better width
DEBUGMSG(UPDATE_WIDTH,"End UPDATE_WIDTH");
}
// *** EE_COMPUTATION ***
//------------------------
//During the 3rd phase of the width-algorithm we have to rotate planes to
//enumerate all possible edge-edge pairs. This rotating (in primal context)
//resp. tracking edges (in the dual context) is made by the following
//function. The edge we rotate about is called e. To ensure only to
//enumerate a pair once (...only going forward) we need a set of
//already visited vertices (Visited) and a set of vertices from that we know
//they are antipodal to the first facet (V). In this function we don't
//know the antipodal vertices of the second facet.
template <class InputDA, class Halfedge_handle_, class Vertex_handle_>
void EE_computation(InputDA,
Halfedge_handle_& e,
std::vector<Vertex_handle_>& V,
std::vector<Vertex_handle_>& Visited,
std::vector<Vertex_handle_>& Nnew) {
DEBUGMSG(EE_COMPUTATION,"\nBegin EE_COMPUTATION");
//Compute end points of e and two witnesses: Each in one of the two
//facets participating
Point_3 p,q;
p=e->opposite()->vertex()->point();
q=e->vertex()->point();
typename InputDA::Vertex_handle w1=e->next()->vertex();
typename InputDA::Vertex_handle w2=e->opposite()->next()->vertex();
//prepare for the rotating procedure
Nnew.clear();
typename std::vector<typename InputDA::Vertex_handle>
::iterator vtxit=V.begin();
//Consider all the vertices in V. EE-pairs consist of p,q and the
//vertex v in V and another neighbor vertex of v
while(vtxit != V.end() ) {
std::vector<typename InputDA::Vertex_handle> R;
neighbors_of((*vtxit)->halfedge(),R);
std::vector<typename InputDA::Vertex_handle> Witnesses;
//The set of witnesses are all neighbor vertices of v (=R) and the
//two vertices "on the other side" that ensure not rotating too far
Witnesses.push_back(w1);
Witnesses.push_back(w2);
setunion(Witnesses,R);
//The neighbor vertices of v that are also in the basic set V are of no
//interest, so we exclude them
setminus(R,V);
//The set of all vertices we have already visited is also of no interest
setminus(R,Visited);
typename std::vector<typename InputDA::Vertex_handle>
::iterator rit=R.begin();
//Now look at the modified set of neighbor vertices. For each neighbor r
//we assume (p,q) and (v,r) to be an EE-pair and want then to find
//witnesses that against this quadruple. If no such witness exist
//(p,q) and (v,r) are a legal EE-pair. In that case we break the
//quest and update all the sets Visited Nnew and V. If we have considered
//all vertices v in V and all the respective r in R and if we have
//not found a legal EE-pair, then an error occurs
while (rit!=R.end()) {
RT a,b,c,d,k;
//It could be that the system is not uniquely solvable we only want to
//enumerate proper solutions no degenerate ones
if(solve_4x4(InputDA(),p,q,(*rit)->point(),(*vtxit)->point(),
a,b,c,d,k)){
DEBUGMSG(EE_COMPUTATION,"Now we check if the provided "
<<"solution is a feasible one.");
#if !(defined(CGAL_KERNEL_NO_ASSERTIONS) || defined(CGAL_NO_ASSERTIONS) \
|| (!defined(CGAL_KERNEL_CHECK_EXPENSIVE) && !defined(CGAL_CHECK_EXPENSIVE))\
|| defined(NDEBUG))
RT px,py,pz,ph;
tco.get_point_coordinates(p,px,py,pz,ph);
CGAL_expensive_assertion(a*px+b*py+c*pz+k*ph>=0);
CGAL_expensive_assertion(a*px+b*py+c*pz+d*ph<=0);
tco.get_point_coordinates(q,px,py,pz,ph);
CGAL_expensive_assertion(a*px+b*py+c*pz+k*ph>=0);
CGAL_expensive_assertion(a*px+b*py+c*pz+d*ph<=0);
tco.get_point_coordinates((*rit)->point(),px,py,pz,ph);
CGAL_expensive_assertion(a*px+b*py+c*pz+k*ph>=0);
CGAL_expensive_assertion(a*px+b*py+c*pz+d*ph<=0);
tco.get_point_coordinates((*vtxit)->point(),px,py,pz,ph);
CGAL_expensive_assertion(a*px+b*py+c*pz+k*ph>=0);
CGAL_expensive_assertion(a*px+b*py+c*pz+d*ph<=0);
DEBUGMSG(ASSERTION_OUTPUT,"All restrictions to the 4 points "
<<"are satisfied. ASSERTION OK.");
#endif
if (check_feasibility(InputDA(),a,b,c,d,k,Witnesses)) {
DEBUGMSG(EE_COMPUTATION,"Update Width and compute all "
<<"active restrictions");
//Therefore we update the width
update_width(a,b,c,d,k);
//The next region we consider (because we only go forward)
//contains (at least) r
Nnew.push_back(*rit);
//Now we look if we are in a special case, that is we look if
//other restrictions according to neighboring vertices of r
//are also active. If so Nnew is expanded we them.
std::vector<typename InputDA::Vertex_handle> S;
neighbors_of((*rit)->halfedge(),S);
//Because we only go forward we exclude v from the neighbor set S
std::vector<typename InputDA::Vertex_handle> vtemp;
vtemp.push_back(*vtxit);
setminus(S,vtemp);
//The check of more than 4 active restrictions begins
typename
std::vector<typename InputDA::Vertex_handle>
::iterator sit;
while(!S.empty()) {
sit=S.begin();
RT sx,sy,sz,sh;
tco.get_point_coordinates((*sit)->point(),sx,sy,sz,sh);
if (a*sx+b*sy+c*sz+d*sh==0) {
//This special case occurs now. Thus we extend Nnew
Nnew.push_back(*sit);
//In the neighborhood of this new active vertex could
//also be other new active vertices but we are only interested
//in new ones
std::vector<typename InputDA::Vertex_handle> T;
neighbors_of((*sit)->halfedge(),T);
S.erase(sit);
setunion(S,T);
T.clear();
T.push_back(*vtxit);
setminus(S,T);
setminus(S,Nnew);
} else {
//s is not active and we can erase it
S.erase(sit);
}
} //end while (!S.empty())
//Since we have now enumerated all EE-pairs with the active
//restrictions according to p,q and v we can now leave
//Nnew contains now all new active restrictions
DEBUGMSG(EE_COMPUTATION,"End EE_COMPUTATION");
return;
} //end if (feasible)
}//end if(proper)
//Try next r
++rit;
}//end while(!R.empty())
//Try new v
++vtxit;
}
//There must be a new EE-pair. If not, an error occurs
std::cerr<<"No new EE-pair found!"<<std::endl;
CGAL_error();
}
// *** EE_PAIRS ***
//------------------------
//This function is similar to EE_computation. The difference is that now
//we know the antipodal vertices of BOTH participating facets
template <class InputDA, class Halfedge_handle_>
void EE_pairs(InputDA& dao,
Halfedge_handle_& e,
std::vector<Halfedge_handle_>& impassable) {
DEBUGMSG(EE_PAIRS,"\nBegin EE_PAIRS");
Point_3 p,q;
p=e->opposite()->vertex()->point();
q=e->vertex()->point();
typename InputDA::Vertex_handle w1=e->next()->vertex();
typename InputDA::Vertex_handle w2=e->opposite()->next()->vertex();
typename InputDA::Facet_handle f1=e->facet();
typename InputDA::Facet_handle f2=e->opposite()->facet();
std::vector<typename InputDA::Vertex_handle> V1;
std::vector<typename InputDA::Vertex_handle> V2;
dao.get_antipodal_vertices(f1,V1);
dao.get_antipodal_vertices(f2,V2);
std::vector<typename InputDA::Vertex_handle> N,V,Visited;
V=V1;
bool do_break = false;
while (!setcut(V,V2)) {
do_break = false;
typename std::vector<typename InputDA::Vertex_handle>
::iterator vtxit=V.begin();
std::vector<typename InputDA::Vertex_handle> R;
while (vtxit!=V.end()) {
neighbors_of((*vtxit)->halfedge(),R);
std::vector<typename InputDA::Vertex_handle> Witnesses;
Witnesses.push_back(w1);
Witnesses.push_back(w2);
setunion(Witnesses,R);
setminus(R,V);
setminus(R,Visited);
typename std::vector<typename InputDA::Vertex_handle>
::iterator rit=R.begin();
while (rit!=R.end()) {
RT a,b,c,d,k;
//It could be that the system is not uniquely solvable we only want
//to enumerate proper solutions no degenerate ones
if(solve_4x4(InputDA(),p,q,(*rit)->point(),(*vtxit)->point(),
a,b,c,d,k)){
if (check_feasibility(InputDA(),a,b,c,d,k,Witnesses)) {
update_width(a,b,c,d,k);
N.push_back(*rit);
std::vector<typename InputDA::Vertex_handle> S;
neighbors_of((*rit)->halfedge(),S);
setminus(S,V);
typename
std::vector<typename InputDA::Vertex_handle>
::iterator sit;
while(!S.empty()) {
sit=S.begin();
RT sx,sy,sz,sh;
tco.get_point_coordinates((*sit)->point(),sx,sy,sz,sh);
if (a*sx+b*sy+c*sz+d*sh== 0) {
N.push_back(*sit);
std::vector<typename InputDA::Vertex_handle>
T;
neighbors_of((*sit)->halfedge(),T);
S.erase(sit);
setunion(S,T);
T.clear();
T.push_back(*vtxit);
setminus(S,T);
setminus(S,N);
} else {
S.erase(sit);
}
}//end while (!S.empty())
do_break=true;
break;
}//if (feasible)
}//if(proper)
++rit;
}//end while(!R.empty())
if (do_break == true)
break;
++vtxit;
}//end while(!V.end())
setunion(Visited,V);
V=N;
}
impassable.pop_back();
//Go on with next edge
DEBUGMSG(EE_PAIRS,"End EE_PAIRS");
}
// *** ORIGIN_INSIDE_CH ***
//-------------------------
// To ensure that zero lies completly inside the convex hull of a point set.
// Returns true if the point set is not coplanar, false otherwise
// PRECONDITION: Iterator range has at least 3 points
template<class InputDA, class Vertex_iterator_>
bool origin_inside_CH(Vertex_iterator_& start,
Vertex_iterator_& beyond,
InputDA){
DEBUGMSG(ORIGIN_INSIDE_CH,"\nBegin ORIGIN_INSIDE_CH");
typename InputDA::Vertex_iterator first=start;
//Take 4 points that build a tetrahedron. This tetrahedron is also
//contained in the convex hull of the points. Thus every point
//in/on this tetrahedron is a valable point for a new origin
typename InputDA::PolyPoint p,q,r,s;
p=(*first).point();
++first;
q=(*first).point();
++first;
r=(*first).point();
++first;
RT px,py,pz,ph,qx,qy,qz,qh,rx,ry,rz,rh;
tco.get_point_coordinates(p,px,py,pz,ph);
tco.get_point_coordinates(q,qx,qy,qz,qh);
tco.get_point_coordinates(r,rx,ry,rz,rh);
CGAL_assertion(ph>0 && qh>0 && rh>0);
RT tmpa,tmpb,tmpc,tmpk;
tmpk=px*(qy*rz-ry*qz)-qx*(py*rz-ry*pz)+rx*(py*qz-qy*pz);
tmpa=-ph*(qy*rz-ry*qz)+qh*(py*rz-ry*pz)-rh*(py*qz-qy*pz);
tmpb=px*(rh*qz-qh*rz)-qx*(rh*pz-ph*rz)+rx*(qh*pz-ph*qz);
tmpc=px*(ry*qh-qy*rh)-qx*(ry*ph-py*rh)+rx*(qy*ph-py*qh);
#ifdef GCD_COMPUTATION
RT dummy=0;
DEBUGENDL(ORIGIN_INSIDE_CH,"Solution of 3x3 (before GCD "
<<"computation):\n",tmpa<<std::endl
<<tmpb<<std::endl<<tmpc<<std::endl<<tmpk<<std::endl);
simplify_solution(tmpa,tmpb,tmpc,tmpk,dummy);
#endif
if (first==beyond) {
DEBUGMSG(ORIGIN_INSIDE_CH,"3 coplanar Points. Computed plane through "
<<"these points. Width=0.");
WNum=0;
WDenom=1;
A=tmpa;
B=tmpb;
C=tmpc;
K=tmpk;
DEBUGENDL(ORIGIN_INSIDE_CH,"Solution of 3x3:\n",A<<std::endl
<<B<<std::endl<<C<<std::endl<<K<<std::endl);
D=K;
std::vector <RT> sol;
sol.push_back(A);
sol.push_back(B);
sol.push_back(C);
sol.push_back(D);
sol.push_back(K);
allsolutions.push_back(sol);
alloptimal.push_back(sol);
DEBUGMSG(ORIGIN_INSIDE_CH,"End ORIGIN_INSIDE_CH");
return false;
} else {
s=(*first).point();
RT sx,sy,sz,sh;
tco.get_point_coordinates(s,sx,sy,sz,sh);
//Ensure that the 4 points are not coplanar. If so take another 4th point
while (tmpa*sx+tmpb*sy+tmpc*sz+tmpk*sh==0 && first!=beyond) {
s=(*first).point();
tco.get_point_coordinates(s,sx,sy,sz,sh);
++first;
}
//If we could not find a valable 4th point, then the set of the points
//is coplanar. Therefore the width is zero and we can terminate the
//algorithm
if (tmpa*sx+tmpb*sy+tmpc*sz+tmpk*sh==0) {
DEBUGMSG(ORIGIN_INSIDE_CH,"n coplanar Points. Compute plane through "
<<"these points. Width=0.");
WNum=0;
WDenom=1;
A=tmpa;
B=tmpb;
C=tmpc;
K=tmpk;
DEBUGENDL(ORIGIN_INSIDE_CH,"Solution of 3x3:\n",A<<std::endl
<<B<<std::endl<<C<<std::endl<<K<<std::endl);
D=K;
std::vector <RT> sol;
sol.push_back(A);
sol.push_back(B);
sol.push_back(C);
sol.push_back(D);
sol.push_back(K);
allsolutions.push_back(sol);
alloptimal.push_back(sol);
DEBUGMSG(ORIGIN_INSIDE_CH,"End ORIGIN_INSIDE_CH");
return false;
} else {
//Take center of tetrahedron pqrs
RT ux,uy,uz,uh,vx,vy,vz,vh,nox,noy,noz,noh;
ux=px*qh+ph*qx;
vx=rx*sh+rh*sx;
uy=py*qh+ph*qy;
vy=ry*sh+rh*sy;
uz=pz*qh+ph*qz;
vz=rz*sh+rh*sz;
uh=RT(2)*ph*qh;
vh=RT(2)*rh*sh;
nox=ux*vh+uh*vx;
noy=uy*vh+uh*vy;
noz=uz*vh+uh*vz;
noh=RT(2)*uh*vh;
neworigin=tco.make_point(nox,noy,noz,noh);
CGAL_assertion(noh!=0);
DEBUGENDL(ORIGIN_INSIDE_CH,"New Origin: ",neworigin);
//Translate all the points
first=start;
while(first!=beyond) {
typename InputDA::PolyPoint tmp=(*first).point();
RT tmpx,tmpy,tmpz,tmph;
tco.get_point_coordinates(tmp,tmpx,tmpy,tmpz,tmph);
RT newx,newy,newz,newh;
newx=tmpx*noh-tmph*nox;
newy=tmpy*noh-tmph*noy;
newz=tmpz*noh-tmph*noz;
newh=tmph*noh;
DEBUGENDL(ORIGIN_INSIDE_CH,"Old Point: ",(*first).point());
#ifdef GCD_COMPUTATION
RT dummy=0;
simplify_solution(newx,newy,newz,newh,dummy);
#endif
(*first).point()=tco.make_point(newx,newy,newz,newh);
DEBUGENDL(ORIGIN_INSIDE_CH,"New Point: ",(*first).point());
++first;
}
DEBUGMSG(ORIGIN_INSIDE_CH,"Zero now inside polyhedron.");
DEBUGMSG(ORIGIN_INSIDE_CH,"End ORIGIN_INSIDE_CH");
return true;
}
}
}
/* ****************************************************** */
/* *** --- *** The main enumeration functions *** --- *** */
/* ****************************************************** */
template<class InputPolyhedron>
void width_3_convex(InputPolyhedron &P) {
DEBUGMSG(WIDTH_3_CONVEX,"\nBegin WIDTH_3_CONVEX");
typedef CGAL::Width_3_internal::Data_access<InputPolyhedron,Traits> DA;
typedef typename DA::Facet_handle Facet_handle;
typedef typename DA::Vertex_handle Vertex_handle;
typedef typename DA::Halfedge_handle Halfedge_handle;
typedef typename DA::Vertex_iterator Vertex_iterator;
//Ensure that Polyhedron has at least one vertex
CGAL_assertion_msg(P.size_of_vertices()>2,
"Can not compute width of a 0, 1 or 2-vertex polyhedron");
Vertex_iterator first=P.vertices_begin();
Vertex_iterator beyond=P.vertices_end();
//Begin with Phase 2
if (origin_inside_CH(first,beyond,DA())) {
DEBUGMSG(WIDTH_3_CONVEX,"Origin is now Inside the Polyhedron. "
<<std::endl
<<"And polyhedron has at least 4 not coplanar vertices");
DA dao;
std::vector<Halfedge_handle> go_on;
std::vector<Halfedge_handle> impassable;
//Ensure that the plane equations are determined because of the
//compare operator in DA
Facet_handle feq=P.facets_begin();
while(feq!=P.facets_end()) {
compute_plane_equation(DA(),feq);
++feq;
}
DEBUGMSG(WIDTH_3_CONVEX,"All plane equations of all facets computed.");
//ensure all flags are false
#if !(defined(CGAL_KERNEL_NO_ASSERTIONS) || defined(CGAL_NO_ASSERTIONS) \
|| defined(NDEBUG))
int halfedgecount=0;
#endif
Halfedge_handle esf=P.halfedges_begin();
while(esf!=P.halfedges_end()) {
#if !(defined(CGAL_KERNEL_NO_ASSERTIONS) || defined(CGAL_NO_ASSERTIONS) \
|| defined(NDEBUG))
++halfedgecount;
#endif
DEBUGENDL(EDGE_INITIALIZING,"Edge e: "
<<esf->opposite()->vertex()->point()
<<" --> ",esf->vertex()->point());
dao.set_visited_flag(esf,false);
dao.set_impassable_flag(esf,false);
++esf;
}
#if !(defined(CGAL_KERNEL_NO_ASSERTIONS) || defined(CGAL_NO_ASSERTIONS) \
|| defined(NDEBUG))
CGAL_assertion(int(P.size_of_halfedges())==halfedgecount);
DEBUGENDL(WIDTH_3_CONVEX,"Visited all ",halfedgecount
<<" halfedges. ASSERTION OK.");
CGAL_assertion(dao.size_of_visited()==halfedgecount);
CGAL_assertion(dao.size_of_impassable()==halfedgecount);
DEBUGMSG(WIDTH_3_CONVEX,"Map sizes of visited and impassable "
<<"halfedges are correct. ASSERTION OK.");
#endif
DEBUGMSG(WIDTH_3_CONVEX,"All flags set to false.");
//Now begin with the main enumeration
Facet_handle f = P.facets_begin();
initial_VF_pair(dao,f,P,go_on);
#if !(defined(CGAL_KERNEL_NO_ASSERTIONS) || defined(CGAL_NO_ASSERTIONS) \
|| (!defined(CGAL_KERNEL_CHECK_EXPENSIVE) && !defined(CGAL_CHECK_EXPENSIVE))\
|| defined(NDEBUG))
Vertex_iterator vtxass=P.vertices_begin();
while(vtxass!=P.vertices_end()) {
RT px,py,pz,ph;
tco.get_point_coordinates(vtxass->point(),px,py,pz,ph);
CGAL_expensive_assertion(A*px+B*py+C*pz+K*ph>=0);
CGAL_expensive_assertion(A*px+B*py+C*pz+D*ph<=0);
++vtxass;
}
//Assert that the initial facet has antipodal vertices
//and that all incident edges are visited (flag=true) but
//that the impassable flag is not set yet.
std::vector<Vertex_handle> avass;
dao.get_antipodal_vertices(f,avass);
DEBUGENDL(ASSERTION_OUTPUT,"Size of avass: ",avass.size());
CGAL_expensive_assertion(avass.size()!=0);
Halfedge_handle eass=f->halfedge();
Halfedge_handle eass0=eass;
CGAL_expensive_assertion(dao.is_visited(eass));
CGAL_expensive_assertion(!dao.is_impassable(eass));
eass=eass->next();
while (eass != eass0) {
CGAL_expensive_assertion(dao.is_visited(eass));
CGAL_expensive_assertion(!dao.is_impassable(eass));
eass=eass->next();
}
DEBUGMSG(ASSERTION_OUTPUT,"All edges of the first initial facet "
<<"has a visited flag.");
#endif
// Begin Phase 3
Facet_handle fnext;
Halfedge_handle e;
std::vector<Vertex_handle> Visited;
std::vector<Vertex_handle> N;
std::vector<Vertex_handle> Nnew;
//While there still exist an edge we can rotate an incident facet with
//known antipodal vertices in the other facet with unknown antipodal
//vertices then do this rotation
while ( !go_on.empty()) {
DEBUGENDL(WIDTH_3_CONVEX,"Size of go_on: ",go_on.size());
#ifdef GO_ON_OUTPUT
DEBUGMSG(GO_ON_OUTPUT,"Edges on stack go_on:");
typename std::vector<Halfedge_handle>::iterator
goonit=go_on.begin();
while(goonit!=go_on.end()) {
DEBUGENDL(GO_ON_OUTPUT,"Edge: ",
(*goonit)->opposite()->vertex()->point()<<" --> "
<<(*goonit)->vertex()->point());
++goonit;
}
#endif
//Take last edge on stack go_on
e=go_on.back();
//Check if e is a proper edge or not. If so determine fnext
if (preparation_check(dao,e,fnext,go_on,impassable)) {
DEBUGMSG(WIDTH_3_CONVEX,"Preparation Check successful");
//f is the facet of which we know the antipodal vertices
f=e->facet();
Visited.clear();
dao.get_antipodal_vertices(f,N);
CGAL_assertion (!N.empty());
DEBUGMSG(ASSERTION_OUTPUT,"f has some antipodal vertices. Assertion "
<<"successful.");
while(!check_about_VF_pairs(dao,fnext,N)) {
DEBUGMSG(WIDTH_3_CONVEX,"No new VF-pair. Continue (Begin) "
<<"rotation of the planes.");
EE_computation(DA(),e,N,Visited,Nnew);
DEBUGMSG(WIDTH_3_CONVEX,"Planes have been rotated. Check now "
<<"for a new VF-pair");
setunion(Visited,N);
N=Nnew;
}
}
}
#if !(defined(CGAL_KERNEL_NO_ASSERTIONS) || defined(CGAL_NO_ASSERTIONS) \
|| (!defined(CGAL_KERNEL_CHECK_EXPENSIVE) && !defined(CGAL_CHECK_EXPENSIVE))\
|| defined(NDEBUG))
Facet_handle fass=P.facets_begin();
while(fass!=P.facets_end()) {
std::vector<Vertex_handle> apvass;
dao.get_antipodal_vertices(fass,apvass);
DEBUGENDL(ASSERTION,"Current checking facet: ",fass->plane());
CGAL_assertion(!apvass.empty());
++fass;
}
DEBUGMSG(ASSERTION,"All facets have antipodal vertices. "
<<"ASSERTION OK.");
Facet_handle fec = P.facets_begin();
std::vector<Halfedge_handle> fakego_on;
DA daoec;
while(fec!=P.facets_end()) {
std::vector<Vertex_handle> avec;
std::vector<Vertex_handle> avivf;
initial_VF_pair(daoec,fec,P,fakego_on);
daoec.get_antipodal_vertices(fec,avec);
dao.get_antipodal_vertices(fec,avivf);
CGAL_assertion(int(avivf.size())==int(avec.size()));
CGAL_assertion(int(avec.size())>0);
DEBUGENDL(EXPENSIVE_CHECKS_OUTPUT,"Antipodal vertices of facet: ("
<<fec->halfedge()->opposite()->vertex()->point()
<<"), (",fec->halfedge()->vertex()->point()<<"), ("
<<fec->halfedge()->next()->vertex()->point()<<")");
std::vector<Vertex_handle>::iterator vtxit=avec.begin();
while(vtxit!=avec.end()) {
std::vector<Vertex_handle>::iterator it;
it=std::find(avivf.begin(),avivf.end(),*vtxit);
CGAL_assertion(it!=avivf.end());
DEBUGENDL(EXPENSIVE_CHECKS_OUTPUT,"Antipodal vertex: ",
(*vtxit)->point());
++vtxit;
}
++fec;
}
DEBUGMSG(EXPENSIVE_CHECKS_OUTPUT,"All VF-pairs verified. "
<<"Expensive Check successful.");
//
// This assertion should not currently be true since the convex hull
// polyhedron is triangulated; no postprocessing is done to merge coplanar
// neighboring facets.
//
// CGAL_assertion(dao.size_of_antipodal_vertices()
// ==int(P.size_of_facets()));
#endif
//Begin with phase 4. As long as the set of impassable edges is not empty
//rotate one of the planes into the other sharing the impassable edge
while(!impassable.empty()) {
//Take top edge on stack impassable
e=impassable.back();
EE_pairs(dao,e,impassable);
//In EE_pairs the top element will be removed
}
}
DEBUGMSG(WIDTH_3_CONVEX,"Width computed.");
}
};
} //namespace CGAL
#endif
Reference in New Issue View Git Blame Copy Permalink