Gabriele Cosmo
2803 lines
87 KiB
Plaintext
2803 lines
87 KiB
Plaintext
// Copyright (C) 2010, Guy Barrand. All rights reserved.
|
|
// See the file tools.license for terms.
|
|
|
|
/***********************************************************************
|
|
* *
|
|
* Name: BooleanProcessor Date: 10.12.99 *
|
|
* Author: E.Chernyaev Revised: *
|
|
* *
|
|
* Function: Internal class for executing boolean operations *
|
|
* on Polyhedra *
|
|
* *
|
|
***********************************************************************/
|
|
|
|
#include "../lina/plane"
|
|
|
|
//#define TOOLS_HEP_BP_OUT_ERR
|
|
//#define TOOLS_HEP_BP_CHECK_INDEX
|
|
|
|
//#define TOOLS_HEP_BP_VERBOSE
|
|
//#define TOOLS_HEP_BP_NOT_OPT
|
|
|
|
#if defined(TOOLS_HEP_BP_OUT_ERR) || defined(TOOLS_HEP_BP_VERBOSE) || defined(TOOLS_HEP_BP_CHECK_INDEX)
|
|
#include <iostream>
|
|
#endif
|
|
|
|
namespace tools {
|
|
namespace hep {
|
|
|
|
typedef plane<vec3d> HVPlane3D;
|
|
|
|
const double GRANULARITY = 10.e+5;
|
|
|
|
// Operations
|
|
const int OP_UNION = 0;
|
|
const int OP_INTERSECTION = 1;
|
|
const int OP_SUBTRACTION = 2;
|
|
|
|
// Face vs face statuses
|
|
const int OUT_OF_PLANE = 0;
|
|
const int ON_PLANE = 1;
|
|
const int INTERSECTION = 2;
|
|
const int EDGE = 3;
|
|
const int NON_PLANAR_FACE = 4;
|
|
|
|
// Face statuses
|
|
const int UNKNOWN_FACE = 0;
|
|
const int ORIGINAL_FACE = -1;
|
|
const int NEW_FACE = -2;
|
|
const int UNSUITABLE_FACE = -3;
|
|
const int DEFECTIVE_FACE = -4;
|
|
|
|
// -------------------------------------------- Simplified STL vector ---
|
|
//G.Barrand : begin
|
|
//#include <vector>
|
|
//G.Barrand : end
|
|
|
|
// ---------------------------------------------------- Extended node ---
|
|
class ExtNode {
|
|
#ifdef TOOLS_MEM
|
|
TOOLS_SCLASS(tools::hep::ExtNode)
|
|
#endif
|
|
public:
|
|
HVPoint3D v;
|
|
int s;
|
|
|
|
public:
|
|
ExtNode(HVPoint3D vertex=HVPoint3D(), int status=0)
|
|
: v(vertex), s(status) {
|
|
#ifdef TOOLS_MEM
|
|
mem::increment(s_class().c_str());
|
|
#endif
|
|
}
|
|
~ExtNode() {
|
|
#ifdef TOOLS_MEM
|
|
mem::decrement(s_class().c_str());
|
|
#endif
|
|
}
|
|
|
|
ExtNode(const ExtNode & node) : v(node.v), s(node.s) {
|
|
#ifdef TOOLS_MEM
|
|
mem::increment(s_class().c_str());
|
|
#endif
|
|
}
|
|
|
|
ExtNode & operator=(const ExtNode & node) {
|
|
v = node.v;
|
|
s = node.s;
|
|
return *this;
|
|
}
|
|
};
|
|
|
|
// ---------------------------------------------------- Extended edge ---
|
|
class ExtEdge {
|
|
#ifdef TOOLS_MEM
|
|
TOOLS_SCLASS(tools::hep::ExtEdge)
|
|
#endif
|
|
public:
|
|
int i1, i2; // end points
|
|
int iface1; // native face
|
|
int iface2; // neighbouring face
|
|
int ivis; // visibility: +1 (visible), -1 (invisible)
|
|
int inext; // index of next edge
|
|
|
|
public:
|
|
ExtEdge(int k1=0, int k2=0, int kface1=0, int kface2=0, int kvis=0) :
|
|
i1(k1), i2(k2), iface1(kface1), iface2(kface2), ivis(kvis), inext(0) {
|
|
#ifdef TOOLS_MEM
|
|
mem::increment(s_class().c_str());
|
|
#endif
|
|
}
|
|
|
|
~ExtEdge() {
|
|
#ifdef TOOLS_MEM
|
|
mem::decrement(s_class().c_str());
|
|
#endif
|
|
}
|
|
|
|
ExtEdge(const ExtEdge & edge) :
|
|
i1(edge.i1), i2(edge.i2), iface1(edge.iface1), iface2(edge.iface2),
|
|
ivis(edge.ivis), inext(edge.inext) {
|
|
#ifdef TOOLS_MEM
|
|
mem::increment(s_class().c_str());
|
|
#endif
|
|
}
|
|
|
|
ExtEdge & operator=(const ExtEdge & edge) {
|
|
i1 = edge.i1;
|
|
i2 = edge.i2;
|
|
iface1 = edge.iface1;
|
|
iface2 = edge.iface2;
|
|
ivis = edge.ivis;
|
|
inext = edge.inext;
|
|
return *this;
|
|
}
|
|
|
|
void invert() {
|
|
int w;
|
|
//#define SWAP(A,B) w = A; A = B; B = w
|
|
//SWAP(i1, i2);
|
|
w = i1;i1=i2;i2=w;
|
|
}
|
|
};
|
|
|
|
// ---------------------------------------------------- Extended face ---
|
|
class ExtFace {
|
|
private:
|
|
#ifdef TOOLS_MEM
|
|
TOOLS_SCLASS(tools::hep::ExtFace)
|
|
#endif
|
|
std::vector<ExtEdge>& edges; //G.Barrand
|
|
public:
|
|
int iedges[4]; // indices of original edges
|
|
HVPlane3D plane; // face plane
|
|
double rmin[3], rmax[3]; // bounding box
|
|
int iold; // head of the list of the original edges
|
|
int inew; // head of the list of the new edges
|
|
int iprev; // index of previous face
|
|
int inext; // index of next face
|
|
|
|
public:
|
|
//G.Barrand : ExtFace(int iedge=0) : iold(iedge), inew(0), iprev(iprev), inext(0) {}
|
|
ExtFace(std::vector<ExtEdge>& a_edges,int iedge)
|
|
: edges(a_edges), iold(iedge), inew(0), iprev(0), inext(0) {
|
|
#ifdef TOOLS_MEM
|
|
mem::increment(s_class().c_str());
|
|
#endif
|
|
//G.Barrand : initialize arrays to quiet valgrind.
|
|
{for (int i=0; i<4; i++) { iedges[i] = 0; }}
|
|
{for (int i=0; i<3; i++) { rmin[i] = 0; rmax[i] = 0; }}
|
|
}
|
|
~ExtFace() {
|
|
#ifdef TOOLS_MEM
|
|
mem::decrement(s_class().c_str());
|
|
#endif
|
|
}
|
|
|
|
ExtFace(const ExtFace & face) :
|
|
edges(face.edges), //G.Barrand
|
|
plane(face.plane), iold(face.iold), inew(face.inew),
|
|
iprev(face.iprev), inext(face.inext)
|
|
{
|
|
#ifdef TOOLS_MEM
|
|
mem::increment(s_class().c_str());
|
|
#endif
|
|
int i;
|
|
for (i=0; i<4; i++) { iedges[i] = face.iedges[i]; }
|
|
for (i=0; i<3; i++) { rmin[i] = face.rmin[i]; rmax[i] = face.rmax[i]; }
|
|
}
|
|
|
|
ExtFace & operator=(const ExtFace & face) {
|
|
//FIXME : edges(face.edges) ???? //G.Barrand
|
|
int i;
|
|
for (i=0; i<4; i++) { iedges[i] = face.iedges[i]; }
|
|
plane = face.plane;
|
|
for (i=0; i<3; i++) { rmin[i] = face.rmin[i]; rmax[i] = face.rmax[i]; }
|
|
iold = face.iold;
|
|
inew = face.inew;
|
|
iprev = face.iprev;
|
|
inext = face.inext;
|
|
return *this;
|
|
}
|
|
|
|
bool invert(); //G.Barrand : return bool.
|
|
|
|
//G.Barrand
|
|
#ifdef TOOLS_HEP_BP_CHECK_INDEX
|
|
bool check_edge_index(const std::string& a_where,int a_index) {
|
|
if(a_index<0) {
|
|
std::cerr << "ExtFace::check_edge_index :"
|
|
<< " " << a_where << " :"
|
|
<< " i<0."
|
|
<< std::endl;
|
|
return false;
|
|
}
|
|
if(a_index>=int(edges.size())) {
|
|
std::cerr << "ExtFace::check_edge_index :"
|
|
<< " " << a_where << " :"
|
|
<< " i>=sz."
|
|
<< " i=" << a_index
|
|
<< " sz=" << edges.size()
|
|
<< " cap=" << edges.capacity()
|
|
<< std::endl;
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
#endif
|
|
};
|
|
|
|
// ---------------------------------------------------- Global arrays ---
|
|
//G.Barrand : MacIntel : crash with g++-4.0.1 with -O on some subtract.
|
|
// Anyway static of objects is proved to be not safe.
|
|
// We put the below vector as members of BooleanProcessor.
|
|
//GB static std::vector<ExtNode> nodes; // vector of nodes
|
|
//GB static std::vector<ExtEdge> edges; // vector of edges
|
|
//GB static std::vector<ExtFace> faces; // vector of faces
|
|
|
|
// ---------------------------------------------------- List of faces ---
|
|
class FaceList {
|
|
#ifdef TOOLS_MEM
|
|
TOOLS_SCLASS(tools::hep::FaceList)
|
|
#endif
|
|
private:
|
|
std::vector<ExtFace>& faces; //G.Barrad : end
|
|
private:
|
|
int ihead;
|
|
int ilast;
|
|
|
|
public:
|
|
//G.Barrand : FaceList() : ihead(0), ilast(0) {}
|
|
FaceList(std::vector<ExtFace>& a_faces) : faces(a_faces),ihead(0),ilast(0) {
|
|
#ifdef TOOLS_MEM
|
|
mem::increment(s_class().c_str());
|
|
#endif
|
|
}
|
|
~FaceList() {
|
|
#ifdef TOOLS_MEM
|
|
mem::decrement(s_class().c_str());
|
|
#endif
|
|
}
|
|
protected:
|
|
FaceList(const FaceList& a_from)
|
|
:faces(a_from.faces),ihead(0),ilast(0){
|
|
#ifdef TOOLS_MEM
|
|
mem::increment(s_class().c_str());
|
|
#endif
|
|
}
|
|
|
|
FaceList& operator=(const FaceList&) {return *this;}
|
|
public:
|
|
void clean() { ihead = 0; ilast = 0; }
|
|
int front() { return ihead; }
|
|
|
|
void push_back(int i) {
|
|
if (ilast == 0) { ihead = i; } else { faces[ilast].inext = i; }
|
|
ExtFace& face = faces[i]; //G.Barrand : optimize.
|
|
face.iprev = ilast;
|
|
face.inext = 0;
|
|
ilast = i;
|
|
}
|
|
|
|
void remove(int i) {
|
|
ExtFace& face = faces[i]; //G.Barrand : optimize.
|
|
if (ihead == i) {
|
|
ihead = face.inext;
|
|
}else{
|
|
faces[face.iprev].inext = face.inext;
|
|
}
|
|
if (ilast == i) {
|
|
ilast = face.iprev;
|
|
}else{
|
|
faces[face.inext].iprev = face.iprev;
|
|
}
|
|
face.iprev = 0;
|
|
face.inext = 0;
|
|
}
|
|
};
|
|
|
|
// --------------------- Polyhedron with extended access to
|
|
// its members from the BooleanProcessor class ---
|
|
class ExtPolyhedron : public polyhedron {
|
|
friend class BooleanProcessor;
|
|
virtual polyhedron& operator = (const polyhedron& from) {
|
|
return polyhedron::operator = (from);
|
|
}
|
|
};
|
|
|
|
// ----------------------------------------- Boolean processor class ---
|
|
class BooleanProcessor {
|
|
#ifdef TOOLS_MEM
|
|
TOOLS_SCLASS(tools::hep::BooleanProcessor)
|
|
#endif
|
|
private:
|
|
//static int ishift; //G.Barrand
|
|
std::vector<ExtNode> nodes; // vector of nodes //G.Barrand
|
|
std::vector<ExtEdge> edges; // vector of edges //G.Barrand
|
|
std::vector<ExtFace> faces; // vector of faces //G.Barrand
|
|
private:
|
|
//int processor_error; // is set in case of error
|
|
int operation; // 0 (union), 1 (intersection), 2 (subtraction)
|
|
int ifaces1, ifaces2; // lists of faces
|
|
int iout1, iout2; // lists of faces with status "out"
|
|
int iunk1, iunk2; // lists of faces with status "unknown"
|
|
double rmin[3], rmax[3]; // intersection of bounding boxes
|
|
double del; // precision (tolerance)
|
|
|
|
FaceList result_faces; // list of accepted faces
|
|
FaceList suitable_faces; // list of suitable faces
|
|
FaceList unsuitable_faces; // list of unsuitable faces
|
|
FaceList unknown_faces; // list of unknown faces
|
|
|
|
std::vector<int> external_contours; // heads of external contours
|
|
std::vector<int> internal_contours; // heads of internal contours
|
|
|
|
public:
|
|
private:
|
|
bool takePolyhedron(const polyhedron & p, double, double, double);
|
|
double findMinMax();
|
|
void selectOutsideFaces(int & ifaces, int & iout);
|
|
int testFaceVsPlane(ExtEdge & edge);
|
|
void renumberNodes(int & i1, int & i2, int & i3, int & i4);
|
|
int testEdgeVsEdge(ExtEdge & edge1, ExtEdge & edge2);
|
|
void removeJunkNodes() { while(nodes.back().s != 0) nodes.pop_back(); }
|
|
void divideEdge(int & i1, int & i2);
|
|
void insertEdge(const ExtEdge & edge);
|
|
void caseII(ExtEdge & edge1, ExtEdge & edge2);
|
|
bool caseIE(ExtEdge & edge1, ExtEdge & edge2);
|
|
bool caseEE(ExtEdge & edge1, ExtEdge & edge2);
|
|
bool testFaceVsFace(int iface1, int iface2);
|
|
void invertNewEdges(int iface);
|
|
void checkDoubleEdges(int iface);
|
|
bool assembleFace(int what, int iface);
|
|
bool assembleNewFaces(int what, int ihead);
|
|
bool initiateLists();
|
|
bool assemblePolyhedra();
|
|
void findABC(double x1, double y1, double x2, double y2,
|
|
double &a, double &b, double &c) const;
|
|
int checkDirection(double *x, double *y) const;
|
|
int checkIntersection(int ix, int iy, int i1, int i2) const;
|
|
void mergeContours(int ix, int iy, int kext, int kint);
|
|
bool checkTriangle(int iedge1, int iedge2, int ix, int iy) const;
|
|
bool triangulateContour(int ix, int iy, int ihead);
|
|
bool modifyReference(int iface, int i1, int i2, int iref);
|
|
bool triangulateFace(int iface);
|
|
polyhedron createPolyhedron();
|
|
|
|
public:
|
|
//G.Barrand : BooleanProcessor() {}
|
|
BooleanProcessor() //G.Barrand
|
|
//:processor_error(0) //G.Barrand
|
|
:result_faces(faces)
|
|
,suitable_faces(faces)
|
|
,unsuitable_faces(faces)
|
|
,unknown_faces(faces)
|
|
{
|
|
#ifdef TOOLS_MEM
|
|
mem::increment(s_class().c_str());
|
|
#endif
|
|
}
|
|
|
|
~BooleanProcessor() {
|
|
#ifdef TOOLS_MEM
|
|
mem::decrement(s_class().c_str());
|
|
#endif
|
|
}
|
|
private:
|
|
BooleanProcessor(const BooleanProcessor&)
|
|
//:processor_error(0) //G.Barrand
|
|
:result_faces(faces)
|
|
,suitable_faces(faces)
|
|
,unsuitable_faces(faces)
|
|
,unknown_faces(faces)
|
|
{
|
|
#ifdef TOOLS_MEM
|
|
mem::increment(s_class().c_str());
|
|
#endif
|
|
}
|
|
BooleanProcessor& operator=(const BooleanProcessor&){return *this;}
|
|
public:
|
|
polyhedron execute(int op,
|
|
const polyhedron &a,
|
|
const polyhedron &b,
|
|
int& err);
|
|
|
|
//G.Barrand : begin : drawing disconnected.
|
|
//void draw();
|
|
//void draw_edge(int, int);
|
|
//void draw_contour(int, int, int);
|
|
//void draw_faces(int, int, int);
|
|
//void print_face(int);
|
|
//void print_edge(int);
|
|
//G.Barrand : end
|
|
|
|
//int get_processor_error() const {return processor_error;}
|
|
|
|
void dump(std::ostream&); //G.Barrand
|
|
static int& get_shift(); //G.Barrand
|
|
static void set_shift(int); //G.Barrand
|
|
static void inc_shift(); //G.Barrand
|
|
static int get_num_shift(); //G.Barrand
|
|
|
|
private:
|
|
bool inc_try_count(int,const polyhedron&,const polyhedron&,int&); //GB
|
|
|
|
static HVPoint3D CRAZY_POINT(){return HVPoint3D(-10.e+6, -10.e+6, -10.e+6);}
|
|
#ifdef TOOLS_HEP_BP_OUT_ERR
|
|
static void PROCESSOR_ERROR(int a_what){
|
|
std::cerr << "BooleanProcessor: boolean operation problem (" << a_what
|
|
<< "). Try again with other shifts."
|
|
<< std::endl;
|
|
}
|
|
#else
|
|
static void PROCESSOR_ERROR(int){}
|
|
#endif
|
|
|
|
//G.Barrand :
|
|
#ifdef TOOLS_HEP_BP_CHECK_INDEX
|
|
bool check_face_index(const std::string& a_where,int a_index) {
|
|
if(a_index<0) {
|
|
std::cerr << "BooleanProcessor::check_face_index :"
|
|
<< " " << a_where << " :"
|
|
<< " i<0."
|
|
<< std::endl;
|
|
return false;
|
|
}
|
|
if(a_index>=int(faces.size())) {
|
|
std::cerr << "BooleanProcessor::check_face_index :"
|
|
<< " " << a_where << " :"
|
|
<< " i>=sz."
|
|
<< " i=" << a_index
|
|
<< " sz=" << faces.size()
|
|
<< " cap=" << faces.capacity()
|
|
<< std::endl;
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
bool check_edge_index(const std::string& a_where,int a_index) {
|
|
if(a_index<0) {
|
|
std::cerr << "BooleanProcessor::check_edge_index :"
|
|
<< " " << a_where << " :"
|
|
<< " i<0."
|
|
<< std::endl;
|
|
return false;
|
|
}
|
|
if(a_index>=int(edges.size())) {
|
|
std::cerr << "BooleanProcessor::check_edge_index :"
|
|
<< " " << a_where << " :"
|
|
<< " i>=sz."
|
|
<< " i=" << a_index
|
|
<< " sz=" << edges.size()
|
|
<< " cap=" << edges.capacity()
|
|
<< std::endl;
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
#endif
|
|
|
|
};
|
|
|
|
inline bool ExtFace::invert() //G.Barrand : return bool.
|
|
/***********************************************************************
|
|
* *
|
|
* Name: ExtFace::invert() Date: 28.02.00 *
|
|
* Author: E.Chernyaev Revised: *
|
|
* *
|
|
* Function: Invert face *
|
|
* *
|
|
***********************************************************************/
|
|
{
|
|
int iEprev, iEcur, iEnext;
|
|
|
|
iEprev = 0; iEcur = iold;
|
|
while (iEcur > 0) {
|
|
#ifdef TOOLS_HEP_BP_CHECK_INDEX
|
|
if(!check_edge_index("ExtFace::invert(1)",iEcur)) return false;
|
|
#endif
|
|
ExtEdge& edge = edges[iEcur]; //G.Barrand : optimize.
|
|
edge.invert();
|
|
iEnext = edge.inext;
|
|
edge.inext = iEprev;
|
|
iEprev = iEcur;
|
|
iEcur = iEnext;
|
|
}
|
|
if (iold > 0) iold = iEprev;
|
|
|
|
iEprev = 0; iEcur = inew;
|
|
while (iEcur > 0) {
|
|
#ifdef TOOLS_HEP_BP_CHECK_INDEX
|
|
if(!check_edge_index("ExtFace::invert(2)",iEcur)) return false;
|
|
#endif
|
|
ExtEdge& edge = edges[iEcur]; //G.Barrand : optimize.
|
|
edge.invert();
|
|
iEnext = edge.inext;
|
|
edge.inext = iEprev;
|
|
iEprev = iEcur;
|
|
iEcur = iEnext;
|
|
}
|
|
if (inew > 0) inew = iEprev;
|
|
|
|
//plane = HVPlane3D(-plane.a(), -plane.b(), -plane.c(), -plane.d());
|
|
|
|
HVNormal3D n = plane.normal();
|
|
n *= -1;
|
|
plane.set(n, -plane.distance_from_origin());
|
|
|
|
return true;
|
|
}
|
|
|
|
inline
|
|
bool BooleanProcessor::takePolyhedron(const polyhedron & p,
|
|
double dx, double dy, double dz)
|
|
/***********************************************************************
|
|
* *
|
|
* Name: BooleanProcessor::takePolyhedron Date: 16.12.99 *
|
|
* Author: E.Chernyaev Revised: *
|
|
* *
|
|
* Function: Transfer Polyhedron to internal representation *
|
|
* *
|
|
***********************************************************************/
|
|
{
|
|
int i, k, nnode, iNodes[5], iVis[4], iFaces[4];
|
|
int dnode = int(nodes.size()) - 1;
|
|
int dface = int(faces.size()) - 1;
|
|
|
|
// S E T N O D E S
|
|
|
|
// for (i=1; i <= p.GetNoVertices(); i++) {
|
|
// nodes.push_back(ExtNode(p.GetVertex(i)));
|
|
// }
|
|
|
|
HVPoint3D ppp;
|
|
for (i=1; i <= p.GetNoVertices(); i++) {
|
|
#ifndef TOOLS_HEP_BP_NOT_OPT //G.Barrand
|
|
nodes.push_back(ExtNode());
|
|
ExtNode& node = nodes.back();
|
|
node.v = p.GetVertexFast(i);
|
|
node.v.add(dx,dy,dz);
|
|
#else
|
|
ppp = p.GetVertexFast(i);
|
|
ppp += HVPoint3D(dx,dy,dz);
|
|
nodes.push_back(ExtNode(ppp));
|
|
#endif
|
|
}
|
|
|
|
// S E T F A C E S
|
|
|
|
HVNormal3D plane_n; //G.Barrand
|
|
HVPoint3D plane_p; //G.Barrand
|
|
|
|
for (int iface=1; iface <= p.GetNoFacets(); iface++) {
|
|
faces.push_back(ExtFace(edges,int(edges.size())));
|
|
|
|
// S E T F A C E N O D E S
|
|
|
|
p.GetFacet(iface, nnode, iNodes, iVis, iFaces);
|
|
for (i=0; i<nnode; i++) {
|
|
//if (iNodes[i] < 1 || iNodes[i] > p.GetNoVertices()) processor_error = 1;
|
|
//if (iFaces[i] < 1 || iFaces[i] > p.GetNoFacets()) processor_error = 1;
|
|
|
|
if (iNodes[i] < 1 || iNodes[i] > p.GetNoVertices()) { //G.Barrand
|
|
//G.Barrand : processor_error = 1;
|
|
#ifdef TOOLS_HEP_BP_OUT_ERR
|
|
std::cerr
|
|
<< "BooleanProcessor::takePolyhedron : problem 1."
|
|
<< " nnode " << nnode
|
|
<< " p.GetNoVertices() " << p.GetNoVertices()
|
|
<< " p.GetNoFacets() " << p.GetNoFacets()
|
|
<< " iface " << iface
|
|
<< " i " << i
|
|
<< " iNodes[i] " << iNodes[i]
|
|
<< std::endl;
|
|
#endif
|
|
return false; //G.Barrand
|
|
}
|
|
if (iFaces[i] < 1 || iFaces[i] > p.GetNoFacets()) { //G.Barrand
|
|
//G.Barrand : processor_error = 1;
|
|
#ifdef TOOLS_HEP_BP_OUT_ERR
|
|
std::cerr
|
|
<< "BooleanProcessor::takePolyhedron : problem 2."
|
|
<< " p.GetNoVertices() " << p.GetNoVertices()
|
|
<< " p.GetNoFacets() " << p.GetNoFacets()
|
|
<< " iface " << iface
|
|
<< " i " << i
|
|
<< " iFaces[i] " << iFaces[i]
|
|
<< std::endl;
|
|
#endif
|
|
return false; //G.Barrand
|
|
}
|
|
iNodes[i] += dnode;
|
|
iFaces[i] += dface;
|
|
}
|
|
|
|
// S E T E D G E S
|
|
|
|
iNodes[nnode] = iNodes[0];
|
|
faces.back().iedges[3] = 0;
|
|
for (i=0; i<nnode; i++) {
|
|
faces.back().iedges[i] = int(edges.size());
|
|
edges.push_back(ExtEdge(iNodes[i], iNodes[i+1],
|
|
iface+dface, iFaces[i], iVis[i]));
|
|
edges.back().inext = int(edges.size());
|
|
}
|
|
edges.back().inext = 0;
|
|
|
|
// S E T F A C E M I N - M A X
|
|
|
|
ExtFace& face = faces.back(); //G.Barrand : optimize.
|
|
for (i=0; i<3; i++) {
|
|
face.rmin[i] = nodes[iNodes[0]].v[i];
|
|
face.rmax[i] = nodes[iNodes[0]].v[i];
|
|
}
|
|
for (i=1; i<nnode; i++) {
|
|
ExtNode& node = nodes[iNodes[i]]; //G.Barrand : optimize.
|
|
for (k=0; k<3; k++) {
|
|
if (face.rmin[k] > node.v[k])
|
|
face.rmin[k] = node.v[k];
|
|
if (face.rmax[k] < node.v[k])
|
|
face.rmax[k] = node.v[k];
|
|
}
|
|
}
|
|
|
|
// S E T F A C E P L A N E
|
|
|
|
(nodes[iNodes[2]].v-nodes[iNodes[0]].v).cross(nodes[iNodes[3]].v-nodes[iNodes[1]].v,plane_n);
|
|
|
|
plane_p.set_value(0,0,0);
|
|
for (i=0; i<nnode; i++) { plane_p += nodes[iNodes[i]].v; }
|
|
plane_p *= (1./nnode);
|
|
|
|
//G.Barrand : faces.back().plane = HVPlane3D(n.unit(), p);
|
|
faces.back().plane.set(plane_n,plane_p); //G.Barrand
|
|
|
|
// S E T R E F E R E N C E T O T H E N E X T F A C E
|
|
|
|
faces.back().inext = int(faces.size());
|
|
}
|
|
faces.back().inext = 0;
|
|
|
|
return true; //G.Barrand
|
|
}
|
|
|
|
inline
|
|
double BooleanProcessor::findMinMax()
|
|
/***********************************************************************
|
|
* *
|
|
* Name: BooleanProcessor::findMinMax Date: 16.12.99 *
|
|
* Author: E.Chernyaev Revised: *
|
|
* *
|
|
* Function: Find min-max (bounding) boxes for polyhedra *
|
|
* *
|
|
***********************************************************************/
|
|
{
|
|
if (ifaces1 == 0 || ifaces2 == 0) return 0;
|
|
|
|
int i, iface;
|
|
double rmin1[3], rmax1[3];
|
|
double rmin2[3], rmax2[3];
|
|
|
|
// F I N D B O U N D I N G B O X E S
|
|
|
|
for (i=0; i<3; i++) {
|
|
rmin1[i] = faces[ifaces1].rmin[i];
|
|
rmax1[i] = faces[ifaces1].rmax[i];
|
|
rmin2[i] = faces[ifaces2].rmin[i];
|
|
rmax2[i] = faces[ifaces2].rmax[i];
|
|
}
|
|
|
|
iface = faces[ifaces1].inext;
|
|
while(iface > 0) {
|
|
ExtFace& face = faces[iface]; //G.Barrand
|
|
for (i=0; i<3; i++) {
|
|
if (rmin1[i] > face.rmin[i]) rmin1[i] = face.rmin[i];
|
|
if (rmax1[i] < face.rmax[i]) rmax1[i] = face.rmax[i];
|
|
}
|
|
iface = face.inext;
|
|
}
|
|
|
|
iface = faces[ifaces2].inext;
|
|
while(iface > 0) {
|
|
ExtFace& face = faces[iface]; //G.Barrand
|
|
for (i=0; i<3; i++) {
|
|
if (rmin2[i] > face.rmin[i]) rmin2[i] = face.rmin[i];
|
|
if (rmax2[i] < face.rmax[i]) rmax2[i] = face.rmax[i];
|
|
}
|
|
iface = face.inext;
|
|
}
|
|
|
|
// F I N D I N T E R S E C T I O N O F B O U N D I N G B O X E S
|
|
|
|
for (i=0; i<3; i++) {
|
|
rmin[i] = (rmin1[i] > rmin2[i]) ? rmin1[i] : rmin2[i];
|
|
rmax[i] = (rmax1[i] < rmax2[i]) ? rmax1[i] : rmax2[i];
|
|
}
|
|
|
|
// F I N D T O L E R A N C E
|
|
|
|
double del1 = 0;
|
|
double del2 = 0;
|
|
for (i=0; i<3; i++) {
|
|
if ((rmax1[i]-rmin1[i]) > del1) del1 = rmax1[i]-rmin1[i];
|
|
if ((rmax2[i]-rmin2[i]) > del2) del2 = rmax2[i]-rmin2[i];
|
|
}
|
|
return ((del1 < del2) ? del1 : del2) / GRANULARITY;
|
|
}
|
|
|
|
inline
|
|
void BooleanProcessor::selectOutsideFaces(int & ifaces, int & iout)
|
|
/***********************************************************************
|
|
* *
|
|
* Name: BooleanProcessor::selectOutsideFaces Date: 10.01.00 *
|
|
* Author: E.Chernyaev Revised: *
|
|
* *
|
|
* Function: Preselection of outside faces *
|
|
* *
|
|
***********************************************************************/
|
|
{
|
|
int i, outflag, iface = ifaces, *prev;
|
|
HVPoint3D mmbox[8] = { HVPoint3D(rmin[0],rmin[1],rmin[2]),
|
|
HVPoint3D(rmax[0],rmin[1],rmin[2]),
|
|
HVPoint3D(rmin[0],rmax[1],rmin[2]),
|
|
HVPoint3D(rmax[0],rmax[1],rmin[2]),
|
|
HVPoint3D(rmin[0],rmin[1],rmax[2]),
|
|
HVPoint3D(rmax[0],rmin[1],rmax[2]),
|
|
HVPoint3D(rmin[0],rmax[1],rmax[2]),
|
|
HVPoint3D(rmax[0],rmax[1],rmax[2]) };
|
|
prev = &ifaces;
|
|
while (iface > 0) {
|
|
|
|
// B O U N D I N G B O X vs B O U N D I N G B O X
|
|
|
|
outflag = 0;
|
|
ExtFace& face = faces[iface]; //G.Barrand : optimize.
|
|
for (i=0; i<3; i++) {
|
|
if (face.rmin[i] > rmax[i] + del) { outflag = 1; break; }
|
|
if (face.rmax[i] < rmin[i] - del) { outflag = 1; break; }
|
|
}
|
|
|
|
// B O U N D I N G B O X vs P L A N E
|
|
|
|
if (outflag == 0) {
|
|
int npos = 0, nneg = 0;
|
|
double d;
|
|
for (i=0; i<8; i++) {
|
|
d = face.plane.distance(mmbox[i]); //G.Barrand : optimize
|
|
if (d > +del) npos++;
|
|
if (d < -del) nneg++;
|
|
}
|
|
if (npos == 8 || nneg == 8) outflag = 1;
|
|
}
|
|
|
|
// U P D A T E L I S T S
|
|
|
|
if (outflag == 1) {
|
|
*prev = face.inext;
|
|
face.inext = iout;
|
|
iout = iface;
|
|
}else{
|
|
prev = &face.inext;
|
|
}
|
|
|
|
iface = *prev;
|
|
}
|
|
}
|
|
|
|
inline
|
|
int BooleanProcessor::testFaceVsPlane(ExtEdge & edge)
|
|
/***********************************************************************
|
|
* *
|
|
* Name: BooleanProcessor::testFaceVsPlane Date: 19.01.00 *
|
|
* Author: E.Chernyaev Revised: *
|
|
* *
|
|
* Function: Find result of intersection of face by plane *
|
|
* *
|
|
***********************************************************************/
|
|
{
|
|
int iface = edge.iface1;
|
|
const HVPlane3D& plane = faces[edge.iface2].plane;
|
|
int i, nnode, npos = 0, nneg = 0, nzer = 0;
|
|
double dd[5];
|
|
|
|
// F I N D D I S T A N C E S
|
|
|
|
nnode = (faces[iface].iedges[3] == 0) ? 3 : 4;
|
|
for (i=0; i<nnode; i++) {
|
|
dd[i] = plane.distance(nodes[edges[faces[iface].iedges[i]].i1].v);
|
|
if (dd[i] > del) {
|
|
npos++;
|
|
}else if (dd[i] < -del) {
|
|
nneg++;
|
|
}else{
|
|
nzer++; dd[i] = 0;
|
|
}
|
|
}
|
|
|
|
// S O M E S I M P L E C A S E S ( N O I N T E R S E C T I O N )
|
|
|
|
if (npos == nnode || nneg == nnode) return OUT_OF_PLANE;
|
|
if (nzer == 1 && nneg == 0) return OUT_OF_PLANE;
|
|
if (nzer == 1 && npos == 0) return OUT_OF_PLANE;
|
|
if (nzer == nnode) return ON_PLANE;
|
|
if (nzer == 3) return NON_PLANAR_FACE;
|
|
|
|
// F I N D I N T E R S E C T I O N
|
|
|
|
int ie1 = 0, ie2 = 0, s1 = 0, s2 = 0, status, nint = 0;
|
|
enum { PLUS_MINUS, MINUS_PLUS, ZERO_ZERO, ZERO_PLUS, ZERO_MINUS };
|
|
|
|
dd[nnode] = dd[0];
|
|
for (i=0; i<nnode; i++) {
|
|
if (dd[i] > 0) {
|
|
if (dd[i+1] >= 0) continue;
|
|
status = PLUS_MINUS;
|
|
}else if (dd[i] < 0) {
|
|
if (dd[i+1] <= 0) continue;
|
|
status = MINUS_PLUS;
|
|
}else{
|
|
status = ZERO_ZERO;
|
|
if (dd[i+1] > 0) status = ZERO_PLUS;
|
|
if (dd[i+1] < 0) status = ZERO_MINUS;
|
|
}
|
|
switch (nint) {
|
|
case 0:
|
|
ie1 = i; s1 = status; nint++; break;
|
|
case 1:
|
|
ie2 = i; s2 = status; nint++; break;
|
|
default:
|
|
return NON_PLANAR_FACE;
|
|
}
|
|
}
|
|
if (nint != 2) return NON_PLANAR_FACE;
|
|
|
|
// F O R M I N T E R S E C T I O N S E G M E N T
|
|
|
|
if (s1 != ZERO_ZERO && s2 != ZERO_ZERO) {
|
|
if (s1 == s2) return NON_PLANAR_FACE;
|
|
int iedge, i1 = 0, i2 = 0, ii[2];
|
|
double d1 = 0., d2 = 0., ddd ;
|
|
ii[0] = ie1; ii[1] = ie2;
|
|
for (i=0; i<2; i++) {
|
|
iedge = faces[iface].iedges[ii[i]];
|
|
while (iedge > 0) {
|
|
i1 = edges[iedge].i1;
|
|
i2 = edges[iedge].i2;
|
|
|
|
d1 = plane.distance(nodes[i1].v);
|
|
d2 = plane.distance(nodes[i2].v);
|
|
if (d1 > del) {
|
|
if (d2 < -del) { ii[i] = int(nodes.size()); break; } // +-
|
|
}else if (d1 < -del) {
|
|
if (d2 > del) { ii[i] = int(nodes.size()); break; } // -+
|
|
}else{
|
|
ii[i] = i1; break; // 0+ or 0-
|
|
}
|
|
iedge = edges[iedge].inext;
|
|
}
|
|
if (ii[i] == (int)nodes.size()) {
|
|
ddd = d2-d1; d1 = d1/ddd; d2 = d2/ddd;
|
|
nodes.push_back(ExtNode(d2*nodes[i1].v-d1*nodes[i2].v, iedge));
|
|
}
|
|
}
|
|
edge.inext = 0;
|
|
if (s1 == MINUS_PLUS || s1 == ZERO_PLUS) {
|
|
edge.i1 = ii[1];
|
|
edge.i2 = ii[0];
|
|
}else{
|
|
edge.i1 = ii[0];
|
|
edge.i2 = ii[1];
|
|
}
|
|
return INTERSECTION;
|
|
}else{
|
|
if (npos == nneg) return NON_PLANAR_FACE;
|
|
edge.inext = (s1 == ZERO_ZERO) ? ie1+1 : ie2+1;
|
|
if (s1 == ZERO_PLUS || s2 == ZERO_MINUS) {
|
|
edge.i1 = edges[faces[iface].iedges[ie2]].i1;
|
|
edge.i2 = edges[faces[iface].iedges[ie1]].i1;
|
|
}else{
|
|
edge.i1 = edges[faces[iface].iedges[ie1]].i1;
|
|
edge.i2 = edges[faces[iface].iedges[ie2]].i1;
|
|
}
|
|
return EDGE;
|
|
}
|
|
}
|
|
|
|
inline
|
|
void BooleanProcessor::renumberNodes(int & i1, int & i2, int & i3, int & i4)
|
|
/***********************************************************************
|
|
* *
|
|
* Name: BooleanProcessor::renumberNodes Date: 19.01.00 *
|
|
* Author: E.Chernyaev Revised: *
|
|
* *
|
|
* Function: Renumber nodes and remove last temporary node. *
|
|
* Remark: In principal this routine can be replaced just *
|
|
* with i1 = i2; *
|
|
* Removal of temporary nodes provides additional control *
|
|
* on number of nodes, that is very useful for debugging. *
|
|
* *
|
|
***********************************************************************/
|
|
{
|
|
if (i1 == i2) return;
|
|
if (nodes[i1].s == 0 || nodes.back().s == 0) { i1 = i2; return; }
|
|
|
|
int ilast = int(nodes.size())-1;
|
|
if (i1 == ilast) { i1 = i2; nodes.pop_back(); return; }
|
|
if (i2 == ilast) { i2 = i1; }
|
|
if (i3 == ilast) { i3 = i1; }
|
|
if (i4 == ilast) { i4 = i1; }
|
|
nodes[i1] = nodes.back(); i1 = i2; nodes.pop_back();
|
|
}
|
|
|
|
inline
|
|
int BooleanProcessor::testEdgeVsEdge(ExtEdge & edge1, ExtEdge & edge2)
|
|
/***********************************************************************
|
|
* *
|
|
* Name: BooleanProcessor::testEdgeVsEdge Date: 19.01.00 *
|
|
* Author: E.Chernyaev Revised: *
|
|
* *
|
|
* Function: Find common part of two edges *
|
|
* *
|
|
***********************************************************************/
|
|
{
|
|
int i, ii = 0;
|
|
double d, dd = 0.;
|
|
|
|
for (i=0; i<3; i++) {
|
|
d = nodes[edge1.i1].v[i]-nodes[edge1.i2].v[i];
|
|
if (d < 0.) d = -d;
|
|
if (d > dd) { dd = d; ii = i; }
|
|
}
|
|
double t1 = nodes[edge1.i1].v[ii];
|
|
double t2 = nodes[edge1.i2].v[ii];
|
|
double t3 = nodes[edge2.i1].v[ii];
|
|
double t4 = nodes[edge2.i2].v[ii];
|
|
if (t2-t1 < 0.) { t1 = -t1; t2 = -t2; t3 = -t3; t4 = -t4; }
|
|
|
|
if (t3 <= t1+del || t4 >= t2-del) return 0;
|
|
if (t3 > t2+del) {
|
|
renumberNodes(edge2.i1, edge1.i2, edge1.i1, edge2.i2);
|
|
}else if (t3 < t2-del) {
|
|
renumberNodes(edge1.i2, edge2.i1, edge1.i1, edge2.i2);
|
|
}
|
|
if (t4 < t1-del) {
|
|
renumberNodes(edge2.i2, edge1.i1, edge1.i2, edge2.i1);
|
|
}else if (t4 > t1+del) {
|
|
renumberNodes(edge1.i1, edge2.i2, edge1.i2, edge2.i1);
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
inline
|
|
void BooleanProcessor::divideEdge(int & i1, int & i2)
|
|
/***********************************************************************
|
|
* *
|
|
* Name: BooleanProcessor::divideEdge Date: 24.01.00 *
|
|
* Author: E.Chernyaev Revised: *
|
|
* *
|
|
* Function: Unify the nodes and divide edge on two parts by the node. *
|
|
* *
|
|
***********************************************************************/
|
|
{
|
|
int iedges[2];
|
|
iedges[0] = nodes[i1].s;
|
|
iedges[1] = nodes[i2].s;
|
|
|
|
// U N I F Y N O D E S
|
|
|
|
if (i1 < i2) { i2 = i1; }
|
|
else if (i1 > i2) { i1 = i2; }
|
|
else { iedges[1] = 0; }
|
|
if (iedges[0] == iedges[1]) return;
|
|
|
|
int ie1, ie2, inode = i1;
|
|
nodes[inode].s = 0;
|
|
for (int i=0; i<2; i++) {
|
|
|
|
// F I N D C O R R E S P O N D I N G E D G E
|
|
|
|
if ((ie1 = iedges[i]) == 0) continue;
|
|
ie2 = faces[edges[ie1].iface2].iedges[0];
|
|
while (ie2 > 0) {
|
|
if (edges[ie2].i1 == edges[ie1].i2 &&
|
|
edges[ie2].i2 == edges[ie1].i1) break;
|
|
ie2 = edges[ie2].inext;
|
|
}
|
|
|
|
// D I V I D E E D G E S
|
|
|
|
edges.push_back(edges[ie1]);
|
|
edges[ie1].inext = int(edges.size()) - 1;
|
|
edges[ie1].i2 = inode;
|
|
edges.back().i1 = inode;
|
|
|
|
edges.push_back(edges[ie2]);
|
|
edges[ie2].inext = int(edges.size()) - 1;
|
|
edges[ie2].i2 = inode;
|
|
edges.back().i1 = inode;
|
|
}
|
|
}
|
|
|
|
inline
|
|
void BooleanProcessor::insertEdge(const ExtEdge & edge)
|
|
/***********************************************************************
|
|
* *
|
|
* Name: BooleanProcessor::insertEdge Date: 24.01.00 *
|
|
* Author: E.Chernyaev Revised: *
|
|
* *
|
|
* Function: Insert edge to the list of new edges *
|
|
* *
|
|
***********************************************************************/
|
|
{
|
|
int iface = edge.iface1;
|
|
edges.push_back(edge);
|
|
edges.back().inext = faces[iface].inew;
|
|
faces[iface].inew = int(edges.size()) - 1;
|
|
}
|
|
|
|
inline
|
|
void BooleanProcessor::caseII(ExtEdge & edge1, ExtEdge & edge2)
|
|
/***********************************************************************
|
|
* *
|
|
* Name: BooleanProcessor::caseII Date: 19.01.00 *
|
|
* Author: E.Chernyaev Revised: *
|
|
* *
|
|
* Function: Intersection/Intersection case *
|
|
* *
|
|
***********************************************************************/
|
|
{
|
|
divideEdge(edge1.i1, edge2.i2);
|
|
divideEdge(edge1.i2, edge2.i1);
|
|
edge1.ivis = 1;
|
|
edge2.ivis = 1;
|
|
insertEdge(edge1);
|
|
insertEdge(edge2);
|
|
}
|
|
|
|
inline
|
|
bool BooleanProcessor::caseIE(ExtEdge &, ExtEdge &)
|
|
/***********************************************************************
|
|
* *
|
|
* Name: BooleanProcessor::caseIE Date: 19.01.00 *
|
|
* Author: E.Chernyaev Revised: *
|
|
* *
|
|
* Function: Intersection/Edge-touch case *
|
|
* *
|
|
***********************************************************************/
|
|
{
|
|
//G.Barrand : processor_error = 1;
|
|
#ifdef TOOLS_HEP_BP_OUT_ERR
|
|
std::cerr
|
|
<< "BooleanProcessor::caseIE : unimplemented case"
|
|
<< std::endl;
|
|
#endif
|
|
return false; //G.Barrand
|
|
}
|
|
|
|
inline
|
|
bool BooleanProcessor::caseEE(ExtEdge &, ExtEdge &)
|
|
/***********************************************************************
|
|
* *
|
|
* Name: BooleanProcessor::caseEE Date: 19.01.00 *
|
|
* Author: E.Chernyaev Revised: *
|
|
* *
|
|
* Function: Edge-touch/Edge-touch case *
|
|
* *
|
|
***********************************************************************/
|
|
{
|
|
//G.Barrand : processor_error = 1;
|
|
#ifdef TOOLS_HEP_BP_OUT_ERR
|
|
std::cerr
|
|
<< "BooleanProcessor::caseEE : unimplemented case"
|
|
<< std::endl;
|
|
#endif
|
|
return false;
|
|
}
|
|
|
|
inline
|
|
bool BooleanProcessor::testFaceVsFace(int iface1, int iface2)
|
|
/***********************************************************************
|
|
* *
|
|
* Name: BooleanProcessor::testFaceVsFace Date: 11.01.00 *
|
|
* Author: E.Chernyaev Revised: *
|
|
* *
|
|
* Function: Find result (an edge) of intersection of two faces *
|
|
* *
|
|
***********************************************************************/
|
|
{
|
|
ExtEdge edge1, edge2;
|
|
int irep1, irep2;
|
|
|
|
// M I N - M A X
|
|
|
|
{const ExtFace& face_1 = faces[iface1]; //G.Barrand : optimize
|
|
const ExtFace& face_2 = faces[iface2];
|
|
for (int i=0; i<3; i++) {
|
|
if (face_1.rmin[i] > face_2.rmax[i] + del) return true; //GB : true ?
|
|
if (face_1.rmax[i] < face_2.rmin[i] - del) return true; //GB : true ?
|
|
}}
|
|
|
|
// F A C E - 1 vs P L A N E - 2
|
|
|
|
edge1.iface1 = iface1;
|
|
edge1.iface2 = iface2;
|
|
irep1 = testFaceVsPlane(edge1);
|
|
if (irep1 == OUT_OF_PLANE || irep1 == ON_PLANE) {
|
|
removeJunkNodes();
|
|
return true; //GB : true ?
|
|
}
|
|
|
|
// F A C E - 2 vs P L A N E - 1
|
|
|
|
edge2.iface1 = iface2;
|
|
edge2.iface2 = iface1;
|
|
irep2 = testFaceVsPlane(edge2);
|
|
if (irep2 == OUT_OF_PLANE || irep2 == ON_PLANE) {
|
|
removeJunkNodes();
|
|
return true; //GB : true ?
|
|
}
|
|
|
|
// C H E C K F O R N O N P L A N A R F A C E
|
|
|
|
if (irep1 == NON_PLANAR_FACE || irep2 == NON_PLANAR_FACE) {
|
|
removeJunkNodes();
|
|
return true; //GB : true ?
|
|
}
|
|
|
|
// F I N D I N T E R S E C T I O N P A R T
|
|
|
|
if (testEdgeVsEdge(edge1, edge2) == 0) {
|
|
return true; //GB : true ?
|
|
}
|
|
|
|
// C O N S I D E R D I F F E R E N T C A S E S
|
|
|
|
if (irep1 == INTERSECTION && irep2 == INTERSECTION) caseII(edge1, edge2);
|
|
if (irep1 == INTERSECTION && irep2 == EDGE) {
|
|
if(!caseIE(edge1, edge2)) {
|
|
//G.Barrand : processor_error = 1;
|
|
removeJunkNodes(); //G.Barrand
|
|
return false; //G.Barrand
|
|
}
|
|
}
|
|
if (irep1 == EDGE && irep2 == INTERSECTION) {
|
|
if(!caseIE(edge2, edge1)) {
|
|
//G.Barrand : processor_error = 1;
|
|
removeJunkNodes(); //G.Barrand
|
|
return false; //G.Barrand
|
|
}
|
|
}
|
|
if (irep1 == EDGE && irep2 == EDGE) {
|
|
if(!caseEE(edge1, edge2)) {
|
|
//G.Barrand : processor_error = 1;
|
|
removeJunkNodes(); //G.Barrand
|
|
return false; //G.Barrand
|
|
}
|
|
}
|
|
removeJunkNodes();
|
|
|
|
return true; //G.Barrand
|
|
}
|
|
|
|
inline
|
|
void BooleanProcessor::invertNewEdges(int iface)
|
|
/***********************************************************************
|
|
* *
|
|
* Name: BooleanProcessor::invertNewEdges Date: 04.02.00 *
|
|
* Author: E.Chernyaev Revised: *
|
|
* *
|
|
* Function: Invert direction of new edges *
|
|
* *
|
|
***********************************************************************/
|
|
{
|
|
int iedge = faces[iface].inew;
|
|
while (iedge > 0) {
|
|
edges[iedge].invert();
|
|
iedge = edges[iedge].inext;
|
|
}
|
|
}
|
|
|
|
inline
|
|
void BooleanProcessor::checkDoubleEdges(int)
|
|
/***********************************************************************
|
|
* *
|
|
* Name: BooleanProcessor::checkDoubleEdges Date: 04.02.00 *
|
|
* Author: E.Chernyaev Revised: *
|
|
* *
|
|
* Function: Eliminate duplication of edges *
|
|
* *
|
|
***********************************************************************/
|
|
{
|
|
|
|
}
|
|
|
|
inline
|
|
bool BooleanProcessor::assembleFace(int what, int iface)
|
|
/***********************************************************************
|
|
* *
|
|
* Name: BooleanProcessor::assembleFace Date: 19.02.00 *
|
|
* Author: E.Chernyaev Revised: *
|
|
* *
|
|
* Function: Assemble face *
|
|
* *
|
|
***********************************************************************/
|
|
{
|
|
// A S S E M B L E N E W F A C E
|
|
|
|
int ihead; // head of the list of edges for new face
|
|
int icur; // current edge in the list - last edge inserted to the list
|
|
int *ilink; // pointer to the current link
|
|
int ifirst; // first node of a contour
|
|
int *i; // pointer to the index of the current edge in a loop
|
|
int ioldflag=0; // is set if an edge from iold has been taken
|
|
|
|
ExtFace& face = faces[iface]; //G.Barrand : optimize.
|
|
ilink = &ihead;
|
|
for(;;) {
|
|
if (face.inew == 0) break;
|
|
|
|
// S T A R T N E W C O N T O U R
|
|
|
|
icur = face.inew;
|
|
face.inew = edges[icur].inext;
|
|
|
|
//INSERT_EDGE_TO_THE_LIST(icur); //G.Barrand
|
|
*ilink = icur; ilink = &edges[icur].inext; *ilink = 0; //G.Barrand
|
|
|
|
ifirst = edges[icur].i1;
|
|
|
|
// C O N S T R U C T T H E C O N T O U R
|
|
|
|
for (;;) {
|
|
i = &face.inew;
|
|
ExtEdge& edge_cur = edges[icur];
|
|
while(*i > 0) {
|
|
ExtEdge& edge_i = edges[*i];
|
|
if (edge_i.i1 == edge_cur.i2) break;
|
|
i = &edge_i.inext;
|
|
}
|
|
if (*i == 0) {
|
|
i = &face.iold;
|
|
while(*i > 0) {
|
|
ExtEdge& edge_i = edges[*i];
|
|
if (edge_i.i1 == edge_cur.i2) {
|
|
ioldflag = 1;
|
|
break;
|
|
}
|
|
i = &edge_i.inext;
|
|
}
|
|
}
|
|
if (*i > 0) {
|
|
icur = *i;
|
|
*i = edges[icur].inext;
|
|
|
|
//INSERT_EDGE_TO_THE_LIST(icur);
|
|
*ilink = icur; ilink = &edges[icur].inext; *ilink = 0; //G.Barrand
|
|
|
|
if (edges[icur].i2 == ifirst) { break; } else { continue; }
|
|
}else{
|
|
//G.Barrand : processor_error = 1;
|
|
#ifdef TOOLS_HEP_BP_OUT_ERR
|
|
std::cerr
|
|
<< "BooleanProcessor::assembleFace(" << iface << ") : "
|
|
<< "could not find next edge of the contour"
|
|
<< std::endl;
|
|
#endif
|
|
face.inew = DEFECTIVE_FACE;
|
|
return false; //G.Barrand : false
|
|
}
|
|
}
|
|
}
|
|
|
|
// C H E C K O R I G I N A L C O N T O U R
|
|
|
|
int iedge;
|
|
iedge = face.iold;
|
|
if (what == 0 && ioldflag == 0 && iedge > 0) {
|
|
for (;;) {
|
|
if (edges[iedge].inext > 0) {
|
|
if (edges[iedge].i2 == edges[edges[iedge].inext].i1) {
|
|
iedge = edges[iedge].inext;
|
|
}else{
|
|
break;
|
|
}
|
|
}else{
|
|
if (edges[iedge].i2 == edges[face.iold].i1) {
|
|
edges[iedge].inext = ihead; // set new face
|
|
return true; //G.Barrand : true.
|
|
}else{
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// M A R K U N S U I T A B L E N E I G H B O U R I N G F A C E S
|
|
|
|
int iface2;
|
|
iedge = face.iold;
|
|
while(iedge > 0) {
|
|
iface2 = edges[iedge].iface2;
|
|
if (faces[iface2].inew == 0) faces[iface2].inew = UNSUITABLE_FACE;
|
|
iedge = edges[iedge].inext;
|
|
}
|
|
face.iold = ihead; // set new face
|
|
|
|
return true;
|
|
}
|
|
|
|
inline
|
|
bool BooleanProcessor::assembleNewFaces(int what, int ihead)
|
|
/***********************************************************************
|
|
* *
|
|
* Name: BooleanProcessor::assembleNewFaces Date: 30.01.00 *
|
|
* Author: E.Chernyaev Revised: *
|
|
* *
|
|
* Function: Assemble internal or external parts of faces *
|
|
* *
|
|
***********************************************************************/
|
|
{
|
|
int iface = ihead;
|
|
while(iface > 0) {
|
|
if (faces[iface].inew > 0) {
|
|
if (what != 0) invertNewEdges(iface);
|
|
checkDoubleEdges(iface);
|
|
if(!assembleFace(what, iface)) return false; //G.Barrand : test.
|
|
faces[iface].inew =
|
|
(faces[iface].iold == 0) ? UNSUITABLE_FACE : NEW_FACE;
|
|
}
|
|
iface = faces[iface].inext;
|
|
}
|
|
return true; //G.Barrand
|
|
}
|
|
|
|
inline
|
|
bool BooleanProcessor::initiateLists() //G.Barrand : return bool.
|
|
/***********************************************************************
|
|
* *
|
|
* Name: BooleanProcessor::initiateLists Date: 28.02.00 *
|
|
* Author: E.Chernyaev Revised: *
|
|
* *
|
|
* Function: Initiate lists of faces. *
|
|
* *
|
|
***********************************************************************/
|
|
{
|
|
int i, iface;
|
|
|
|
// R E S E T L I S T S O F F A C E S
|
|
|
|
result_faces.clean();
|
|
suitable_faces.clean();
|
|
unsuitable_faces.clean();
|
|
unknown_faces.clean();
|
|
|
|
// I N I T I A T E T H E L I S T S
|
|
|
|
iface = iout1;
|
|
while (iface > 0) {
|
|
i = iface;
|
|
#ifdef TOOLS_HEP_BP_CHECK_INDEX
|
|
if(!check_face_index("initiateLists(1)",i)) return false;
|
|
#endif
|
|
iface = faces[i].inext;
|
|
if (operation == OP_INTERSECTION) {
|
|
unsuitable_faces.push_back(i);
|
|
faces[i].inew = UNSUITABLE_FACE;
|
|
}else{
|
|
suitable_faces.push_back(i);
|
|
faces[i].inew = ORIGINAL_FACE;
|
|
}
|
|
}
|
|
|
|
iface = iout2;
|
|
while (iface > 0) {
|
|
i = iface;
|
|
#ifdef TOOLS_HEP_BP_CHECK_INDEX
|
|
if(!check_face_index("initiateLists(2)",i)) return false;
|
|
#endif
|
|
iface = faces[i].inext;
|
|
if (operation == OP_UNION) {
|
|
suitable_faces.push_back(i);
|
|
faces[i].inew = ORIGINAL_FACE;
|
|
}else{
|
|
unsuitable_faces.push_back(i);
|
|
faces[i].inew = UNSUITABLE_FACE;
|
|
}
|
|
}
|
|
|
|
iface = iunk1;
|
|
while (iface > 0) {
|
|
i = iface;
|
|
#ifdef TOOLS_HEP_BP_CHECK_INDEX
|
|
if(!check_face_index("initiateLists(3)",i)) return false;
|
|
#endif
|
|
iface = faces[i].inext;
|
|
unknown_faces.push_back(i);
|
|
}
|
|
iface = iunk2;
|
|
while (iface > 0) {
|
|
i = iface;
|
|
#ifdef TOOLS_HEP_BP_CHECK_INDEX
|
|
if(!check_face_index("initiateLists(4)",i)) return false;
|
|
#endif
|
|
iface = faces[i].inext;
|
|
if (operation == OP_SUBTRACTION) {
|
|
if(!faces[i].invert()) return false; //G.Barrand
|
|
}
|
|
unknown_faces.push_back(i);
|
|
}
|
|
|
|
iface = ifaces1;
|
|
while (iface > 0) {
|
|
i = iface;
|
|
#ifdef TOOLS_HEP_BP_CHECK_INDEX
|
|
if(!check_face_index("initiateLists(5)",i)) return false;
|
|
#endif
|
|
iface = faces[i].inext;
|
|
switch(faces[i].inew) {
|
|
case UNKNOWN_FACE:
|
|
unknown_faces.push_back(i);
|
|
break;
|
|
case ORIGINAL_FACE: case NEW_FACE:
|
|
suitable_faces.push_back(i);
|
|
break;
|
|
case UNSUITABLE_FACE:
|
|
unsuitable_faces.push_back(i);
|
|
break;
|
|
default:
|
|
faces[i].iprev = 0;
|
|
faces[i].inext = 0;
|
|
break;
|
|
}
|
|
}
|
|
|
|
iface = ifaces2;
|
|
while (iface > 0) {
|
|
i = iface;
|
|
iface = faces[i].inext;
|
|
#ifdef TOOLS_HEP_BP_CHECK_INDEX
|
|
if(!check_face_index("initiateLists(6)",i)) return false;
|
|
#endif
|
|
|
|
if (operation == OP_SUBTRACTION) {
|
|
if(!faces[i].invert()) return false;
|
|
}
|
|
|
|
switch(faces[i].inew) {
|
|
case UNKNOWN_FACE:
|
|
unknown_faces.push_back(i);
|
|
break;
|
|
case ORIGINAL_FACE: case NEW_FACE:
|
|
suitable_faces.push_back(i);
|
|
break;
|
|
case UNSUITABLE_FACE:
|
|
unsuitable_faces.push_back(i);
|
|
break;
|
|
default:
|
|
faces[i].iprev = 0;
|
|
faces[i].inext = 0;
|
|
break;
|
|
}
|
|
}
|
|
ifaces1 = ifaces2 = iout1 = iout2 = iunk1 = iunk2 = 0;
|
|
return true; //G.Barrand.
|
|
}
|
|
|
|
inline
|
|
bool BooleanProcessor::assemblePolyhedra() //G.Barrand : return bool.
|
|
/***********************************************************************
|
|
* *
|
|
* Name: BooleanProcessor::assemblePolyhedra() Date: 10.12.99 *
|
|
* Author: E.Chernyaev Revised: *
|
|
* *
|
|
* Function: Collect suitable faces and remove unsuitable ones. *
|
|
* *
|
|
***********************************************************************/
|
|
{
|
|
int i, iedge, iface;
|
|
|
|
// L O O P A L O N G S U I T A B L E F A C E S
|
|
|
|
iface = suitable_faces.front();
|
|
while(iface > 0) {
|
|
i = iface;
|
|
#ifdef TOOLS_HEP_BP_CHECK_INDEX
|
|
if(!check_face_index("assemblePolyhedra(1)",i)) return false;
|
|
#endif
|
|
iedge = faces[i].iold;
|
|
while(iedge > 0) {
|
|
#ifdef TOOLS_HEP_BP_CHECK_INDEX
|
|
if(!check_edge_index("assemblePolyhedra(2)",iedge)) return false;
|
|
#endif
|
|
iface = edges[iedge].iface2;
|
|
#ifdef TOOLS_HEP_BP_CHECK_INDEX
|
|
if(!check_face_index("assemblePolyhedra(3)",iface)) return false;
|
|
#endif
|
|
if (faces[iface].inew == UNKNOWN_FACE) {
|
|
unknown_faces.remove(iface);
|
|
suitable_faces.push_back(iface);
|
|
faces[iface].inew = ORIGINAL_FACE;
|
|
}
|
|
iedge = edges[iedge].inext;
|
|
}
|
|
#ifdef TOOLS_HEP_BP_CHECK_INDEX
|
|
if(!check_face_index("assemblePolyhedra(4)",i)) return false;
|
|
#endif
|
|
iface = faces[i].inext;
|
|
suitable_faces.remove(i);
|
|
result_faces.push_back(i);
|
|
}
|
|
if (unknown_faces.front() == 0) return true;
|
|
|
|
// L O O P A L O N G U N S U I T A B L E F A C E S
|
|
|
|
iface = unsuitable_faces.front();
|
|
while(iface > 0) {
|
|
i = iface;
|
|
#ifdef TOOLS_HEP_BP_CHECK_INDEX
|
|
if(!check_face_index("assemblePolyhedra(5)",i)) return false;
|
|
#endif
|
|
iedge = faces[i].iold;
|
|
while(iedge > 0) {
|
|
#ifdef TOOLS_HEP_BP_CHECK_INDEX
|
|
if(!check_edge_index("assemblePolyhedra(6)",iedge)) return false;
|
|
#endif
|
|
iface = edges[iedge].iface2;
|
|
#ifdef TOOLS_HEP_BP_CHECK_INDEX
|
|
if(!check_face_index("assemblePolyhedra(7)",iface)) return false;
|
|
#endif
|
|
if (faces[iface].inew == UNKNOWN_FACE) {
|
|
unknown_faces.remove(iface);
|
|
unsuitable_faces.push_back(iface);
|
|
faces[iface].inew = UNSUITABLE_FACE;
|
|
}
|
|
iedge = edges[iedge].inext;
|
|
}
|
|
#ifdef TOOLS_HEP_BP_CHECK_INDEX
|
|
if(!check_face_index("assemblePolyhedra(8)",i)) return false;
|
|
#endif
|
|
iface = faces[i].inext;
|
|
unsuitable_faces.remove(i);
|
|
}
|
|
|
|
//G.Barrand : begin
|
|
/* From S.Ponce
|
|
At last, there is a problem in the assemblePolyhedra method. At least, I
|
|
think it is there. The problem deals with boolean operations on solids,
|
|
when one of the two contains entirely the other one. It has no sense for
|
|
intersection and union but still has sense for subtraction. In this
|
|
case, faces from the inner solid are stored in the unknown_faces
|
|
FaceList. And an error occurs in the execute method. This may be correct
|
|
for intersection and union but in the case of subtraction, one should do
|
|
that in assemblePolyhedra :
|
|
*/
|
|
// Unknown faces are actually suitable face !!!
|
|
iface = unknown_faces.front();
|
|
while(iface > 0) {
|
|
i = iface;
|
|
#ifdef TOOLS_HEP_BP_CHECK_INDEX
|
|
if(!check_face_index("assemblePolyhedra(9)",i)) return false;
|
|
#endif
|
|
faces[i].inew = ORIGINAL_FACE;
|
|
iface = faces[i].inext;
|
|
unknown_faces.remove(i);
|
|
result_faces.push_back(i);
|
|
}
|
|
/*
|
|
Otherwise, the inner hole that the second solid was building in the
|
|
first one does not exist. I'm not very clear on what to do for unions
|
|
and intersections. I think this kind of situation should be detected and
|
|
one of the solid should simply be ignored.
|
|
*/
|
|
//G.Barrand : end
|
|
|
|
return true;
|
|
}
|
|
|
|
inline void
|
|
BooleanProcessor::findABC(double x1, double y1, double x2, double y2,
|
|
double &a, double &b, double &c) const
|
|
/***********************************************************************
|
|
* *
|
|
* Name: BooleanProcessor::findABC Date: 07.03.00 *
|
|
* Author: E.Chernyaev Revised: *
|
|
* *
|
|
* Function: Find line equation Ax+By+C=0 *
|
|
* *
|
|
***********************************************************************/
|
|
{
|
|
double w;
|
|
a = y1 - y2;
|
|
b = x2 - x1;
|
|
//G.Barrand : w = std::abs(a)+std::abs(b);
|
|
w = ::fabs(a)+::fabs(b); //G.Barrand
|
|
a /= w;
|
|
b /= w;
|
|
c = -(a*x2 + b*y2);
|
|
}
|
|
|
|
inline
|
|
int BooleanProcessor::checkDirection(double *x, double *y) const
|
|
/***********************************************************************
|
|
* *
|
|
* Name: BooleanProcessor::checkDirection Date: 06.03.00 *
|
|
* Author: E.Chernyaev Revised: *
|
|
* *
|
|
* Function: Check direction of line 1-4 *
|
|
* *
|
|
***********************************************************************/
|
|
{
|
|
double a1, b1, c1, a2, b2, c2, d1, d2;
|
|
|
|
// T E S T L I N E 1 - 4 V S E X T E R N A L C O N T O U R
|
|
|
|
findABC(x[0], y[0], x[1], y[1], a1, b1, c1);
|
|
findABC(x[1], y[1], x[2], y[2], a2, b2, c2);
|
|
d1 = a1*x[4] + b1*y[4] + c1;
|
|
d2 = a2*x[4] + b2*y[4] + c2;
|
|
if (d1 <= del && d2 <= del) return 1;
|
|
if (! (d1 > del && d2 > del)) {
|
|
if ( a1*x[2] + b1*y[2] + c1 >= -del) return 1;
|
|
}
|
|
|
|
// T E S T L I N E 1 - 4 V S I N T E R N A L C O N T O U R
|
|
|
|
findABC(x[3], y[3], x[4], y[4], a1, b1, c1);
|
|
findABC(x[4], y[4], x[5], y[5], a2, b2, c2);
|
|
d1 = a1*x[1] + b1*y[1] + c1;
|
|
d2 = a2*x[1] + b2*y[1] + c2;
|
|
if (d1 <= del && d2 <= del) return 1;
|
|
if (!(d1 > del && d2 > del)) {
|
|
if ( a1*x[5] + b1*y[5] + c1 >= -del) return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
inline
|
|
int BooleanProcessor::checkIntersection(int ix, int iy, int i1, int i2) const
|
|
/***********************************************************************
|
|
* *
|
|
* Name: BooleanProcessor::checkDirection Date: 06.03.00 *
|
|
* Author: E.Chernyaev Revised: *
|
|
* *
|
|
* Function: Check line i1-i2 on intersection with contours *
|
|
* *
|
|
***********************************************************************/
|
|
{
|
|
// F I N D L I N E E Q U A T I O N
|
|
|
|
double x1, y1, x2, y2, a1, b1, c1;
|
|
x1 = nodes[i1].v[ix];
|
|
y1 = nodes[i1].v[iy];
|
|
x2 = nodes[i2].v[ix];
|
|
y2 = nodes[i2].v[iy];
|
|
findABC(x1, y1, x2, y2, a1, b1, c1);
|
|
|
|
// L O O P A L O N G E X T E R N A L C O N T O U R S
|
|
|
|
int icontour, iedge, k1, k2;
|
|
double x3, y3, x4, y4, a2, b2, c2, d1, d2;
|
|
for(icontour=0; icontour<(int)external_contours.size(); icontour++) {
|
|
iedge = external_contours[icontour];
|
|
while(iedge > 0) {
|
|
k1 = edges[iedge].i1;
|
|
k2 = edges[iedge].i2;
|
|
iedge = edges[iedge].inext;
|
|
if (k1 == i1 || k2 == i1) continue;
|
|
if (k1 == i2 || k2 == i2) continue;
|
|
x3 = nodes[k1].v[ix];
|
|
y3 = nodes[k1].v[iy];
|
|
x4 = nodes[k2].v[ix];
|
|
y4 = nodes[k2].v[iy];
|
|
d1 = a1*x3 + b1*y3 + c1;
|
|
d2 = a1*x4 + b1*y4 + c1;
|
|
if (d1 > del && d2 > del) continue;
|
|
if (d1 < -del && d2 < -del) continue;
|
|
|
|
findABC(x3, y3, x4, y4, a2, b2, c2);
|
|
d1 = a2*x1 + b2*y1 + c2;
|
|
d2 = a2*x2 + b2*y2 + c2;
|
|
if (d1 > del && d2 > del) continue;
|
|
if (d1 < -del && d2 < -del) continue;
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
// L O O P A L O N G E X T E R N A L C O N T O U R S
|
|
|
|
for(icontour=0; icontour<(int)internal_contours.size(); icontour++) {
|
|
iedge = internal_contours[icontour];
|
|
while(iedge > 0) {
|
|
k1 = edges[iedge].i1;
|
|
k2 = edges[iedge].i2;
|
|
iedge = edges[iedge].inext;
|
|
if (k1 == i1 || k2 == i1) continue;
|
|
if (k1 == i2 || k2 == i2) continue;
|
|
x3 = nodes[k1].v[ix];
|
|
y3 = nodes[k1].v[iy];
|
|
x4 = nodes[k2].v[ix];
|
|
y4 = nodes[k2].v[iy];
|
|
d1 = a1*x3 + b1*y3 + c1;
|
|
d2 = a1*x4 + b1*y4 + c1;
|
|
if (d1 > del && d2 > del) continue;
|
|
if (d1 < -del && d2 < -del) continue;
|
|
|
|
findABC(x3, y3, x4, y4, a2, b2, c2);
|
|
d1 = a2*x1 + b2*y1 + c2;
|
|
d2 = a2*x2 + b2*y2 + c2;
|
|
if (d1 > del && d2 > del) continue;
|
|
if (d1 < -del && d2 < -del) continue;
|
|
return 1;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
inline
|
|
void BooleanProcessor::mergeContours(int ix, int iy, int kext, int kint)
|
|
/***********************************************************************
|
|
* *
|
|
* Name: BooleanProcessor::mergeContours Date: 06.03.00 *
|
|
* Author: E.Chernyaev Revised: *
|
|
* *
|
|
* Function: Attemp to merge internal contour with external one *
|
|
* *
|
|
***********************************************************************/
|
|
{
|
|
int i1ext, i2ext, i1int, i2int, i, k[6];
|
|
double x[6], y[6];
|
|
|
|
// L O O P A L O N G E X T E R N A L C O N T O U R
|
|
|
|
i1ext = external_contours[kext];
|
|
while (i1ext > 0) {
|
|
i2ext = edges[i1ext].inext;
|
|
if (i2ext == 0) i2ext = external_contours[kext];
|
|
k[0] = edges[i1ext].i1;
|
|
k[1] = edges[i1ext].i2;
|
|
k[2] = edges[i2ext].i2;
|
|
for (i=0; i<3; i++) {
|
|
x[i] = nodes[k[i]].v[ix];
|
|
y[i] = nodes[k[i]].v[iy];
|
|
}
|
|
|
|
// L O O P A L O N G I N T E R N A L C O N T O U R
|
|
|
|
i1int = internal_contours[kint];
|
|
while (i1int > 0) {
|
|
i2int = edges[i1int].inext;
|
|
if (i2int == 0) i2int = internal_contours[kint];
|
|
k[3] = edges[i1int].i1;
|
|
k[4] = edges[i1int].i2;
|
|
k[5] = edges[i2int].i2;
|
|
for (i=3; i<6; i++) {
|
|
x[i] = nodes[k[i]].v[ix];
|
|
y[i] = nodes[k[i]].v[iy];
|
|
}
|
|
|
|
// T E S T L I N E K1 - K4
|
|
// I F O K T H E N M E R G E C O N T O U R S
|
|
|
|
if (checkDirection(x, y) == 0) {
|
|
if (checkIntersection(ix, iy, k[1], k[4]) == 0) {
|
|
i = i1int;
|
|
for(;;) {
|
|
if (edges[i].inext == 0) {
|
|
edges[i].inext = internal_contours[kint];
|
|
internal_contours[kint] = 0;
|
|
break;
|
|
}else{
|
|
i = edges[i].inext;
|
|
}
|
|
}
|
|
i = edges[i1int].iface1;
|
|
edges.push_back(ExtEdge(k[1], k[4], i, -1*(int(edges.size())+1), -1));
|
|
edges.back().inext = i2int;
|
|
edges.push_back(ExtEdge(k[4], k[1], i, -1*(int(edges.size())-1), -1));
|
|
edges.back().inext = edges[i1ext].inext;
|
|
edges[i1ext].inext = int(edges.size())-2;
|
|
edges[i1int].inext = int(edges.size())-1;
|
|
return;
|
|
}
|
|
}
|
|
i1int = edges[i1int].inext;
|
|
}
|
|
i1ext = edges[i1ext].inext;
|
|
}
|
|
}
|
|
|
|
inline bool
|
|
BooleanProcessor::checkTriangle(int iedge1, int iedge2, int ix, int iy) const
|
|
/***********************************************************************
|
|
* *
|
|
* Name: BooleanProcessor::checkTriangle Date: 08.03.00 *
|
|
* Author: E.Chernyaev Revised: *
|
|
* *
|
|
* Function: Check triangle for correctness *
|
|
* *
|
|
***********************************************************************/
|
|
{
|
|
int k[3];
|
|
double x[3], y[3];
|
|
double a1, b1, c1;
|
|
|
|
k[0] = edges[iedge1].i1;
|
|
k[1] = edges[iedge1].i2;
|
|
k[2] = edges[iedge2].i2;
|
|
for (int i=0; i<3; i++) {
|
|
x[i] = nodes[k[i]].v[ix];
|
|
y[i] = nodes[k[i]].v[iy];
|
|
}
|
|
|
|
// C H E C K P R I N C I P A L C O R R E C T N E S S
|
|
|
|
findABC(x[2], y[2], x[0], y[0], a1, b1, c1);
|
|
if (a1*x[1]+b1*y[1]+c1 <= 0.1*del) return true;
|
|
|
|
// C H E C K T H A T T H E R E I S N O P O I N T S I N S I D E
|
|
|
|
int inode, iedge;
|
|
double a2, b2, c2, a3, b3, c3;
|
|
|
|
findABC(x[0], y[0], x[1], y[1], a2, b2, c2);
|
|
findABC(x[1], y[1], x[2], y[2], a3, b3, c3);
|
|
iedge = iedge2;
|
|
for (;;) {
|
|
iedge = edges[iedge].inext;
|
|
if (edges[iedge].inext == iedge1) return false;
|
|
inode = edges[iedge].i2;
|
|
if (inode == k[0]) continue;
|
|
if (inode == k[1]) continue;
|
|
if (inode == k[2]) continue;
|
|
x[1] = nodes[inode].v[ix];
|
|
y[1] = nodes[inode].v[iy];
|
|
if (a1*x[1]+b1*y[1]+c1 < -0.1*del) continue;
|
|
if (a2*x[1]+b2*y[1]+c2 < -0.1*del) continue;
|
|
if (a3*x[1]+b3*y[1]+c3 < -0.1*del) continue;
|
|
return true;
|
|
}
|
|
}
|
|
|
|
inline
|
|
bool BooleanProcessor::triangulateContour(int ix, int iy, int ihead)
|
|
/***********************************************************************
|
|
* *
|
|
* Name: BooleanProcessor::triangulateContour Date: 06.03.00 *
|
|
* Author: E.Chernyaev Revised: *
|
|
* *
|
|
* Function: Triangulate external contour *
|
|
* *
|
|
***********************************************************************/
|
|
{
|
|
|
|
//int draw_flag = 0;
|
|
//if (draw_flag) draw_contour(5, 3, ihead);
|
|
|
|
// C L O S E C O N T O U R
|
|
|
|
int ipnext = ihead, nnode = 1;
|
|
for (;;) {
|
|
if (edges[ipnext].inext > 0) {
|
|
ipnext = edges[ipnext].inext;
|
|
nnode++;
|
|
}else{
|
|
edges[ipnext].inext = ihead;
|
|
break;
|
|
}
|
|
}
|
|
|
|
// L O O P A L O N G C O N T O U R
|
|
|
|
//std::cerr << "debug : contour : begin : =================" << std::endl;
|
|
//dump();//debug
|
|
|
|
int iedge1, iedge2, iedge3, istart = 0;
|
|
for (;;) {
|
|
iedge1 = edges[ipnext].inext;
|
|
iedge2 = edges[iedge1].inext;
|
|
|
|
//std::cerr << "debug :"
|
|
// << " ipnext " << ipnext
|
|
// << " iedge1 " << iedge1
|
|
// << " iedge2 " << iedge2
|
|
// << " : istart " << istart
|
|
// << " , nnode " << nnode
|
|
// << std::endl;
|
|
|
|
if (istart == 0) {
|
|
istart = iedge1;
|
|
if (nnode <= 3) {
|
|
iedge3 = edges[iedge2].inext;
|
|
edges[iedge1].iface1 = int(faces.size());
|
|
edges[iedge2].iface1 = int(faces.size());
|
|
edges[iedge3].iface1 = int(faces.size());
|
|
edges[iedge3].inext = 0;
|
|
faces.push_back(ExtFace(edges,0)); //G.Barrand : ok ?
|
|
faces.back().iold = iedge1;
|
|
faces.back().inew = ORIGINAL_FACE;
|
|
|
|
//if (draw_flag) draw_contour(4, 2, iedge1);
|
|
|
|
break;
|
|
}
|
|
}else if (istart == iedge1) {
|
|
//G.Barrand processor_error = 1; //use returned status.
|
|
#ifdef TOOLS_HEP_BP_OUT_ERR
|
|
std::cerr
|
|
<< "BooleanProcessor::triangulateContour : "
|
|
<< "could not generate a triangle (infinite loop)"
|
|
<< std::endl;
|
|
#endif
|
|
return false; //G.Barrand
|
|
}
|
|
|
|
// C H E C K C O R E C T N E S S O F T H E T R I A N G L E
|
|
|
|
if(checkTriangle(iedge1,iedge2,ix,iy)) {
|
|
ipnext = edges[ipnext].inext;
|
|
continue;
|
|
}
|
|
|
|
// M O D I F Y C O N T O U R
|
|
|
|
int i1 = edges[iedge1].i1;
|
|
int i3 = edges[iedge2].i2;
|
|
int iface1 = edges[iedge1].iface1;
|
|
int iface2 = int(faces.size());
|
|
|
|
edges[ipnext].inext = int(edges.size());
|
|
edges.push_back(ExtEdge(i1, i3, iface1, -1*(int(edges.size())+1), -1));
|
|
edges.back().inext = edges[iedge2].inext;
|
|
|
|
// A D D N E W T R I A N G L E T O T H E L I S T
|
|
|
|
edges[iedge2].inext = int(edges.size());
|
|
edges.push_back(ExtEdge(i3, i1, iface2, -1*(int(edges.size())-1), -1));
|
|
faces.push_back(ExtFace(edges,0)); //G.Barrand : ok ?
|
|
faces.back().iold = iedge1;
|
|
faces.back().inew = ORIGINAL_FACE;
|
|
edges[iedge1].iface1 = iface2;
|
|
edges[iedge2].iface1 = iface2;
|
|
ipnext = edges[ipnext].inext;
|
|
istart = 0;
|
|
nnode--;
|
|
|
|
//if (draw_flag) draw_contour(4, 2, iedge1);
|
|
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
inline
|
|
bool BooleanProcessor::modifyReference(int iface, int i1, int i2, int iref)
|
|
/***********************************************************************
|
|
* *
|
|
* Name: BooleanProcessor::modifyReference Date: 13.03.00 *
|
|
* Author: E.Chernyaev Revised: *
|
|
* *
|
|
* Function: Modify reference to the neighbouring face *
|
|
* *
|
|
***********************************************************************/
|
|
{
|
|
int iedge = faces[iface].iold;
|
|
while (iedge > 0) {
|
|
if (edges[iedge].i1 == i2 && edges[iedge].i2 == i1) {
|
|
edges[iedge].iface2 = iref;
|
|
return true;
|
|
}
|
|
iedge = edges[iedge].inext;
|
|
}
|
|
//G.Barrand : processor_error = 1;
|
|
#ifdef TOOLS_HEP_BP_OUT_ERR
|
|
std::cerr
|
|
<< "BooleanProcessor::modifyReference : could not find the edge, "
|
|
<< "iface=" << iface << ", i1,i2=" << i1 << "," << i2 << ", iref=" << iref
|
|
<< std::endl;
|
|
#endif
|
|
return false; //G.Barrand
|
|
}
|
|
|
|
inline
|
|
bool BooleanProcessor::triangulateFace(int iface)
|
|
/***********************************************************************
|
|
* *
|
|
* Name: BooleanProcessor::triangulateFace Date: 02.03.00 *
|
|
* Author: E.Chernyaev Revised: *
|
|
* *
|
|
* Function: Triangulation of an extended face *
|
|
* *
|
|
***********************************************************************/
|
|
{
|
|
|
|
// F I N D M A X C O M P O N E N T O F T H E N O R M A L
|
|
// S E T IX, IY, IZ
|
|
|
|
//HVNormal3D normal = faces[iface].plane.normal();
|
|
const HVNormal3D& normal = faces[iface].plane.normal();
|
|
|
|
int ix, iy, iz = 0;
|
|
//G.Barrand : if (std::abs(normal[1]) > std::abs(normal[iz])) iz = 1;
|
|
//G.Barrand : if (std::abs(normal[2]) > std::abs(normal[iz])) iz = 2;
|
|
if (::fabs(normal[1]) > ::fabs(normal[iz])) iz = 1; //G.Barrand
|
|
if (::fabs(normal[2]) > ::fabs(normal[iz])) iz = 2; //G.Barrand
|
|
if (normal[iz] > 0) {
|
|
ix = (iz+1)%3; iy = (ix+1)%3;
|
|
}else{
|
|
iy = (iz+1)%3; ix = (iy+1)%3;
|
|
}
|
|
|
|
// F I L L L I S T S O F C O N T O U R S
|
|
|
|
external_contours.clear();
|
|
internal_contours.clear();
|
|
double z;
|
|
int i1, i2, ifirst, iedge, icontour = faces[iface].iold;
|
|
while (icontour > 0) {
|
|
iedge = icontour;
|
|
ifirst = edges[iedge].i1;
|
|
z = 0.0;
|
|
for(;;) {
|
|
if (iedge > 0) {
|
|
i1 = edges[iedge].i1;
|
|
i2 = edges[iedge].i2;
|
|
ExtNode& node_1 = nodes[i1];
|
|
ExtNode& node_2 = nodes[i2];
|
|
z += node_1.v[ix]*node_2.v[iy]-node_2.v[ix]*node_1.v[iy];
|
|
if (ifirst != i2) {
|
|
iedge = edges[iedge].inext;
|
|
continue;
|
|
}else{
|
|
if (z > del*del) {
|
|
external_contours.push_back(icontour);
|
|
}else if (z < -del*del) {
|
|
internal_contours.push_back(icontour);
|
|
}else{
|
|
//G.Barrand : processor_error = 1; //use returned value.
|
|
#ifdef TOOLS_HEP_BP_OUT_ERR
|
|
std::cerr
|
|
<< "BooleanProcessor::triangulateFace : too small contour"
|
|
<< " z " << z
|
|
<< " del*del " << del*del
|
|
<< std::endl;
|
|
#endif
|
|
return false; //G.Barrand.
|
|
}
|
|
icontour = edges[iedge].inext;
|
|
edges[iedge].inext = 0;
|
|
break;
|
|
}
|
|
}else{
|
|
//G.Barrand : processor_error = 1; //use returned value.
|
|
#ifdef TOOLS_HEP_BP_OUT_ERR
|
|
std::cerr
|
|
<< "BooleanProcessor::triangulateFace : broken contour"
|
|
<< std::endl;
|
|
#endif
|
|
icontour = 0;
|
|
//G.Barrand : break;
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
|
|
// G E T R I D O F I N T E R N A L C O N T O U R S
|
|
|
|
int kint, kext;
|
|
for (kint=0; kint < (int)internal_contours.size(); kint++) {
|
|
for (kext=0; kext < (int)external_contours.size(); kext++) {
|
|
mergeContours(ix, iy, kext, kint);
|
|
if (internal_contours[kint] == 0) break;
|
|
}
|
|
if (kext == (int)external_contours.size()) {
|
|
//G.Barrand : processor_error = 1; //use returned value.
|
|
#ifdef TOOLS_HEP_BP_OUT_ERR
|
|
std::cerr
|
|
<< "BooleanProcessor::triangulateFace : "
|
|
<< "could not merge internal contour " << kint
|
|
<< std::endl;
|
|
#endif
|
|
return false; //G.Barrand
|
|
}
|
|
}
|
|
|
|
// T R I A N G U L A T E C O N T O U R S
|
|
|
|
int nface = int(faces.size());
|
|
for (kext=0; kext < (int)external_contours.size(); kext++) {
|
|
if(!triangulateContour(ix, iy, external_contours[kext])) {
|
|
//G.Barrand : processor_error = 1; //use returned value.
|
|
#ifdef TOOLS_HEP_BP_OUT_ERR
|
|
std::cerr
|
|
<< "BooleanProcessor::triangulateFace : "
|
|
<< "triangulateContour failed."
|
|
<< std::endl;
|
|
#endif
|
|
//break; //G.Barrand : ok ?
|
|
//return; //G.Barrand : ok ?
|
|
return false; //G.Barrand
|
|
}
|
|
}
|
|
faces[iface].inew = UNSUITABLE_FACE;
|
|
|
|
// M O D I F Y R E F E R E N C E S
|
|
|
|
for (int ifa=nface; ifa<(int)faces.size(); ifa++) {
|
|
iedge = faces[ifa].iold;
|
|
while (iedge > 0) {
|
|
if (edges[iedge].iface1 != ifa) {
|
|
//G.Barrand : processor_error = 1; //use returned value.
|
|
#ifdef TOOLS_HEP_BP_OUT_ERR
|
|
std::cerr
|
|
<< "BooleanProcessor::triangulateFace : wrong reference to itself, "
|
|
<< "iface=" << ifa << ", iface1=" << edges[iedge].iface1
|
|
<< std::endl;
|
|
#endif
|
|
return false; //G.Barrand
|
|
}else if (edges[iedge].iface2 > 0) {
|
|
if(!modifyReference(edges[iedge].iface2,
|
|
edges[iedge].i1, edges[iedge].i2, ifa)) { //G.Barrand
|
|
return false; //G.Barrand
|
|
}
|
|
}else if (edges[iedge].iface2 < 0) {
|
|
edges[iedge].iface2 = edges[-edges[iedge].iface2].iface1;
|
|
}
|
|
iedge = edges[iedge].inext;
|
|
}
|
|
}
|
|
|
|
return true; //G.Barrand.
|
|
}
|
|
|
|
inline
|
|
polyhedron BooleanProcessor::createPolyhedron()
|
|
/***********************************************************************
|
|
* *
|
|
* Name: BooleanProcessor::createPolyhedron() Date: 14.03.00 *
|
|
* Author: E.Chernyaev Revised: *
|
|
* *
|
|
* Function: Create polyhedron. *
|
|
* *
|
|
***********************************************************************/
|
|
{
|
|
int i, iedge, nnode = 0, nface = 0;
|
|
|
|
// R E N U M E R A T E N O D E S A N D F A C E S
|
|
|
|
for (i=1; i<(int)nodes.size(); i++) nodes[i].s = 0;
|
|
|
|
for (i=1; i<(int)faces.size(); i++) {
|
|
if (faces[i].inew == ORIGINAL_FACE) {
|
|
faces[i].inew = ++nface;
|
|
iedge = faces[i].iold;
|
|
while (iedge > 0) {
|
|
nodes[edges[iedge].i1].s = 1;
|
|
iedge = edges[iedge].inext;
|
|
}
|
|
}else{
|
|
faces[i].inew = 0;
|
|
}
|
|
}
|
|
|
|
for (i=1; i<(int)nodes.size(); i++) {
|
|
if (nodes[i].s == 1) nodes[i].s = ++nnode;
|
|
}
|
|
|
|
// A L L O C A T E M E M O R Y
|
|
|
|
ExtPolyhedron polyhedron;
|
|
if (nface == 0) return polyhedron;
|
|
polyhedron.AllocateMemory(nnode, nface);
|
|
|
|
// S E T N O D E S
|
|
|
|
for (i=1; i<(int)nodes.size(); i++) {
|
|
if (nodes[i].s != 0) polyhedron.pV[nodes[i].s] = nodes[i].v;
|
|
}
|
|
|
|
// S E T F A C E S
|
|
|
|
int k, v[4], f[4];
|
|
for (i=1; i<(int)faces.size(); i++) {
|
|
if (faces[i].inew == 0) continue;
|
|
v[3] = f[3] = k = 0;
|
|
iedge = faces[i].iold;
|
|
while (iedge > 0) {
|
|
if (k > 3) {
|
|
#ifdef TOOLS_HEP_BP_VERBOSE
|
|
std::cerr
|
|
<< "BooleanProcessor::createPolyhedron : too many edges"
|
|
<< std::endl;
|
|
#endif
|
|
break;
|
|
}
|
|
v[k] = nodes[edges[iedge].i1].s;
|
|
if (edges[iedge].ivis < 0) v[k] = -v[k];
|
|
f[k] = faces[edges[iedge].iface2].inew;
|
|
iedge = edges[iedge].inext;
|
|
k++;
|
|
}
|
|
if (k < 3) {
|
|
#ifdef TOOLS_HEP_BP_VERBOSE
|
|
std::cerr
|
|
<< "BooleanProcessor::createPolyhedron : "
|
|
<< "face has only " << k << " edges"
|
|
<< std::endl;
|
|
#endif
|
|
}
|
|
//polyhedron.pF[faces[i].inew] =
|
|
// SbFacet(v[0],f[0], v[1],f[1], v[2],f[2], v[3],f[3]);
|
|
polyhedron.pF[faces[i].inew].set( //G.Barrand
|
|
v[0],f[0], v[1],f[1], v[2],f[2], v[3],f[3]);
|
|
}
|
|
return polyhedron;
|
|
}
|
|
|
|
//G.Barrand : begin
|
|
//int BooleanProcessor::ishift = 0; //does not work with pure header code.
|
|
inline int& BooleanProcessor::get_shift() { //& not thread safe.
|
|
static int s_ishift;
|
|
return s_ishift;
|
|
}
|
|
|
|
inline void BooleanProcessor::set_shift(int a_shift) {
|
|
get_shift() = a_shift;
|
|
}
|
|
inline void BooleanProcessor::inc_shift() {
|
|
int i = get_shift();
|
|
i++;
|
|
if(i>=get_num_shift()) i = 0;
|
|
get_shift() = i;
|
|
}
|
|
|
|
inline int BooleanProcessor::get_num_shift() { return 8;}
|
|
//G.Barrand : end
|
|
|
|
//G.Barrand :
|
|
inline
|
|
bool BooleanProcessor::inc_try_count(
|
|
#ifdef TOOLS_HEP_BP_VERBOSE
|
|
int a_op,const polyhedron& a,const polyhedron& b
|
|
#else
|
|
int,const polyhedron&,const polyhedron&
|
|
#endif
|
|
,int& a_try_count){
|
|
if(a_try_count>get_num_shift()) {
|
|
#ifdef TOOLS_HEP_BP_VERBOSE
|
|
std::cerr << "BooleanProcessor: "
|
|
<< " all shifts tried. Boolean operation (" << a_op << ") failure."
|
|
<< " a name \"" << a.getName() << "\""
|
|
<< " b name \"" << b.getName() << "\""
|
|
<< std::endl;
|
|
#endif
|
|
return false; //stop
|
|
}
|
|
|
|
#ifdef TOOLS_HEP_BP_VERBOSE
|
|
std::cerr
|
|
<< "BooleanProcessor::execute : try another tilt..."
|
|
<< std::endl;
|
|
#endif
|
|
|
|
a_try_count++;
|
|
return true;
|
|
}
|
|
|
|
inline
|
|
polyhedron BooleanProcessor::execute(int op,
|
|
const polyhedron & a,
|
|
const polyhedron & b,
|
|
int& a_err) //G.Barrand
|
|
/***********************************************************************
|
|
* *
|
|
* Name: BooleanProcessor::execute Date: 10.12.99 *
|
|
* Author: E.Chernyaev Revised: *
|
|
* *
|
|
* Function: Execute boolean operation. *
|
|
* *
|
|
***********************************************************************/
|
|
{
|
|
//static int ishift = 0; //G.Barrand
|
|
//static double shift[8][3] = {
|
|
static double shift[/*NUM_SHIFT*/ 8][3] = { //G.Barrand
|
|
{ 31, 23, 17},
|
|
{ -31, -23, -17},
|
|
{ -23, 17, 31},
|
|
{ 23, -17, -31},
|
|
{ -17, -31, 23},
|
|
{ 17, 31, -23},
|
|
{ 31, -23, 17},
|
|
{ -31, 23, -17}
|
|
};
|
|
|
|
|
|
//std::cerr << "BooleanProcessor::execute : ++++++++++++++++++++++"
|
|
// << a.getName()
|
|
// << b.getName()
|
|
// << std::endl;
|
|
|
|
// I N I T I A T E P R O C E S S O R
|
|
|
|
operation = op;
|
|
nodes.clear(); nodes.push_back(CRAZY_POINT());
|
|
edges.clear(); edges.push_back(ExtEdge());
|
|
faces.clear(); faces.push_back(ExtFace(edges,0)); //G.Barrand : ok ?
|
|
|
|
// T A K E P O L Y H E D R A
|
|
|
|
ifaces1 = int(faces.size());
|
|
if(!takePolyhedron(a,0,0,0)){ //G.Barrand : use returned value.
|
|
// corrapted polyhedron
|
|
#ifdef TOOLS_HEP_BP_OUT_ERR
|
|
std::cerr
|
|
<< "BooleanProcessor: a corrapted input polyhedron"
|
|
<< std::endl;
|
|
#endif
|
|
a_err = 1; //G.Barrand
|
|
return polyhedron();
|
|
}
|
|
|
|
ifaces2 = int(faces.size());
|
|
if(!takePolyhedron(b,0,0,0)){
|
|
// corrapted polyhedron
|
|
#ifdef TOOLS_HEP_BP_OUT_ERR
|
|
std::cerr
|
|
<< "BooleanProcessor: b corrapted input polyhedron"
|
|
<< std::endl;
|
|
#endif
|
|
a_err = 1; //G.Barrand
|
|
return polyhedron();
|
|
}
|
|
|
|
if (ifaces1 == ifaces2) { // a is empty
|
|
a_err = 0; //G.Barrand
|
|
switch (operation) {
|
|
case OP_UNION:
|
|
return b;
|
|
case OP_INTERSECTION:
|
|
#ifdef TOOLS_HEP_BP_VERBOSE
|
|
std::cerr
|
|
<< "BooleanProcessor: intersection with empty polyhedron"
|
|
<< std::endl;
|
|
#endif
|
|
return polyhedron();
|
|
case OP_SUBTRACTION:
|
|
#ifdef TOOLS_HEP_BP_VERBOSE
|
|
std::cerr
|
|
<< "BooleanProcessor: subtraction from empty polyhedron"
|
|
<< std::endl;
|
|
#endif
|
|
return polyhedron();
|
|
}
|
|
}
|
|
if (ifaces2 == (int)faces.size()) { // b is empty
|
|
a_err = 0; //G.Barrand
|
|
switch (operation) {
|
|
case OP_UNION:
|
|
return a;
|
|
case OP_INTERSECTION:
|
|
#ifdef TOOLS_HEP_BP_VERBOSE
|
|
std::cerr
|
|
<< "BooleanProcessor: intersection with empty polyhedron"
|
|
<< std::endl;
|
|
#endif
|
|
return polyhedron();
|
|
case OP_SUBTRACTION:
|
|
return a;
|
|
}
|
|
}
|
|
|
|
// S E T I N I T I A L M I N - M A X A N D T O L E R A N C E
|
|
|
|
del = findMinMax();
|
|
|
|
// W O R K A R O U N D T O A V O I D I E A N D E E
|
|
|
|
int try_count = 1;
|
|
while(true) { //G.Barrand
|
|
|
|
double ddxx = del*shift[get_shift()][0];
|
|
double ddyy = del*shift[get_shift()][1];
|
|
double ddzz = del*shift[get_shift()][2];
|
|
//ishift++; if (ishift == get_num_shift()) ishift = 0;
|
|
inc_shift();
|
|
|
|
operation = op;
|
|
nodes.clear(); nodes.push_back(CRAZY_POINT());
|
|
edges.clear(); edges.push_back(ExtEdge());
|
|
faces.clear(); faces.push_back(ExtFace(edges,0)); //G.Barrand : ok ?
|
|
|
|
ifaces1 = int(faces.size());
|
|
if(!takePolyhedron(a,0,0,0)) {
|
|
#ifdef TOOLS_HEP_BP_OUT_ERR
|
|
std::cerr
|
|
<< "BooleanProcessor: shifted a corrapted input polyhedron"
|
|
<< std::endl;
|
|
#endif
|
|
if(!inc_try_count(op,a,b,try_count)) {a_err = 1;return a;}
|
|
continue; //try another shift.
|
|
}
|
|
|
|
ifaces2 = int(faces.size());
|
|
if(!takePolyhedron(b,ddxx,ddyy,ddzz)){
|
|
#ifdef TOOLS_HEP_BP_OUT_ERR
|
|
std::cerr
|
|
<< "BooleanProcessor: shifted b corrapted input polyhedron"
|
|
<< std::endl;
|
|
#endif
|
|
if(!inc_try_count(op,a,b,try_count)) {a_err = 1;return a;}
|
|
continue; //try another shift.
|
|
}
|
|
|
|
del = findMinMax();
|
|
|
|
// P R E S E L E C T O U T S I D E F A C E S
|
|
|
|
iout1 = iout2 = 0;
|
|
selectOutsideFaces(ifaces1, iout1);
|
|
selectOutsideFaces(ifaces2, iout2);
|
|
|
|
// P R E S E L E C T N O I N T E R S E C T I O N F A C E S
|
|
|
|
int ifa1, ifa2;
|
|
iunk1 = iunk2 = 0;
|
|
if (iout1 != 0 || iout2 != 0) {
|
|
for(;;) {
|
|
ifa1 = iunk1;
|
|
ifa2 = iunk2;
|
|
selectOutsideFaces(ifaces1, iunk1);
|
|
selectOutsideFaces(ifaces2, iunk2);
|
|
if (iunk1 == ifa1 && iunk2 == ifa2) break;
|
|
findMinMax();
|
|
}
|
|
}
|
|
|
|
// F I N D N E W E D G E S
|
|
|
|
{int processor_error = 0; //G.Barrand
|
|
if (ifaces1 != 0 && ifaces2 != 0 ) {
|
|
ifa1 = ifaces1;
|
|
while (ifa1 > 0) {
|
|
ifa2 = ifaces2;
|
|
while (ifa2 > 0) {
|
|
if(!testFaceVsFace(ifa1, ifa2)) {
|
|
processor_error = 1; //G.Barrand
|
|
break; //G.Barrand
|
|
}
|
|
ifa2 = faces[ifa2].inext;
|
|
}
|
|
if(processor_error) break; //G.Barrand
|
|
ifa1 = faces[ifa1].inext;
|
|
}
|
|
}
|
|
if (processor_error) {
|
|
PROCESSOR_ERROR(4);
|
|
if(!inc_try_count(op,a,b,try_count)) {a_err = 1;return a;}
|
|
continue; //try another shift.
|
|
}} //G.Barrand
|
|
|
|
// C O N S T R U C T N E W F A C E S
|
|
|
|
if(!assembleNewFaces((operation == OP_INTERSECTION) ? 1 : 0, ifaces1)){
|
|
//G.Barrand
|
|
PROCESSOR_ERROR(5);
|
|
if(!inc_try_count(op,a,b,try_count)) {a_err = 1;return a;}
|
|
continue; //try another shift.
|
|
}
|
|
if(!assembleNewFaces((operation == OP_UNION) ? 0 : 1, ifaces2)){
|
|
//G.Barrand
|
|
PROCESSOR_ERROR(6);
|
|
if(!inc_try_count(op,a,b,try_count)) {a_err = 1;return a;}
|
|
continue; //try another shift.
|
|
}
|
|
// A S S E M B L E S U I T A B L E F A C E S
|
|
|
|
if(!initiateLists()) { //G.Barrand : return status.
|
|
#ifdef TOOLS_HEP_BP_OUT_ERR
|
|
std::cerr
|
|
<< "BooleanProcessor: initiateLists failed."
|
|
<< std::endl;
|
|
#endif
|
|
if(!inc_try_count(op,a,b,try_count)) {a_err = 1;return a;}
|
|
continue; //try another shift.
|
|
}
|
|
|
|
{int processor_error = 0;
|
|
for (;;) {
|
|
if(!assemblePolyhedra()) { //G.Barrand : handle returned value.
|
|
processor_error = 1;
|
|
#ifdef TOOLS_HEP_BP_OUT_ERR
|
|
std::cerr
|
|
<< "BooleanProcessor: assemblePolyhedra failed."
|
|
<< std::endl;
|
|
#endif
|
|
break;
|
|
}
|
|
if (unknown_faces.front() != 0) {
|
|
processor_error = 1;
|
|
#ifdef TOOLS_HEP_BP_OUT_ERR
|
|
std::cerr
|
|
<< "BooleanProcessor::execute : unknown faces !!!"
|
|
<< std::endl;
|
|
#endif
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
if (processor_error) {
|
|
PROCESSOR_ERROR(7);
|
|
if(!inc_try_count(op,a,b,try_count)) {a_err = 1;return a;}
|
|
continue; //try another shift.
|
|
}}
|
|
|
|
// T R I A N G U L A T E A C C E P T E D F A C E S
|
|
|
|
{int processor_error = 0;
|
|
ifa1 = result_faces.front();
|
|
while (ifa1 > 0) {
|
|
ifa2 = ifa1;
|
|
ifa1 = faces[ifa2].inext;
|
|
if(faces[ifa2].inew == NEW_FACE) {
|
|
if(!triangulateFace(ifa2)) { //G.Barrand : use returned status.
|
|
processor_error = 1;
|
|
break; //G.Barrand
|
|
}
|
|
}
|
|
}
|
|
if (processor_error) {
|
|
PROCESSOR_ERROR(8);
|
|
if(!inc_try_count(op,a,b,try_count)) {a_err = 1;return a;}
|
|
continue; //try another shift.
|
|
}}
|
|
|
|
#ifdef TOOLS_HEP_BP_VERBOSE
|
|
if(try_count!=1) {
|
|
std::cerr
|
|
<< "BooleanProcessor::execute : had converged."
|
|
<< std::endl;
|
|
}
|
|
#endif
|
|
break;
|
|
|
|
} //G.Barrand : end while shift.
|
|
|
|
// C R E A T E P O L Y H E D R O N
|
|
|
|
a_err = 0;
|
|
return createPolyhedron();
|
|
}
|
|
|
|
|
|
//#include <cfortran.h>
|
|
//#include <higz.h>
|
|
//#include "zbuf.h"
|
|
//void BooleanProcessor::draw()
|
|
/***********************************************************************
|
|
* *
|
|
* Name: BooleanProcessor::draw Date: 10.12.99 *
|
|
* Author: E.Chernyaev Revised: *
|
|
* *
|
|
* Function: Draw *
|
|
* *
|
|
***********************************************************************/
|
|
/*
|
|
{
|
|
int II;
|
|
int icol, i1, i2, iedge, iface, ilist[4];
|
|
float p1[3], p2[3];
|
|
|
|
ilist[0] = ifaces1;
|
|
ilist[1] = ifaces2;
|
|
ilist[2] = iout1;
|
|
ilist[3] = iout2;
|
|
|
|
for (int i=0; i<4; i++) {
|
|
|
|
if (i == 0) cout << "========= Ifaces_1" << endl;
|
|
if (i == 1) cout << "========= Ifaces_2" << endl;
|
|
if (i == 2) cout << "========= Iout_1" << endl;
|
|
if (i == 3) cout << "========= Iout_2" << endl;
|
|
|
|
icol = i+1;
|
|
iface = ilist[i];
|
|
while (iface > 0) {
|
|
|
|
cout << "iface = " << iface << endl;
|
|
cout << "--- iold" << endl;
|
|
|
|
iedge = faces[iface].iold;
|
|
icol = 2;
|
|
|
|
while (iedge > 0) {
|
|
|
|
cout << " iegde = " << iedge
|
|
<< " i1,i2 =" << edges[iedge].i1 << "," << edges[iedge].i2
|
|
<< " iface1,iface2 = "
|
|
<< edges[iedge].iface1 << "," << edges[iedge].iface2
|
|
<< endl;
|
|
|
|
i1 = edges[iedge].i1;
|
|
p1[0] = nodes[i1].v.x();
|
|
p1[1] = nodes[i1].v.y();
|
|
p1[2] = nodes[i1].v.z();
|
|
IHWTON(p1,p1);
|
|
i2 = edges[iedge].i2;
|
|
p2[0] = nodes[i2].v.x();
|
|
p2[1] = nodes[i2].v.y();
|
|
p2[2] = nodes[i2].v.z();
|
|
IHWTON(p2,p2);
|
|
// icol = (edges[iedge].ivis > 0) ? 1 : 2;
|
|
IHZLIN(icol,p1[0],p1[1],p1[2], p2[0],p2[1],p2[2]);
|
|
iedge = edges[iedge].inext;
|
|
}
|
|
|
|
cout << "--- inew" << endl;
|
|
|
|
iedge = faces[iface].inew;
|
|
icol = 3;
|
|
|
|
while (iedge > 0) {
|
|
|
|
cout << " iegde = " << iedge
|
|
<< " i1,i2 =" << edges[iedge].i1 << "," << edges[iedge].i2
|
|
<< " iface1,iface2 = "
|
|
<< edges[iedge].iface1 << "," << edges[iedge].iface2
|
|
<< endl;
|
|
|
|
i1 = edges[iedge].i1;
|
|
p1[0] = nodes[i1].v.x();
|
|
p1[1] = nodes[i1].v.y();
|
|
p1[2] = nodes[i1].v.z();
|
|
IHWTON(p1,p1);
|
|
i2 = edges[iedge].i2;
|
|
p2[0] = nodes[i2].v.x();
|
|
p2[1] = nodes[i2].v.y();
|
|
p2[2] = nodes[i2].v.z();
|
|
IHWTON(p2,p2);
|
|
// icol = (edges[iedge].ivis > 0) ? 1 : 2;
|
|
IHZLIN(icol,p1[0],p1[1],p1[2], p2[0],p2[1],p2[2]);
|
|
iedge = edges[iedge].inext;
|
|
}
|
|
iface = faces[iface].inext;
|
|
|
|
IHZTOX(0,100,100);
|
|
ixupdwi(0);
|
|
cin >> II;
|
|
ixclrwi();
|
|
IHZCLE(0);
|
|
}
|
|
}
|
|
}
|
|
*/
|
|
|
|
/*
|
|
//--------------------------------------------------------------------
|
|
inline void
|
|
BooleanProcessor::draw_edge(int icol, int iedge) {
|
|
int i1, i2;
|
|
float p1[3], p2[3];
|
|
|
|
i1 = edges[iedge].i1;
|
|
p1[0] = nodes[i1].v.x();
|
|
p1[1] = nodes[i1].v.y();
|
|
p1[2] = nodes[i1].v.z();
|
|
IHWTON(p1,p1);
|
|
i2 = edges[iedge].i2;
|
|
p2[0] = nodes[i2].v.x();
|
|
p2[1] = nodes[i2].v.y();
|
|
p2[2] = nodes[i2].v.z();
|
|
IHWTON(p2,p2);
|
|
IHZLIN(icol,p1[0],p1[1],p1[2], p2[0],p2[1],p2[2]);
|
|
}
|
|
|
|
//--------------------------------------------------------------------
|
|
inline void
|
|
BooleanProcessor::draw_contour(int i1col, int i2col, int ihead) {
|
|
int iedge, icol;
|
|
iedge = ihead;
|
|
while (iedge > 0) {
|
|
icol = (edges[iedge].ivis > 0) ? i1col : i2col;
|
|
draw_edge(icol, iedge);
|
|
iedge = edges[iedge].inext;
|
|
}
|
|
|
|
IHZTOX(0,100,100);
|
|
ixupdwi(0);
|
|
|
|
int i;
|
|
std::cin >> i;
|
|
}
|
|
|
|
//--------------------------------------------------------------------
|
|
inline void
|
|
BooleanProcessor::print_face(int iface) {
|
|
cout.precision(3);
|
|
cout << "\n====== Face N " << iface << endl;
|
|
cout << "iedges[4] = "
|
|
<< faces[iface].iedges[0] << ", "
|
|
<< faces[iface].iedges[1] << ", "
|
|
<< faces[iface].iedges[2] << ", "
|
|
<< faces[iface].iedges[3] << endl;
|
|
cout << "rmin[3] = "
|
|
<< faces[iface].rmin[0] << ", "
|
|
<< faces[iface].rmin[1] << ", "
|
|
<< faces[iface].rmin[2] << endl;
|
|
cout << "rmax[3] = "
|
|
<< faces[iface].rmax[0] << ", "
|
|
<< faces[iface].rmax[1] << ", "
|
|
<< faces[iface].rmax[2] << endl;
|
|
cout << "iprev,inext = "
|
|
<< faces[iface].iprev << ", "
|
|
<< faces[iface].inext << endl;
|
|
cout << "iold = " << faces[iface].iold << endl;
|
|
for(int i = faces[iface].iold; i != 0;) {
|
|
print_edge(i);
|
|
i = edges[abs(i)].inext;
|
|
}
|
|
|
|
cout << "inew = ";
|
|
switch (faces[iface].inew) {
|
|
case UNKNOWN_FACE:
|
|
cout << "UNKNOWN_FACE" << endl;
|
|
break;
|
|
case ORIGINAL_FACE:
|
|
cout << "ORIGINAL_FACE" << endl;
|
|
break;
|
|
case NEW_FACE:
|
|
cout << "NEW_FACE" << endl;
|
|
break;
|
|
case UNSUITABLE_FACE:
|
|
cout << "UNSUITABLE_FACE" << endl;
|
|
break;
|
|
case DEFECTIVE_FACE:
|
|
cout << "DEFECTIVE_FACE" << endl;
|
|
break;
|
|
default:
|
|
cout << faces[iface].inew << endl;
|
|
for(int k = faces[iface].inew; k != 0;) {
|
|
print_edge(k);
|
|
k = edges[abs(k)].inext;
|
|
}
|
|
}
|
|
}
|
|
|
|
//--------------------------------------------------------------------
|
|
inline void
|
|
BooleanProcessor::print_edge(int iedge) {
|
|
cout << "==== Edge N " << iedge << endl;
|
|
int i = std::abs(iedge);
|
|
int i1 = edges[i].i1;
|
|
int i2 = edges[i].i2;
|
|
cout << "node[" << i1 << "] = "
|
|
<< nodes[i1].v.x() << ", "
|
|
<< nodes[i1].v.y() << ", "
|
|
<< nodes[i1].v.z() << endl;
|
|
|
|
cout << "node[" << i2 << "] = "
|
|
<< nodes[i2].v.x() << ", "
|
|
<< nodes[i2].v.y() << ", "
|
|
<< nodes[i2].v.z() << endl;
|
|
|
|
cout << "iface1,iface2,ivis,inext = "
|
|
<< edges[i].iface1 << ", "
|
|
<< edges[i].iface2 << ", "
|
|
<< edges[i].ivis << ", "
|
|
<< edges[i].inext << endl;
|
|
}
|
|
*/
|
|
|
|
inline void BooleanProcessor::dump(std::ostream& a_out) {//G.Barrand
|
|
size_t number = nodes.size();
|
|
a_out << "nodes : " << number << std::endl;
|
|
for(size_t index=0;index<number;index++) {
|
|
const ExtNode& node = nodes[index];
|
|
a_out << " " << index
|
|
<< " x = " << node.v[0]
|
|
<< " y = " << node.v[1]
|
|
<< " z = " << node.v[2]
|
|
<< std::endl;
|
|
}
|
|
}
|
|
|
|
}}
|