BooleanProcessor Class Reference

#include <BooleanProcessor.h>

Collaboration diagram for BooleanProcessor:

Public Member Functions
	BooleanProcessor ()
	~BooleanProcessor ()
HepPolyhedron	execute (int op, const HepPolyhedron &a, const HepPolyhedron &b, int &err)
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)
int	get_processor_error () const
void	dump ()

Static Public Member Functions
static int	get_shift ()
static void	set_shift (int)
static int	get_num_shift ()

Private Member Functions
void	takePolyhedron (const HepPolyhedron &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 ()
void	divideEdge (int &i1, int &i2)
void	insertEdge (const ExtEdge &edge)
void	caseII (ExtEdge &edge1, ExtEdge &edge2)
void	caseIE (ExtEdge &edge1, ExtEdge &edge2)
void	caseEE (ExtEdge &edge1, ExtEdge &edge2)
void	testFaceVsFace (int iface1, int iface2)
void	invertNewEdges (int iface)
void	checkDoubleEdges (int iface)
void	assembleFace (int what, int iface)
void	assembleNewFaces (int what, int ihead)
void	initiateLists ()
void	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)
int	checkTriangle (int iedge1, int iedge2, int ix, int iy) const
void	triangulateContour (int ix, int iy, int ihead)
void	modifyReference (int iface, int i1, int i2, int iref)
void	triangulateFace (int iface)
HepPolyhedron	createPolyhedron ()

Private Attributes
std::vector< ExtNode >	m_nodes
std::vector< ExtEdge >	m_edges
std::vector< ExtFace >	m_faces
int	m_processor_error
int	m_operation
int	m_ifaces1
int	m_ifaces2
int	m_iout1
int	m_iout2
int	m_iunk1
int	m_iunk2
double	m_rmin [3]
double	m_rmax [3]
double	m_del
FaceList	m_result_faces
FaceList	m_suitable_faces
FaceList	m_unsuitable_faces
FaceList	m_unknown_faces
std::vector< int >	m_external_contours
std::vector< int >	m_internal_contours

Static Private Attributes
static int	s_ishift = 0

Detailed Description

Definition at line 312 of file BooleanProcessor.h.

Constructor & Destructor Documentation

BooleanProcessor()

BooleanProcessor::BooleanProcessor ( )

inline

Definition at line 368 of file BooleanProcessor.h.

  :m_processor_error(0)  // The next few fields are work space, initialised
  ,m_operation(0)        // here to prevent Coverity warnings.
  ,m_ifaces1(0)          // "
  ,m_ifaces2(0)          // "
  ,m_iout1(0)            // "
  ,m_iout2(0)            // "
  ,m_iunk1(0)            // "
  ,m_iunk2(0)            // "
  ,m_del(0.)             // "
  ,m_result_faces(m_faces)
  ,m_suitable_faces(m_faces)
  ,m_unsuitable_faces(m_faces)
  ,m_unknown_faces(m_faces)
  {  // rmin, rmax also initialised here to prevent Coverity warnings.
    for (int i = 0; i < 3; i++) {
      m_rmin[i] = 0.;
      m_rmax[i] = 0.;
    }
  }

~BooleanProcessor()

BooleanProcessor::~BooleanProcessor ( )

inline

Definition at line 389 of file BooleanProcessor.h.

{}

Member Function Documentation

assembleFace()

void BooleanProcessor::assembleFace ( int what, int iface )

private

Definition at line 1087 of file BooleanProcessor.h.

{
  //   A S S E M B L E   N E W   F A C E
 
  int ihead = 0;  // 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
 
#define INSERT_EDGE_TO_THE_LIST(A) \
*ilink = A; ilink = &m_edges[A].inext; *ilink = 0
 
  ExtFace& face = m_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 = m_edges[icur].inext;
    INSERT_EDGE_TO_THE_LIST(icur);
    ifirst = m_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 = m_edges[icur];
      while(*i > 0) {
        ExtEdge& edge_i = m_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 = m_edges[*i];
          if (edge_i.i1 == edge_cur.i2) {
            ioldflag = 1;
            break;
          }
          i = &edge_i.inext;
        }
      }
      if (*i > 0) {
        icur = *i;
        *i = m_edges[icur].inext;
        INSERT_EDGE_TO_THE_LIST(icur);
        if (m_edges[icur].i2 == ifirst) { break; } else { continue; }
      }else{
        m_processor_error = 1;
#ifdef BP_DEBUG
        G4cerr
          << "BooleanProcessor::assembleFace(" << iface << ") : "
          << "could not find next edge of the contour"
          << G4endl;
#endif
        face.inew = DEFECTIVE_FACE;
        return;
      }
    }
  }
 
  //   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 (m_edges[iedge].inext > 0) {
        if (m_edges[iedge].i2 == m_edges[m_edges[iedge].inext].i1) {
          iedge = m_edges[iedge].inext;
        }else{
          break;
        }
      }else{
        if (m_edges[iedge].i2 == m_edges[face.iold].i1) {
          m_edges[iedge].inext = ihead;   // set new face
          return;
        }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 = m_edges[iedge].iface2;
    if (m_faces[iface2].inew == 0) m_faces[iface2].inew = UNSUITABLE_FACE;
    iedge = m_edges[iedge].inext;
  }
  face.iold = ihead;            // set new face
}

assembleNewFaces()

void BooleanProcessor::assembleNewFaces ( int what, int ihead )

private

Definition at line 1196 of file BooleanProcessor.h.

{
  int iface = ihead;
  while(iface > 0) {
    if (m_faces[iface].inew > 0) {
      if (what != 0) invertNewEdges(iface);
      checkDoubleEdges(iface);
      assembleFace(what, iface);
      m_faces[iface].inew =
        (m_faces[iface].iold == 0) ? UNSUITABLE_FACE : NEW_FACE;
    }
    iface = m_faces[iface].inext;
  }
}

assemblePolyhedra()

void BooleanProcessor::assemblePolyhedra ( )

private

Definition at line 1323 of file BooleanProcessor.h.

{
  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 = m_suitable_faces.front();
  while(iface > 0) {
    i = iface;
    iedge = m_faces[i].iold;
    while(iedge > 0) {
      iface = m_edges[iedge].iface2;
      if (m_faces[iface].inew == UNKNOWN_FACE) {
        m_unknown_faces.remove(iface);
        m_suitable_faces.push_back(iface);
        m_faces[iface].inew = ORIGINAL_FACE;
      }
      iedge = m_edges[iedge].inext;
    }
    iface = m_faces[i].inext;
    m_suitable_faces.remove(i);
    m_result_faces.push_back(i);
  }
  if (m_unknown_faces.front() == 0) return;
 
  //   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 = m_unsuitable_faces.front();
  while(iface > 0) {
    i = iface;
    iedge = m_faces[i].iold;
    while(iedge > 0) {
      iface = m_edges[iedge].iface2;
      if (m_faces[iface].inew == UNKNOWN_FACE) {
        m_unknown_faces.remove(iface);
        m_unsuitable_faces.push_back(iface);
        m_faces[iface].inew = UNSUITABLE_FACE;
      }
      iedge = m_edges[iedge].inext;
    }
    iface = m_faces[i].inext;
    m_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 m_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 = m_unknown_faces.front();
   while(iface > 0) {
     i = iface;
     m_faces[i].inew = ORIGINAL_FACE;
     iface = m_faces[i].inext;
     m_unknown_faces.remove(i);
     m_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
}

caseEE()

void BooleanProcessor::caseEE ( ExtEdge & edge1, ExtEdge & edge2 )

private

Definition at line 976 of file BooleanProcessor.h.

{
  m_processor_error = 1;
#ifdef BP_DEBUG
  G4cout
    << "BooleanProcessor::caseEE : unimplemented case"
    << G4endl;
#endif
}

caseIE()

void BooleanProcessor::caseIE ( ExtEdge & edge1, ExtEdge & edge2 )

private

Definition at line 958 of file BooleanProcessor.h.

{
  m_processor_error = 1;
#ifdef BP_DEBUG
  G4cout
    << "BooleanProcessor::caseIE : unimplemented case"
    << G4endl;
#endif
}

caseII()

void BooleanProcessor::caseII ( ExtEdge & edge1, ExtEdge & edge2 )

private

Definition at line 940 of file BooleanProcessor.h.

{
  divideEdge(edge1.i1, edge2.i2);
  divideEdge(edge1.i2, edge2.i1);
  edge1.ivis = 1;
  edge2.ivis = 1;
  insertEdge(edge1);
  insertEdge(edge2);
}

checkDirection()

int BooleanProcessor::checkDirection ( double * x, double * y ) const

private

Definition at line 1426 of file BooleanProcessor.h.

{
  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 <= m_del && d2 <= m_del)            return 1;
  if (! (d1 > m_del && d2 > m_del)) {
    if ( a1*x[2] + b1*y[2] + c1 >= -m_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 <= m_del && d2 <= m_del)            return 1;
  if (!(d1 > m_del && d2 > m_del)) {
    if ( a1*x[5] + b1*y[5] + c1 >= -m_del) return 1;
  }
  return 0;
}

checkDoubleEdges()

void BooleanProcessor::checkDoubleEdges ( int iface )

private

Definition at line 1074 of file BooleanProcessor.h.

{
 
}

checkIntersection()

int BooleanProcessor::checkIntersection ( int ix, int iy, int i1, int i2 ) const

private

Definition at line 1462 of file BooleanProcessor.h.

{
  //  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 = m_nodes[i1].v[ix];
  y1 = m_nodes[i1].v[iy];
  x2 = m_nodes[i2].v[ix];
  y2 = m_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)m_external_contours.size(); icontour++) {
    iedge = m_external_contours[icontour];
    while(iedge > 0) {
      k1 = m_edges[iedge].i1;
      k2 = m_edges[iedge].i2;
      iedge = m_edges[iedge].inext;
      if (k1 == i1 || k2 == i1) continue;
      if (k1 == i2 || k2 == i2) continue;
      x3 = m_nodes[k1].v[ix];
      y3 = m_nodes[k1].v[iy];
      x4 = m_nodes[k2].v[ix];
      y4 = m_nodes[k2].v[iy];
      d1 = a1*x3 + b1*y3 + c1;
      d2 = a1*x4 + b1*y4 + c1;
      if (d1 >  m_del && d2 >  m_del) continue;
      if (d1 < -m_del && d2 < -m_del) continue;
 
      findABC(x3, y3, x4, y4, a2, b2, c2);
      d1 = a2*x1 + b2*y1 + c2;
      d2 = a2*x2 + b2*y2 + c2;
      if (d1 >  m_del && d2 >  m_del) continue;
      if (d1 < -m_del && d2 < -m_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)m_internal_contours.size(); icontour++) {
    iedge = m_internal_contours[icontour];
    while(iedge > 0) {
      k1 = m_edges[iedge].i1;
      k2 = m_edges[iedge].i2;
      iedge = m_edges[iedge].inext;
      if (k1 == i1 || k2 == i1) continue;
      if (k1 == i2 || k2 == i2) continue;
      x3 = m_nodes[k1].v[ix];
      y3 = m_nodes[k1].v[iy];
      x4 = m_nodes[k2].v[ix];
      y4 = m_nodes[k2].v[iy];
      d1 = a1*x3 + b1*y3 + c1;
      d2 = a1*x4 + b1*y4 + c1;
      if (d1 >  m_del && d2 >  m_del) continue;
      if (d1 < -m_del && d2 < -m_del) continue;
 
      findABC(x3, y3, x4, y4, a2, b2, c2);
      d1 = a2*x1 + b2*y1 + c2;
      d2 = a2*x2 + b2*y2 + c2;
      if (d1 >  m_del && d2 >  m_del) continue;
      if (d1 < -m_del && d2 < -m_del) continue;
      return 1;
    }
  }
  return 0;
}

checkTriangle()

int BooleanProcessor::checkTriangle ( int iedge1, int iedge2, int ix, int iy ) const

private

Definition at line 1613 of file BooleanProcessor.h.

{
  int    k[3];
  double x[3], y[3];
  double a1, b1, c1;
 
  k[0] = m_edges[iedge1].i1;
  k[1] = m_edges[iedge1].i2;
  k[2] = m_edges[iedge2].i2;
  for (int i=0; i<3; i++) {
    x[i] = m_nodes[k[i]].v[ix];
    y[i] = m_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*m_del) return 1;
 
  //   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 = m_edges[iedge].inext;
    if (m_edges[iedge].inext == iedge1) return 0;
    inode = m_edges[iedge].i2;
    if (inode == k[0])                continue;
    if (inode == k[1])                continue;
    if (inode == k[2])                continue;
    x[1]  = m_nodes[inode].v[ix];
    y[1]  = m_nodes[inode].v[iy];
    if (a1*x[1]+b1*y[1]+c1 < -0.1*m_del)    continue;
    if (a2*x[1]+b2*y[1]+c2 < -0.1*m_del)    continue;
    if (a3*x[1]+b3*y[1]+c3 < -0.1*m_del)    continue;
    return 1;
  }
  return 0; // default return
}

createPolyhedron()

HepPolyhedron BooleanProcessor::createPolyhedron ( )

private

Definition at line 1940 of file BooleanProcessor.h.

{
  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)m_nodes.size(); i++) m_nodes[i].s = 0;
 
  for (i=1; i<(int)m_faces.size(); i++) {
    if (m_faces[i].inew == ORIGINAL_FACE) {
      m_faces[i].inew = ++nface;
      iedge = m_faces[i].iold;
      while (iedge > 0) {
        m_nodes[m_edges[iedge].i1].s = 1;
        iedge = m_edges[iedge].inext;
      }
    }else{
      m_faces[i].inew = 0;
    }
  }
 
  for (i=1; i<(int)m_nodes.size(); i++) {
    if (m_nodes[i].s == 1) m_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)m_nodes.size(); i++) {
    if (m_nodes[i].s != 0)  polyhedron.m_pV[m_nodes[i].s] = m_nodes[i].v;
  }
 
  //   S E T   F A C E S
 
  int k, v[4]={0}, f[4]={0};
  for (i=1; i<(int)m_faces.size(); i++) {
    if (m_faces[i].inew == 0) continue;
    v[3] = f[3] = k = 0;
    iedge = m_faces[i].iold;
    while (iedge > 0) {
      if (k > 3) {
        std::cerr << "BooleanProcessor::createPolyhedron : too many edges" << std::endl;
        break;
      }
      v[k]  = m_nodes[m_edges[iedge].i1].s;
      if (m_edges[iedge].ivis < 0) v[k] = -v[k];
      f[k]  = m_faces[m_edges[iedge].iface2].inew;
      iedge = m_edges[iedge].inext;
      k++;
    }
    if (k < 3) {
      std::cerr << "BooleanProcessor::createPolyhedron : "
        << "face has only " << k << " edges"
        << std::endl;
    }
    polyhedron.m_pF[m_faces[i].inew] =
      G4Facet(v[0],f[0], v[1],f[1], v[2],f[2], v[3],f[3]);
  }
  //coverity[copy_constructor_call]
  return polyhedron;
}

divideEdge()

void BooleanProcessor::divideEdge ( int & i1, int & i2 )

private

Definition at line 875 of file BooleanProcessor.h.

{
  int iedges[2];
  iedges[0] = m_nodes[i1].s;
  iedges[1] = m_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;
  m_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 = m_faces[m_edges[ie1].iface2].iedges[0];
    while (ie2 > 0) {
      if (m_edges[ie2].i1 == m_edges[ie1].i2 &&
          m_edges[ie2].i2 == m_edges[ie1].i1) break;
      ie2 = m_edges[ie2].inext;
    }
 
    //   D I V I D E   E D G E S
 
    m_edges.push_back(m_edges[ie1]);
    m_edges[ie1].inext = m_edges.size() - 1;
    m_edges[ie1].i2    = inode;
    m_edges.back().i1  = inode;
 
    m_edges.push_back(m_edges[ie2]);
    m_edges[ie2].inext = m_edges.size() - 1;
    m_edges[ie2].i2    = inode;
    m_edges.back().i1  = inode;
  }
}

draw()

void BooleanProcessor::draw

(

)

draw_contour()

void BooleanProcessor::draw_contour	(	int	,
		int	,
		int	)

draw_edge()

void BooleanProcessor::draw_edge	(	int	,
		int	)

draw_faces()

void BooleanProcessor::draw_faces	(	int	,
		int	,
		int	)

dump()

void BooleanProcessor::dump

(

)

Definition at line 2476 of file BooleanProcessor.h.

                            {//G.Barrand
  unsigned int number = m_nodes.size();
  std::cerr << "nodes : " << number << std::endl;
  for(unsigned int index=0;index<number;index++) {
    const ExtNode& node = m_nodes[index];
    std::cerr << " " << index
           << " x = " << node.v[0]
           << " y = " << node.v[1]
           << " z = " << node.v[2]
           << std::endl;
  }
}

execute()

HepPolyhedron BooleanProcessor::execute	(	int	op,
		const HepPolyhedron &	a,
		const HepPolyhedron &	b,
		int &	err )

Definition at line 2021 of file BooleanProcessor.h.

{
  //static int ishift = 0; //G.Barrand
  //static double shift[8][3] = {
  static double shift[NUM_SHIFT][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}
  };
 
/*
  G4cerr << "BooleanProcessor::execute : ++++++++++++++++++++++"
            << a.getName().getString()
            << b.getName().getString()
            << G4endl;
*/
 
  //   I N I T I A T E   P R O C E S S O R
 
  m_processor_error = 0;
  m_operation = op;
  m_nodes.clear(); m_nodes.push_back(CRAZY_POINT);
  m_edges.clear(); m_edges.push_back(ExtEdge());
  m_faces.clear(); m_faces.push_back(ExtFace(m_edges,0)); //G.Barrand : ok ?
 
  //   T A K E   P O L Y H E D R A
 
  m_ifaces1 = m_faces.size(); takePolyhedron(a,0,0,0);
  m_ifaces2 = m_faces.size(); takePolyhedron(b,0,0,0);
 
  if (m_processor_error) {             // corrupted polyhedron
    std::cerr
      << "BooleanProcessor: corrupted input polyhedron"
      << std::endl;
    err = m_processor_error; //G.Barrand
    return HepPolyhedron();
  }
  if (m_ifaces1 == m_ifaces2) {          // a is empty
    err = m_processor_error; //G.Barrand
    switch (m_operation) {
    case OP_UNION:
      return b;
    case OP_INTERSECTION:
        std::cerr
        << "BooleanProcessor: intersection with empty polyhedron"
        << std::endl;
      return HepPolyhedron();
    case OP_SUBTRACTION:
        std::cerr
        << "BooleanProcessor: subtraction from empty polyhedron"
        << std::endl;
      return HepPolyhedron();
    }
  }
  if (m_ifaces2 == (int)m_faces.size()) {     // b is empty
    err = m_processor_error; //G.Barrand
    switch (m_operation) {
    case OP_UNION:
      return a;
    case OP_INTERSECTION:
        std::cerr
        << "BooleanProcessor: intersection with empty polyhedron"
        << std::endl;
      return HepPolyhedron();
    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
 
  m_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
 
/*
#define PROCESSOR_ERROR(a_what) \
  G4cerr << "BooleanProcessor: boolean operation problem (" << a_what \
            << "). Try again with other shifts."\
            << G4endl;
*/
#define PROCESSOR_ERROR(a_what)
 
  unsigned int try_count = 1;
  while(true) { //G.Barrand
 
  double ddxx = m_del*shift[s_ishift][0];
  double ddyy = m_del*shift[s_ishift][1];
  double ddzz = m_del*shift[s_ishift][2];
  s_ishift++; if (s_ishift == get_num_shift()) s_ishift = 0;
 
  m_processor_error = 0; //G.Barrand
  m_operation = op;
  m_nodes.clear(); m_nodes.push_back(CRAZY_POINT);
  m_edges.clear(); m_edges.push_back(ExtEdge());
  m_faces.clear(); m_faces.push_back(ExtFace(m_edges,0)); //G.Barrand : ok ?
 
  m_ifaces1 = m_faces.size(); takePolyhedron(a,0,0,0);
  m_ifaces2 = m_faces.size(); takePolyhedron(b,ddxx,ddyy,ddzz);
 
  if (m_processor_error) { PROCESSOR_ERROR(1) } //G.Barrand
 
  m_del = findMinMax();
 
  //   P R E S E L E C T   O U T S I D E   F A C E S
 
  m_iout1 = m_iout2 = 0;
  selectOutsideFaces(m_ifaces1, m_iout1);
  selectOutsideFaces(m_ifaces2, m_iout2);
 
  if (m_processor_error) { PROCESSOR_ERROR(2) } //G.Barrand
 
  //   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;
  m_iunk1 = m_iunk2 = 0;
  if (m_iout1 != 0 || m_iout2 != 0) {
    for(;;) {
      ifa1 = m_iunk1;
      ifa2 = m_iunk2;
      selectOutsideFaces(m_ifaces1, m_iunk1);
      selectOutsideFaces(m_ifaces2, m_iunk2);
      if (m_iunk1 == ifa1 && m_iunk2 == ifa2) break;
      findMinMax();
    }
  }
 
  if (m_processor_error) { PROCESSOR_ERROR(3) } //G.Barrand
 
  //   F I N D   N E W   E D G E S
 
  if (m_ifaces1 != 0 && m_ifaces2 != 0 ) {
    ifa1 = m_ifaces1;
    while (ifa1 > 0) {
      ifa2 = m_ifaces2;
      while (ifa2 > 0) {
        testFaceVsFace(ifa1, ifa2);
        ifa2 = m_faces[ifa2].inext;
      }
      ifa1 = m_faces[ifa1].inext;
    }
  }
  if (m_processor_error) { PROCESSOR_ERROR(4) } //G.Barrand
 
  //   C O N S T R U C T   N E W   F A C E S
 
  assembleNewFaces((m_operation == OP_INTERSECTION) ? 1 : 0, m_ifaces1);
  if (m_processor_error) { PROCESSOR_ERROR(5) } //G.Barrand
  assembleNewFaces((m_operation == OP_UNION) ? 0 : 1, m_ifaces2);
  if (m_processor_error) { PROCESSOR_ERROR(6) } //G.Barrand
 
  //   A S S E M B L E   S U I T A B L E   F A C E S
 
  initiateLists();
  assemblePolyhedra();
  if (m_unknown_faces.front() != 0) {
    m_processor_error = 1;
#ifdef BP_DEBUG
    G4cerr
      << "BooleanProcessor::execute : unknown faces !!!"
      << G4endl;
#endif
  }
  if (m_processor_error) { PROCESSOR_ERROR(7) } //G.Barrand
 
  //   T R I A N G U L A T E   A C C E P T E D   F A C E S
 
  ifa1 = m_result_faces.front();
  while (ifa1 > 0) {
    ifa2 = ifa1;
    ifa1 = m_faces[ifa2].inext;
    if (m_faces[ifa2].inew == NEW_FACE) triangulateFace(ifa2);
    if (m_processor_error) {
      PROCESSOR_ERROR(8) //G.Barrand
      break; //G.Barrand
    }
  }
 
  if(!m_processor_error) {
#ifdef BP_DEBUG
    if(try_count!=1) {
      G4cerr
         << "BooleanProcessor::execute : had converged."
         << G4endl;
    }
#endif
    break;
  }
 
  if((int)try_count>get_num_shift()) {
#ifdef BP_DEBUG
    /*** Commented out because HepPolyhedron does not have getName...?!
    G4cerr << "BooleanProcessor: "
              << " all shifts tried. Boolean operation (" << op << ") failure."
              << " a name \"" << a.getName().getString() << "\""
              << " b name \"" << b.getName().getString() << "\""
              << G4endl;
    ***/
#endif
    err = m_processor_error;
    return a;
  }
 
#ifdef BP_DEBUG
  G4cerr
     << "BooleanProcessor::execute : try another tilt..."
     << G4endl;
#endif
 
  try_count++;
 
  } //G.Barrand : end while shift.
#undef PROCESSOR_ERROR //G.Barrand
 
  //   C R E A T E   P O L Y H E D R O N
 
  err = m_processor_error;
  return createPolyhedron();
}

findABC()

void BooleanProcessor::findABC ( double x1, double y1, double x2, double y2, double & a, double & b, double & c ) const

inlineprivate

Definition at line 1405 of file BooleanProcessor.h.

{
  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);
}

findMinMax()

double BooleanProcessor::findMinMax ( )

private

Definition at line 567 of file BooleanProcessor.h.

{
  if (m_ifaces1 == 0 || m_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] = m_faces[m_ifaces1].rmin[i];
    rmax1[i] = m_faces[m_ifaces1].rmax[i];
    rmin2[i] = m_faces[m_ifaces2].rmin[i];
    rmax2[i] = m_faces[m_ifaces2].rmax[i];
  }
 
  iface = m_faces[m_ifaces1].inext;
  while(iface > 0) {
    ExtFace& face = m_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 = m_faces[m_ifaces2].inext;
  while(iface > 0) {
    ExtFace& face = m_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++) {
    m_rmin[i] = (rmin1[i] > rmin2[i]) ? rmin1[i] : rmin2[i];
    m_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;
}

get_num_shift()

int BooleanProcessor::get_num_shift ( )

static

Definition at line 2019 of file BooleanProcessor.h.

{ return NUM_SHIFT;} //G.Barrand

get_processor_error()

int BooleanProcessor::get_processor_error ( ) const

inline

Definition at line 402 of file BooleanProcessor.h.

{return m_processor_error;}

get_shift()

int BooleanProcessor::get_shift ( )

static

Definition at line 2016 of file BooleanProcessor.h.

{ return s_ishift;} //G.Barrand

initiateLists()

void BooleanProcessor::initiateLists ( )

private

Definition at line 1219 of file BooleanProcessor.h.

{
  int i, iface;
 
  //   R E S E T   L I S T S   O F   F A C E S
 
  m_result_faces.clean();
  m_suitable_faces.clean();
  m_unsuitable_faces.clean();
  m_unknown_faces.clean();
 
  //   I N I T I A T E   T H E   L I S T S
 
  iface = m_iout1;
  while (iface > 0) {
    i     = iface;
    iface = m_faces[i].inext;
    if (m_operation == OP_INTERSECTION) {
      m_unsuitable_faces.push_back(i);
      m_faces[i].inew = UNSUITABLE_FACE;
    }else{
      m_suitable_faces.push_back(i);
      m_faces[i].inew = ORIGINAL_FACE;
    }
  }
  iface = m_iout2;
  while (iface > 0) {
    i     = iface;
    iface = m_faces[i].inext;
    if (m_operation == OP_UNION) {
      m_suitable_faces.push_back(i);
      m_faces[i].inew = ORIGINAL_FACE;
    }else{
      m_unsuitable_faces.push_back(i);
      m_faces[i].inew = UNSUITABLE_FACE;
    }
  }
 
  iface = m_iunk1;
  while (iface > 0) {
    i     = iface;
    iface = m_faces[i].inext;
    m_unknown_faces.push_back(i);
  }
  iface = m_iunk2;
  while (iface > 0) {
    i     = iface;
    iface = m_faces[i].inext;
    if (m_operation == OP_SUBTRACTION) m_faces[i].invert();
    m_unknown_faces.push_back(i);
  }
 
  iface = m_ifaces1;
  while (iface > 0) {
    i     = iface;
    iface = m_faces[i].inext;
    switch(m_faces[i].inew) {
    case UNKNOWN_FACE:
      m_unknown_faces.push_back(i);
      break;
    case ORIGINAL_FACE: case NEW_FACE:
      m_suitable_faces.push_back(i);
      break;
    case UNSUITABLE_FACE:
      m_unsuitable_faces.push_back(i);
      break;
    default:
      m_faces[i].iprev = 0;
      m_faces[i].inext = 0;
      break;
    }
  }
  iface = m_ifaces2;
  while (iface > 0) {
    i     = iface;
    iface = m_faces[i].inext;
    if (m_operation == OP_SUBTRACTION) m_faces[i].invert();
    switch(m_faces[i].inew) {
    case UNKNOWN_FACE:
      m_unknown_faces.push_back(i);
      break;
    case ORIGINAL_FACE: case NEW_FACE:
      m_suitable_faces.push_back(i);
      break;
    case UNSUITABLE_FACE:
      m_unsuitable_faces.push_back(i);
      break;
    default:
      m_faces[i].iprev = 0;
      m_faces[i].inext = 0;
      break;
    }
  }
  m_ifaces1 = m_ifaces2 = m_iout1 = m_iout2 = m_iunk1 = m_iunk2 = 0;
}

insertEdge()

void BooleanProcessor::insertEdge ( const ExtEdge & edge )

private

Definition at line 924 of file BooleanProcessor.h.

{
  int iface = edge.iface1;
  m_edges.push_back(edge);
  m_edges.back().inext = m_faces[iface].inew;
  m_faces[iface].inew  = m_edges.size() - 1;
}

invertNewEdges()

void BooleanProcessor::invertNewEdges ( int iface )

private

Definition at line 1057 of file BooleanProcessor.h.

{
  int iedge = m_faces[iface].inew;
  while (iedge > 0) {
    m_edges[iedge].invert();
    iedge = m_edges[iedge].inext;
  }
}

mergeContours()

void BooleanProcessor::mergeContours ( int ix, int iy, int kext, int kint )

private

Definition at line 1541 of file BooleanProcessor.h.

{
  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 = m_external_contours[kext];
  while (i1ext > 0) {
    i2ext = m_edges[i1ext].inext;
    if (i2ext == 0) i2ext = m_external_contours[kext];
    k[0] = m_edges[i1ext].i1;
    k[1] = m_edges[i1ext].i2;
    k[2] = m_edges[i2ext].i2;
    for (i=0; i<3; i++) {
      x[i] = m_nodes[k[i]].v[ix];
      y[i] = m_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 = m_internal_contours[kint];
    while (i1int > 0) {
      i2int = m_edges[i1int].inext;
      if (i2int == 0) i2int = m_internal_contours[kint];
      k[3] = m_edges[i1int].i1;
      k[4] = m_edges[i1int].i2;
      k[5] = m_edges[i2int].i2;
      for (i=3; i<6; i++) {
        x[i] = m_nodes[k[i]].v[ix];
        y[i] = m_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 (m_edges[i].inext == 0) {
              m_edges[i].inext = m_internal_contours[kint];
              m_internal_contours[kint] = 0;
              break;
            }else{
              i = m_edges[i].inext;
            }
          }
          i = m_edges[i1int].iface1;
          m_edges.push_back(ExtEdge(k[1], k[4], i, -(int(m_edges.size())+1), -1));
          m_edges.back().inext = i2int;
          m_edges.push_back(ExtEdge(k[4], k[1], i, -(int(m_edges.size())-1), -1));
          m_edges.back().inext = m_edges[i1ext].inext;
          m_edges[i1ext].inext = m_edges.size()-2;
          m_edges[i1int].inext = m_edges.size()-1;
          return;
        }
      }
      i1int = m_edges[i1int].inext;
    }
    i1ext = m_edges[i1ext].inext;
  }
}

modifyReference()

void BooleanProcessor::modifyReference ( int iface, int i1, int i2, int iref )

private

Definition at line 1773 of file BooleanProcessor.h.

{
  int iedge = m_faces[iface].iold;
  while (iedge > 0) {
    if (m_edges[iedge].i1 == i2 && m_edges[iedge].i2 == i1) {
      m_edges[iedge].iface2 = iref;
      return;
    }
    iedge = m_edges[iedge].inext;
  }
  m_processor_error = 1;
#ifdef BP_DEBUG
  G4cerr
    << "BooleanProcessor::modifyReference : could not find the edge, "
    << "iface=" << iface << ", i1,i2=" << i1 << "," << i2 << ", iref=" << iref
    << G4endl;
#endif
}

print_edge()

void BooleanProcessor::print_edge

(

int

)

print_face()

void BooleanProcessor::print_face

(

int

)

removeJunkNodes()

void BooleanProcessor::removeJunkNodes ( )

inlineprivate

Definition at line 342 of file BooleanProcessor.h.

{ while(m_nodes.back().s != 0) m_nodes.pop_back(); }

renumberNodes()

void BooleanProcessor::renumberNodes ( int & i1, int & i2, int & i3, int & i4 )

private

Definition at line 812 of file BooleanProcessor.h.

{
  if (i1 == i2) return;
  if (m_nodes[i1].s == 0 || m_nodes.back().s == 0) { i1 = i2; return; }
 
  int ilast = m_nodes.size()-1;
  if (i1 == ilast) { i1 = i2; m_nodes.pop_back(); return; }
  if (i2 == ilast) { i2 = i1; }
  if (i3 == ilast) { i3 = i1; }
  if (i4 == ilast) { i4 = i1; }
  m_nodes[i1] = m_nodes.back(); i1 = i2; m_nodes.pop_back();
}

selectOutsideFaces()

void BooleanProcessor::selectOutsideFaces ( int & ifaces, int & iout )

private

Definition at line 630 of file BooleanProcessor.h.

{
  int i, outflag, iface = ifaces, *prev;
  HVPoint3D mmbox[8] = { HVPoint3D(m_rmin[0],m_rmin[1],m_rmin[2]),
                               HVPoint3D(m_rmax[0],m_rmin[1],m_rmin[2]),
                               HVPoint3D(m_rmin[0],m_rmax[1],m_rmin[2]),
                               HVPoint3D(m_rmax[0],m_rmax[1],m_rmin[2]),
                               HVPoint3D(m_rmin[0],m_rmin[1],m_rmax[2]),
                               HVPoint3D(m_rmax[0],m_rmin[1],m_rmax[2]),
                               HVPoint3D(m_rmin[0],m_rmax[1],m_rmax[2]),
                               HVPoint3D(m_rmax[0],m_rmax[1],m_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 = m_faces[iface]; //G.Barrand : optimize.
    for (i=0; i<3; i++) {
      if (face.rmin[i] > m_rmax[i] + m_del) { outflag = 1; break; }
      if (face.rmax[i] < m_rmin[i] - m_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 > +m_del) npos++;
        if (d < -m_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;
  }
}

set_shift()

void BooleanProcessor::set_shift ( int a_shift )

static

Definition at line 2017 of file BooleanProcessor.h.

{ s_ishift = a_shift;} //G.Barrand

takePolyhedron()

void BooleanProcessor::takePolyhedron ( const HepPolyhedron & p, double dx, double dy, double dz )

private

Definition at line 451 of file BooleanProcessor.h.

{
  int i, k, nnode, iNodes[5], iVis[4], iFaces[4];
  int dnode = m_nodes.size() - 1;
  int dface = m_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++) {
#ifdef BP_GEANT4 //G.Barrand
    ppp = p.GetVertex(i);
    ppp.setX(ppp.x()+dx);
    ppp.setY(ppp.y()+dy);
    ppp.setZ(ppp.z()+dz);
#else
    ppp = p.GetVertexFast(i);
    ppp += HVPoint3D(dx,dy,dz);
#endif
    m_nodes.push_back(ExtNode(ppp));
  }
 
  //   S E T   F A C E S
 
  for (int iface=1; iface <= p.GetNoFacets(); iface++) {
    m_faces.push_back(ExtFace(m_edges,m_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()) m_processor_error = 1;
      //if (iFaces[i] < 1 || iFaces[i] > p.GetNoFacets())   m_processor_error = 1;
 
      if (iNodes[i] < 1 || iNodes[i] > p.GetNoVertices()) { //G.Barrand
        m_processor_error = 1;
#ifdef BP_DEBUG
        G4cerr
          << "BooleanProcessor::takePolyhedron : problem 1."
          << G4endl;
#endif
      }
      if (iFaces[i] < 1 || iFaces[i] > p.GetNoFacets()) { //G.Barrand
        m_processor_error = 1;
#ifdef BP_DEBUG
        G4cerr
          << "BooleanProcessor::takePolyhedron : problem 2."
          << G4endl;
#endif
      }
      iNodes[i] += dnode;
      iFaces[i] += dface;
    }
 
    //   S E T   E D G E S
 
    iNodes[nnode] = iNodes[0];
    m_faces.back().iedges[3] = 0;
    for (i=0; i<nnode; i++) {
      m_faces.back().iedges[i] = m_edges.size();
      m_edges.push_back(ExtEdge(iNodes[i], iNodes[i+1],
                                iface+dface, iFaces[i], iVis[i]));
      m_edges.back().inext     = m_edges.size();
    }
    m_edges.back().inext = 0;
 
    //   S E T   F A C E   M I N - M A X
 
    ExtFace& face = m_faces.back();     //G.Barrand : optimize.
    for (i=0; i<3; i++) {
      face.rmin[i] = m_nodes[iNodes[0]].v[i];
      face.rmax[i] = m_nodes[iNodes[0]].v[i];
    }
    for (i=1; i<nnode; i++) {
      ExtNode& node = m_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
 
    HVNormal3D n = (m_nodes[iNodes[2]].v-m_nodes[iNodes[0]].v).cross
                        (m_nodes[iNodes[3]].v-m_nodes[iNodes[1]].v);
    HVPoint3D  point(0,0,0);
 
    for (i=0; i<nnode; i++) { point += m_nodes[iNodes[i]].v; }
    if (nnode > 1) point *= (1./nnode);
 
 
    //G.Barrand : faces.back().plane = HVPlane3D(n.unit(), point);
    m_faces.back().plane = HVPlane3D(n, point); //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
 
    m_faces.back().inext = m_faces.size();
  }
  m_faces.back().inext = 0;
}

testEdgeVsEdge()

int BooleanProcessor::testEdgeVsEdge ( ExtEdge & edge1, ExtEdge & edge2 )

private

Definition at line 837 of file BooleanProcessor.h.

{
  int    i, ii = 0;
  double d, dd = 0.;
 
  for (i=0; i<3; i++) {
    d = m_nodes[edge1.i1].v[i]-m_nodes[edge1.i2].v[i];
    if (d < 0.) d = -d;
    if (d > dd) { dd = d; ii = i; }
  }
  double t1 = m_nodes[edge1.i1].v[ii];
  double t2 = m_nodes[edge1.i2].v[ii];
  double t3 = m_nodes[edge2.i1].v[ii];
  double t4 = m_nodes[edge2.i2].v[ii];
  if (t2-t1 < 0.) { t1 = -t1; t2 = -t2; t3 = -t3; t4 = -t4; }
 
  if (t3 <= t1+m_del || t4 >= t2-m_del) return 0;
  if (t3 > t2+m_del) {
    renumberNodes(edge2.i1, edge1.i2, edge1.i1, edge2.i2);
  }else if (t3 < t2-m_del) {
    renumberNodes(edge1.i2, edge2.i1, edge1.i1, edge2.i2);
  }
  if (t4 < t1-m_del) {
    renumberNodes(edge2.i2, edge1.i1, edge1.i2, edge2.i1);
  }else if (t4 > t1+m_del) {
    renumberNodes(edge1.i1, edge2.i2, edge1.i2, edge2.i1);
  }
  return 1;
}

testFaceVsFace()

void BooleanProcessor::testFaceVsFace ( int iface1, int iface2 )

private

Definition at line 994 of file BooleanProcessor.h.

{
  ExtEdge edge1, edge2;
  int     irep1, irep2;
 
  //   M I N - M A X
 
 {const ExtFace& face_1 = m_faces[iface1]; //G.Barrand : optimize
  const ExtFace& face_2 = m_faces[iface2];
  for (int i=0; i<3; i++) {
    if (face_1.rmin[i] > face_2.rmax[i] + m_del) return;
    if (face_1.rmax[i] < face_2.rmin[i] - m_del) return;
  }}
 
  //   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;
  }
 
  //   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;
  }
 
  //   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;
  }
 
  //   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;
 
  //   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)         caseIE(edge1, edge2);
  if (irep1 == EDGE         && irep2 == INTERSECTION) caseIE(edge2, edge1);
  if (irep1 == EDGE         && irep2 == EDGE)         caseEE(edge1, edge2);
  removeJunkNodes();
 
}

testFaceVsPlane()

int BooleanProcessor::testFaceVsPlane ( ExtEdge & edge )

private

Definition at line 688 of file BooleanProcessor.h.

{
  int        iface = edge.iface1;
  HVPlane3D plane = m_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 = (m_faces[iface].iedges[3] == 0) ? 3 : 4;
  for (i=0; i<nnode; i++) {
    dd[i] = plane.distance(m_nodes[m_edges[m_faces[iface].iedges[i]].i1].v);
    if (dd[i] > m_del) {
      npos++;
    }else if (dd[i] < -m_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., d3 = 0.;
    ii[0] = ie1; ii[1] = ie2;
    for (i=0; i<2; i++) {
      iedge = m_faces[iface].iedges[ii[i]];
      while (iedge > 0) {
        i1 = m_edges[iedge].i1;
        i2 = m_edges[iedge].i2;
 
        d1 = plane.distance(m_nodes[i1].v);
        d2 = plane.distance(m_nodes[i2].v);
        if (d1 > m_del) {
          if (d2 < -m_del) { ii[i] = m_nodes.size(); break; } // +-
        }else if (d1 < -m_del) {
          if (d2 >  m_del) { ii[i] = m_nodes.size(); break; } // -+
        }else{
          ii[i] = i1; break;                              // 0+ or 0-
        }
        iedge = m_edges[iedge].inext;
      }
      if (ii[i] == (int)m_nodes.size()) {
        d3 = d2-d1; 
        if (d3 == 0){
          std::cerr<<"d3 is zero in "<<__FILE__<<std::endl;
          return DEFECTIVE_FACE;
        }
        d1 = d1/d3; 
        d2 = d2/d3;
        m_nodes.push_back(ExtNode(d2*m_nodes[i1].v-d1*m_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 = m_edges[m_faces[iface].iedges[ie2]].i1;
      edge.i2 = m_edges[m_faces[iface].iedges[ie1]].i1;
    }else{
      edge.i1 = m_edges[m_faces[iface].iedges[ie1]].i1;
      edge.i2 = m_edges[m_faces[iface].iedges[ie2]].i1;
    }
    return EDGE;
  }
}

triangulateContour()

void BooleanProcessor::triangulateContour ( int ix, int iy, int ihead )

private

Definition at line 1665 of file BooleanProcessor.h.

{
 
  //G4cout << "Next Countour" << G4endl;
  //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 (m_edges[ipnext].inext > 0) {
      ipnext = m_edges[ipnext].inext;
      nnode++;
    }else{
      m_edges[ipnext].inext = ihead;
      break;
    }
  }
 
  //   L O O P   A L O N G   C O N T O U R
 
  //G4cerr << "debug : contour : begin : =================" << G4endl;
  //dump();//debug
 
  int iedge1, iedge2, iedge3, istart = 0;
  for (;;) {
    iedge1 = m_edges[ipnext].inext;
    iedge2 = m_edges[iedge1].inext;
/*
    G4cerr << "debug :"
              << " ipnext " << ipnext
              << " iedge1 " << iedge1
              << " iedge2 " << iedge2
              << " : istart " << istart
              << G4endl;
*/
    if (istart == 0) {
      istart = iedge1;
      if (nnode <= 3) {
        iedge3 = m_edges[iedge2].inext;
        m_edges[iedge1].iface1 = m_faces.size();
        m_edges[iedge2].iface1 = m_faces.size();
        m_edges[iedge3].iface1 = m_faces.size();
        m_edges[iedge3].inext = 0;
        m_faces.push_back(ExtFace(m_edges,0)); //G.Barrand : ok ?
        m_faces.back().iold = iedge1;
        m_faces.back().inew = ORIGINAL_FACE;
 
  //if (draw_flag) draw_contour(4, 2, iedge1);
 
        break;
      }
    }else if (istart == iedge1) {
      m_processor_error = 1;
#ifdef BP_DEBUG
      G4cerr
        << "BooleanProcessor::triangulateContour : "
        << "could not generate a triangle (infinite loop)"
        << G4endl;
#endif
      break;
    }
 
    //   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) != 0) {
      ipnext  = m_edges[ipnext].inext;
      continue;
    }
 
    //   M O D I F Y   C O N T O U R
 
    int i1 = m_edges[iedge1].i1;
    int i3 = m_edges[iedge2].i2;
    int iface1 = m_edges[iedge1].iface1;
    int iface2 = m_faces.size();
 
    m_edges[ipnext].inext = m_edges.size();
    m_edges.push_back(ExtEdge(i1, i3, iface1, -(int(m_edges.size())+1), -1));
    m_edges.back().inext = m_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
 
    m_edges[iedge2].inext = m_edges.size();
    m_edges.push_back(ExtEdge(i3, i1, iface2, -(int(m_edges.size())-1), -1));
    m_faces.push_back(ExtFace(m_edges,0)); //G.Barrand : ok ?
    m_faces.back().iold   = iedge1;
    m_faces.back().inew   = ORIGINAL_FACE;
    m_edges[iedge1].iface1 = iface2;
    m_edges[iedge2].iface1 = iface2;
    ipnext  = m_edges[ipnext].inext;
    istart = 0;
    nnode--;
 
  //if (draw_flag)  draw_contour(4, 2, iedge1);
 
  }
}

triangulateFace()

void BooleanProcessor::triangulateFace ( int iface )

private

Definition at line 1800 of file BooleanProcessor.h.

{
 
  //   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
 
#ifdef BP_GEANT4 //G.Barrand
  HVNormal3D normal = m_faces[iface].plane.normal();
#else
  const HVNormal3D& normal = m_faces[iface].plane.getNormal();
#endif
  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
 
  m_external_contours.clear();
  m_internal_contours.clear();
  double z;
  int    i1, i2, ifirst, iedge, icontour = m_faces[iface].iold;
  while (icontour > 0) {
    iedge  = icontour;
    ifirst = m_edges[iedge].i1;
    z      = 0.0;
    for(;;) {
      if (iedge > 0) {
        i1 = m_edges[iedge].i1;
        i2 = m_edges[iedge].i2;
        ExtNode& node_1 = m_nodes[i1];
        ExtNode& node_2 = m_nodes[i2];
        z += node_1.v[ix]*node_2.v[iy]-node_2.v[ix]*node_1.v[iy];
        if (ifirst != i2) {
          iedge = m_edges[iedge].inext;
          continue;
        }else{
          if (z > m_del*m_del) {
            m_external_contours.push_back(icontour);
          }else if (z < -m_del*m_del) {
            m_internal_contours.push_back(icontour);
          }else{
            m_processor_error = 1;
#ifdef BP_DEBUG
            G4cerr
              << "BooleanProcessor::triangulateFace : too small contour"
              << G4endl;
#endif
          }
          icontour = m_edges[iedge].inext;
          m_edges[iedge].inext = 0;
          break;
        }
      }else{
        m_processor_error = 1;
#ifdef BP_DEBUG
        G4cerr
          << "BooleanProcessor::triangulateFace : broken contour"
          << G4endl;
#endif
        icontour = 0;
        break;
      }
    }
  }
 
  //   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)m_internal_contours.size(); kint++) {
    for (kext=0; kext < (int)m_external_contours.size(); kext++) {
      mergeContours(ix, iy, kext, kint);
      if (m_internal_contours[kint] == 0) break;
    }
    if (kext == (int)m_external_contours.size()) {
      m_processor_error = 1;
#ifdef BP_DEBUG
      G4cerr
        << "BooleanProcessor::triangulateFace : "
        << "could not merge internal contour " << kint
        << G4endl;
#endif
    }
  }
 
  //   T R I A N G U L A T E   C O N T O U R S
 
  int nface = m_faces.size();
  for (kext=0; kext < (int)m_external_contours.size(); kext++) {
    triangulateContour(ix, iy, m_external_contours[kext]);
#ifdef BP_DEBUG
    if(m_processor_error) { //G.Barrand
      G4cerr
        << "BooleanProcessor::triangulateFace : "
        << "triangulateContour failed."
        << G4endl;
      break; //G.Barrand : ok ?
    }
#endif
  }
  m_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)m_faces.size(); ifa++) {
    iedge = m_faces[ifa].iold;
    while (iedge > 0) {
      if (m_edges[iedge].iface1 != ifa) {
        m_processor_error = 1;
#ifdef BP_DEBUG
        G4cerr
          << "BooleanProcessor::triangulateFace : wrong reference to itself, "
          << "iface=" << ifa << ", iface1=" << m_edges[iedge].iface1
          << G4endl;
#endif
      }else if (m_edges[iedge].iface2 > 0) {
        modifyReference(m_edges[iedge].iface2,
                        m_edges[iedge].i1, m_edges[iedge].i2, ifa);
      }else if (m_edges[iedge].iface2 < 0) {
        m_edges[iedge].iface2 = m_edges[-m_edges[iedge].iface2].iface1;
      }
      iedge = m_edges[iedge].inext;
    }
  }
}

Member Data Documentation

m_del

double BooleanProcessor::m_del

private

Definition at line 325 of file BooleanProcessor.h.

m_edges

std::vector<ExtEdge> BooleanProcessor::m_edges

private

Definition at line 316 of file BooleanProcessor.h.

m_external_contours

std::vector<int> BooleanProcessor::m_external_contours

private

Definition at line 332 of file BooleanProcessor.h.

m_faces

std::vector<ExtFace> BooleanProcessor::m_faces

private

Definition at line 317 of file BooleanProcessor.h.

m_ifaces1

int BooleanProcessor::m_ifaces1

private

Definition at line 321 of file BooleanProcessor.h.

m_ifaces2

int BooleanProcessor::m_ifaces2

private

Definition at line 321 of file BooleanProcessor.h.

m_internal_contours

std::vector<int> BooleanProcessor::m_internal_contours

private

Definition at line 333 of file BooleanProcessor.h.

m_iout1

int BooleanProcessor::m_iout1

private

Definition at line 322 of file BooleanProcessor.h.

m_iout2

int BooleanProcessor::m_iout2

private

Definition at line 322 of file BooleanProcessor.h.

m_iunk1

int BooleanProcessor::m_iunk1

private

Definition at line 323 of file BooleanProcessor.h.

m_iunk2

int BooleanProcessor::m_iunk2

private

Definition at line 323 of file BooleanProcessor.h.

m_nodes

std::vector<ExtNode> BooleanProcessor::m_nodes

private

Definition at line 315 of file BooleanProcessor.h.

m_operation

int BooleanProcessor::m_operation

private

Definition at line 320 of file BooleanProcessor.h.

m_processor_error

int BooleanProcessor::m_processor_error

private

Definition at line 319 of file BooleanProcessor.h.

m_result_faces

FaceList BooleanProcessor::m_result_faces

private

Definition at line 327 of file BooleanProcessor.h.

m_rmax

double BooleanProcessor::m_rmax[3]

private

Definition at line 324 of file BooleanProcessor.h.

m_rmin

double BooleanProcessor::m_rmin[3]

private

Definition at line 324 of file BooleanProcessor.h.

m_suitable_faces

FaceList BooleanProcessor::m_suitable_faces

private

Definition at line 328 of file BooleanProcessor.h.

m_unknown_faces

FaceList BooleanProcessor::m_unknown_faces

private

Definition at line 330 of file BooleanProcessor.h.

m_unsuitable_faces

FaceList BooleanProcessor::m_unsuitable_faces

private

Definition at line 329 of file BooleanProcessor.h.

s_ishift

int BooleanProcessor::s_ishift = 0

staticprivate

Definition at line 314 of file BooleanProcessor.h.

---

The documentation for this class was generated from the following file:

• BooleanProcessor.h