Ignore:
Timestamp:
Nov 3, 2009, 11:17:28 AM (16 years ago)
Author:
garnier
Message:

update to CVS

Location:
trunk/source/graphics_reps/src
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • trunk/source/graphics_reps/src/BooleanProcessor.src

    r830 r1140  
    99 ***********************************************************************/
    1010
     11//G.Barrand : begin
     12#define BP_GEANT4
     13
     14#ifdef BP_GEANT4 //G.Barrand
     15
    1116#include <CLHEP/Geometry/Plane3D.h>
    12 
    13 using namespace HepGeom;
     17#include <CLHEP/Geometry/Plane3D.h>
     18typedef HepGeom::Plane3D<double> HVPlane3D;
     19typedef HepGeom::Point3D<double> HVPoint3D;
     20typedef HepGeom::Normal3D<double> HVNormal3D;
     21
     22#else //BP_HEPVIS
     23
     24#define ExtNode          HEPVis_ExtNode
     25#define ExtEdge          HEPVis_ExtEdge
     26#define ExtFace          HEPVis_ExtFace
     27#define FaceList         HEPVis_FaceList
     28#define ExtPolyhedron    HEPVis_ExtPolyhedron
     29#define BooleanProcessor HEPVis_BooleanProcessor
     30
     31#define HepPolyhedron SbPolyhedron
     32#define G4Facet SbFacet
     33
     34#include <HEPVis/SbPlane.h>
     35typedef HEPVis::SbPlane HVPlane3D;
     36
     37#endif
     38
     39//using namespace HepGeom;
     40
     41//#define BP_DEBUG
     42
     43//G.Barrand : end
    1444
    1545#define INITIAL_SIZE 200
    16 #define CRAZY_POINT  Point3D<double>(-10.e+6, -10.e+6, -10.e+6)
    17 #define GRANULARITY  10.e+5;
     46#define CRAZY_POINT  HVPoint3D(-10.e+6, -10.e+6, -10.e+6)
     47//#define GRANULARITY  10.e+5;
     48#define GRANULARITY  10.e+5  //G.Barrand : rm the trailing ;
    1849
    1950#define SWAP(A,B) w = A; A = B; B = w
    … …  
    3667
    3768// -------------------------------------------- Simplified STL vector ---
     69//G.Barrand : begin
     70#include <vector>
     71using namespace std;
     72/*
    3873template<class T>
    3974class vector {
    … …  
    68103  }
    69104};
     105*/
     106//G.Barrand : end
    70107
    71108// ---------------------------------------------------- Extended node ---
    72109class ExtNode {
    73110 public:
    74   Point3D<double> v;
     111  HVPoint3D v;
    75112  int        s;
    76113
    77114 public:
    78   ExtNode(Point3D<double> vertex=Point3D<double>(), int status=0)
     115  ExtNode(HVPoint3D vertex=HVPoint3D(), int status=0)
    79116    : v(vertex), s(status) {}
    80117  ~ExtNode() {}
    … …  
    126163// ---------------------------------------------------- Extended face ---
    127164class ExtFace {
     165 private:
     166  std::vector<ExtEdge>& edges; //G.Barrand
    128167 public:
    129168  int        iedges[4];        // indices of original edges
    130   Plane3D<double> plane;            // face plane
     169  HVPlane3D plane;            // face plane
    131170  double     rmin[3], rmax[3]; // bounding box
    132171  int        iold;             // head of the list of the original edges
    … …  
    136175
    137176 public:
    138   ExtFace(int iedge=0) : iold(iedge), inew(0), iprev(iprev), inext(0) {}
     177  //G.Barrand : ExtFace(int iedge=0) : iold(iedge), inew(0), iprev(iprev), inext(0) {}
     178  ExtFace(std::vector<ExtEdge>& a_edges,int iedge)
     179  : edges(a_edges), iold(iedge), inew(0), iprev(0), inext(0) {
     180    //G.Barrand : initialize arrays to quiet valgrind.
     181   {for (int i=0; i<4; i++) { iedges[i] = 0; }}
     182   {for (int i=0; i<3; i++) { rmin[i] = 0; rmax[i] = 0; }}
     183  }
    139184  ~ExtFace() {}
    140185
    141186  ExtFace(const ExtFace & face) :
     187    edges(face.edges), //G.Barrand
    142188    plane(face.plane), iold(face.iold), inew(face.inew),
    143189    iprev(face.iprev), inext(face.inext)
    … …  
    149195
    150196  ExtFace & operator=(const ExtFace & face) {
     197    //FIXME : edges(face.edges) ???? //G.Barrand
    151198    int i;
    152199    for (i=0; i<4; i++) { iedges[i] = face.iedges[i]; }
    … …  
    164211
    165212// ---------------------------------------------------- Global arrays ---
    166 static vector<ExtNode> nodes;        // vector of nodes
    167 static vector<ExtEdge> edges;        // vector of edges
    168 static vector<ExtFace> faces;        // vector of faces
     213//G.Barrand : MacIntel : crash with g++-4.0.1 with -O on some subtract.
     214//            Anyway static of objects is proved to be not safe.
     215//            We put the below vector as members of BooleanProcessor.
     216//GB static std::vector<ExtNode> nodes;        // vector of nodes
     217//GB static std::vector<ExtEdge> edges;        // vector of edges
     218//GB static std::vector<ExtFace> faces;        // vector of faces
    169219
    170220// ---------------------------------------------------- List of faces ---
    171221class FaceList {
    172222 private:
     223  std::vector<ExtFace>& faces; //G.Barrad : end
     224 private:
    173225  int ihead;
    174226  int ilast;
    175227
    176228 public:
    177   FaceList() : ihead(0), ilast(0) {}
     229  //G.Barrand : FaceList() : ihead(0), ilast(0) {}
     230  FaceList(std::vector<ExtFace>& a_faces) : faces(a_faces),ihead(0),ilast(0) {}
    178231  ~FaceList() {}
    179232
    … …  
    183236  void push_back(int i) {
    184237    if (ilast == 0) { ihead = i; } else { faces[ilast].inext = i; }
    185     faces[i].iprev = ilast;
    186     faces[i].inext = 0;
     238    ExtFace& face = faces[i]; //G.Barrand : optimize.
     239    face.iprev = ilast;
     240    face.inext = 0;
    187241    ilast = i;
    188242  }
    189243
    190244  void remove(int i) {
     245    ExtFace& face = faces[i]; //G.Barrand : optimize.
    191246    if (ihead == i) {
    192       ihead = faces[i].inext;
     247      ihead = face.inext;
    193248    }else{
    194       faces[faces[i].iprev].inext = faces[i].inext;
     249      faces[face.iprev].inext = face.inext;
    195250    }
    196251    if (ilast == i) {
    197       ilast = faces[i].iprev;
     252      ilast = face.iprev;
    198253    }else{
    199       faces[faces[i].inext].iprev = faces[i].iprev;
    200     }
    201     faces[i].iprev = 0;
    202     faces[i].inext = 0;
     254      faces[face.inext].iprev = face.iprev;
     255    }
     256    face.iprev = 0;
     257    face.inext = 0;
    203258  }
    204259};
    … …  
    215270// ----------------------------------------- Boolean processor class ---
    216271class BooleanProcessor {
     272 private:
     273  static int ishift; //G.Barrand
     274  std::vector<ExtNode> nodes;        // vector of nodes //G.Barrand
     275  std::vector<ExtEdge> edges;        // vector of edges //G.Barrand
     276  std::vector<ExtFace> faces;        // vector of faces //G.Barrand
    217277 private:
    218278  int             processor_error;   // is set in case of error
    … …  
    264324
    265325 public:
    266   BooleanProcessor() {}
     326  //G.Barrand : BooleanProcessor() {}
     327  BooleanProcessor() //G.Barrand
     328  :result_faces(faces)
     329  ,suitable_faces(faces)
     330  ,unsuitable_faces(faces)
     331  ,unknown_faces(faces)
     332  {
     333  }
     334
    267335  ~BooleanProcessor() {}
    268336
    269337  HepPolyhedron execute(int op,
    270338                        const HepPolyhedron &a,
    271                         const HepPolyhedron &b);
     339                        const HepPolyhedron &b,
     340                        int& err);
    272341
    273342  void draw();
    … …  
    278347  void print_edge(int);
    279348  int get_processor_error() const {return processor_error;}
     349
     350  void dump(); //G.Barrand
     351  static int get_shift(); //G.Barrand
     352  static void set_shift(int); //G.Barrand
     353  static int get_num_shift(); //G.Barrand
    280354};
    281355
    … …  
    294368  iEprev = 0; iEcur = iold;
    295369  while (iEcur > 0) {
    296     edges[iEcur].invert();
    297     iEnext = edges[iEcur].inext;
    298     edges[iEcur].inext = iEprev;
     370    ExtEdge& edge = edges[iEcur]; //G.Barrand : optimize.
     371    edge.invert();
     372    iEnext = edge.inext;
     373    edge.inext = iEprev;
    299374    iEprev = iEcur;
    300375    iEcur  = iEnext;
    … …  
    304379  iEprev = 0; iEcur = inew;
    305380  while (iEcur > 0) {
    306     edges[iEcur].invert();
    307     iEnext = edges[iEcur].inext;
    308     edges[iEcur].inext = iEprev;
     381    ExtEdge& edge = edges[iEcur]; //G.Barrand : optimize.
     382    edge.invert();
     383    iEnext = edge.inext;
     384    edge.inext = iEprev;
    309385    iEprev = iEcur;
    310386    iEcur  = iEnext;
    … …  
    312388  if (inew > 0) inew = iEprev;
    313389
    314   plane = Plane3D<double>(-plane.a(), -plane.b(), -plane.c(), -plane.d());
     390#ifdef BP_GEANT4 //G.Barrand
     391  plane = HVPlane3D(-plane.a(), -plane.b(), -plane.c(), -plane.d());
     392#else
     393  plane = HVPlane3D(-plane.getNormal(), -plane.getDistanceFromOrigin());
     394#endif
    315395}
    316396
    … …  
    336416  //  }
    337417
    338   Point3D<double> ppp;       
     418  HVPoint3D ppp;       
    339419  for (i=1; i <= p.GetNoVertices(); i++) { 
     420#ifdef BP_GEANT4 //G.Barrand
    340421    ppp = p.GetVertex(i);
    341422    ppp.setX(ppp.x()+dx);
    342423    ppp.setY(ppp.y()+dy);
    343424    ppp.setZ(ppp.z()+dz);
     425#else
     426    ppp = p.GetVertexFast(i);
     427    ppp += HVPoint3D(dx,dy,dz);
     428#endif
    344429    nodes.push_back(ExtNode(ppp));
    345430  }
    … …  
    348433
    349434  for (int iface=1; iface <= p.GetNoFacets(); iface++) {
    350     faces.push_back(ExtFace(edges.size()));
     435    faces.push_back(ExtFace(edges,edges.size()));
    351436
    352437    //   S E T   F A C E   N O D E S
    … …  
    354439    p.GetFacet(iface, nnode, iNodes, iVis, iFaces);
    355440    for (i=0; i<nnode; i++) {
    356       if (iNodes[i] < 1 || iNodes[i] > p.GetNoVertices()) processor_error = 1;
    357       if (iFaces[i] < 1 || iFaces[i] > p.GetNoFacets())   processor_error = 1;
     441      //if (iNodes[i] < 1 || iNodes[i] > p.GetNoVertices()) processor_error = 1;
     442      //if (iFaces[i] < 1 || iFaces[i] > p.GetNoFacets())   processor_error = 1;
     443
     444      if (iNodes[i] < 1 || iNodes[i] > p.GetNoVertices()) { //G.Barrand
     445        processor_error = 1;
     446#ifdef BP_DEBUG
     447        std::cerr
     448          << "BooleanProcessor::takePolyhedron : problem 1."
     449          << std::endl;
     450#endif
     451      }
     452      if (iFaces[i] < 1 || iFaces[i] > p.GetNoFacets()) { //G.Barrand
     453        processor_error = 1;
     454#ifdef BP_DEBUG
     455        std::cerr
     456          << "BooleanProcessor::takePolyhedron : problem 2."
     457          << std::endl;
     458#endif
     459      }
    358460      iNodes[i] += dnode;
    359461      iFaces[i] += dface;
    … …  
    374476    //   S E T   F A C E   M I N - M A X
    375477
     478    ExtFace& face = faces.back();     //G.Barrand : optimize.
    376479    for (i=0; i<3; i++) {
    377       faces.back().rmin[i] = nodes[iNodes[0]].v[i];
    378       faces.back().rmax[i] = nodes[iNodes[0]].v[i];
     480      face.rmin[i] = nodes[iNodes[0]].v[i];
     481      face.rmax[i] = nodes[iNodes[0]].v[i];
    379482    }
    380483    for (i=1; i<nnode; i++) {
     484      ExtNode& node = nodes[iNodes[i]]; //G.Barrand : optimize.
    381485      for (k=0; k<3; k++) {
    382         if (faces.back().rmin[k] > nodes[iNodes[i]].v[k])
    383             faces.back().rmin[k] = nodes[iNodes[i]].v[k];
    384         if (faces.back().rmax[k] < nodes[iNodes[i]].v[k])
    385             faces.back().rmax[k] = nodes[iNodes[i]].v[k];
     486        if (face.rmin[k] > node.v[k])
     487            face.rmin[k] = node.v[k];
     488        if (face.rmax[k] < node.v[k])
     489            face.rmax[k] = node.v[k];
    386490      }
    387491    }
    … …  
    389493    //   S E T   F A C E   P L A N E
    390494
    391     Normal3D<double> n = (nodes[iNodes[2]].v-nodes[iNodes[0]].v).cross
     495    HVNormal3D n = (nodes[iNodes[2]].v-nodes[iNodes[0]].v).cross
    392496                    (nodes[iNodes[3]].v-nodes[iNodes[1]].v);
    393     Point3D<double>  p(0,0,0);
     497    HVPoint3D  p(0,0,0);
    394498   
    395499    for (i=0; i<nnode; i++) { p += nodes[iNodes[i]].v; }
    396500    p *= (1./nnode);
    397     faces.back().plane = Plane3D<double>(n.unit(), p);
     501    //G.Barrand : faces.back().plane = HVPlane3D(n.unit(), p);
     502    faces.back().plane = HVPlane3D(n, p); //G.Barrand
    398503
    399504    //   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
    … …  
    431536  iface = faces[ifaces1].inext;
    432537  while(iface > 0) {
     538    ExtFace& face = faces[iface]; //G.Barrand
    433539    for (i=0; i<3; i++) {
    434       if (rmin1[i] > faces[iface].rmin[i]) rmin1[i] = faces[iface].rmin[i];
    435       if (rmax1[i] < faces[iface].rmax[i]) rmax1[i] = faces[iface].rmax[i];
    436     }
    437     iface = faces[iface].inext;
     540      if (rmin1[i] > face.rmin[i]) rmin1[i] = face.rmin[i];
     541      if (rmax1[i] < face.rmax[i]) rmax1[i] = face.rmax[i];
     542    }
     543    iface = face.inext;
    438544  }
    439545
    440546  iface = faces[ifaces2].inext;
    441547  while(iface > 0) {
     548    ExtFace& face = faces[iface]; //G.Barrand
    442549    for (i=0; i<3; i++) {
    443       if (rmin2[i] > faces[iface].rmin[i]) rmin2[i] = faces[iface].rmin[i];
    444       if (rmax2[i] < faces[iface].rmax[i]) rmax2[i] = faces[iface].rmax[i];
    445     }
    446     iface = faces[iface].inext;
     550      if (rmin2[i] > face.rmin[i]) rmin2[i] = face.rmin[i];
     551      if (rmax2[i] < face.rmax[i]) rmax2[i] = face.rmax[i];
     552    }
     553    iface = face.inext;
    447554  }
    448555
    … …  
    476583{
    477584  int i, outflag, iface = ifaces, *prev;
    478   Point3D<double> mmbox[8] = { Point3D<double>(rmin[0],rmin[1],rmin[2]),
    479                                Point3D<double>(rmax[0],rmin[1],rmin[2]),
    480                                Point3D<double>(rmin[0],rmax[1],rmin[2]),
    481                                Point3D<double>(rmax[0],rmax[1],rmin[2]),
    482                                Point3D<double>(rmin[0],rmin[1],rmax[2]),
    483                                Point3D<double>(rmax[0],rmin[1],rmax[2]),
    484                                Point3D<double>(rmin[0],rmax[1],rmax[2]),
    485                                Point3D<double>(rmax[0],rmax[1],rmax[2]) };
     585  HVPoint3D mmbox[8] = { HVPoint3D(rmin[0],rmin[1],rmin[2]),
     586                               HVPoint3D(rmax[0],rmin[1],rmin[2]),
     587                               HVPoint3D(rmin[0],rmax[1],rmin[2]),
     588                               HVPoint3D(rmax[0],rmax[1],rmin[2]),
     589                               HVPoint3D(rmin[0],rmin[1],rmax[2]),
     590                               HVPoint3D(rmax[0],rmin[1],rmax[2]),
     591                               HVPoint3D(rmin[0],rmax[1],rmax[2]),
     592                               HVPoint3D(rmax[0],rmax[1],rmax[2]) };
    486593  prev = &ifaces;
    487594  while (iface > 0) {
    … …  
    490597
    491598    outflag = 0;
     599    ExtFace& face = faces[iface]; //G.Barrand : optimize.
    492600    for (i=0; i<3; i++) {
    493       if (faces[iface].rmin[i] > rmax[i] + del) { outflag = 1; break; }
    494       if (faces[iface].rmax[i] < rmin[i] - del) { outflag = 1; break; }
     601      if (face.rmin[i] > rmax[i] + del) { outflag = 1; break; }
     602      if (face.rmax[i] < rmin[i] - del) { outflag = 1; break; }
    495603    }
    496604
    … …  
    501609      double d;
    502610      for (i=0; i<8; i++) {
    503         d = faces[iface].plane.distance(mmbox[i]);
     611        d = face.plane.distance(mmbox[i]); //G.Barrand : optimize
    504612        if (d > +del) npos++;
    505613        if (d < -del) nneg++;
    … …  
    511619
    512620    if (outflag == 1) {
    513       *prev = faces[iface].inext;
    514       faces[iface].inext = iout;
     621      *prev = face.inext;
     622      face.inext = iout;
    515623      iout = iface;
    516624    }else{
    517       prev = &faces[iface].inext;
    518     }
     625      prev = &face.inext;
     626    }
     627
    519628    iface = *prev;
    520629  }
    … …  
    532641{
    533642  int        iface = edge.iface1;
    534   Plane3D<double> plane = faces[edge.iface2].plane;
     643  HVPlane3D plane = faces[edge.iface2].plane;
    535644  int        i, nnode, npos = 0, nneg = 0, nzer = 0;
    536645  double     dd[5];
    … …  
    599708        i1 = edges[iedge].i1;
    600709        i2 = edges[iedge].i2;
     710   
    601711        d1 = plane.distance(nodes[i1].v);
    602712        d2 = plane.distance(nodes[i2].v);
    … …  
    610720        iedge = edges[iedge].inext;
    611721      }
    612       if (ii[i] == nodes.size()) {
     722      if (ii[i] == (int)nodes.size()) {
    613723        dd = d2-d1; d1 = d1/dd; d2 = d2/dd;
    614724        nodes.push_back(ExtNode(d2*nodes[i1].v-d1*nodes[i2].v, iedge));
    … …  
    795905{
    796906  processor_error = 1;
     907#ifdef BP_DEBUG
    797908  std::cout
    798909    << "BooleanProcessor::caseIE : unimplemented case"
    799910    << std::endl;
     911#endif
    800912}
    801913
    … …  
    811923{
    812924  processor_error = 1;
     925#ifdef BP_DEBUG
    813926  std::cout
    814927    << "BooleanProcessor::caseEE : unimplemented case"
    815928    << std::endl;
     929#endif
    816930}
    817931
    … …  
    831945  //   M I N - M A X
    832946
     947 {const ExtFace& face_1 = faces[iface1]; //G.Barrand : optimize
     948  const ExtFace& face_2 = faces[iface2];
    833949  for (int i=0; i<3; i++) {
    834     if (faces[iface1].rmin[i] > faces[iface2].rmax[i] + del) return;
    835     if (faces[iface1].rmax[i] < faces[iface2].rmin[i] - del) return;
    836   }
     950    if (face_1.rmin[i] > face_2.rmax[i] + del) return;
     951    if (face_1.rmax[i] < face_2.rmin[i] - del) return;
     952  }}
    837953
    838954  //   F A C E - 1   vs   P L A N E - 2
    … …  
    9291045*ilink = A; ilink = &edges[A].inext; *ilink = 0
    9301046
     1047  ExtFace& face = faces[iface]; //G.Barrand : optimize.
    9311048  ilink = &ihead;
    9321049  for(;;) {
    933     if (faces[iface].inew == 0) break;
     1050    if (face.inew == 0) break;
    9341051
    9351052    //   S T A R T   N E W   C O N T O U R
    9361053
    937     icur   = faces[iface].inew;
    938     faces[iface].inew = edges[icur].inext;
     1054    icur   = face.inew;
     1055    face.inew = edges[icur].inext;
    9391056    INSERT_EDGE_TO_THE_LIST(icur);
    9401057    ifirst = edges[icur].i1;
    … …  
    9431060
    9441061    for (;;) {
    945       i = &faces[iface].inew;
     1062      i = &face.inew;
     1063      ExtEdge& edge_cur = edges[icur];
    9461064      while(*i > 0) {
    947         if (edges[*i].i1 == edges[icur].i2) break;
    948         i = &edges[*i].inext;
     1065        ExtEdge& edge_i = edges[*i];
     1066        if (edge_i.i1 == edge_cur.i2) break;
     1067        i = &edge_i.inext;
    9491068      }
    9501069      if (*i == 0) {
    951         i = &faces[iface].iold;
    952         while(*i > 0) {
    953           if (edges[*i].i1 == edges[icur].i2) ioldflag = 1;
    954           if (edges[*i].i1 == edges[icur].i2) break;
    955           i = &edges[*i].inext;
     1070        i = &face.iold;   
     1071        while(*i > 0) {       
     1072          ExtEdge& edge_i = edges[*i];
     1073          if (edge_i.i1 == edge_cur.i2) {
     1074            ioldflag = 1;
     1075            break;
     1076          }
     1077          i = &edge_i.inext;
    9561078        }
    9571079      }
    … …  
    9631085      }else{
    9641086        processor_error = 1;
     1087#ifdef BP_DEBUG
    9651088        std::cerr
    9661089          << "BooleanProcessor::assembleFace(" << iface << ") : "
    9671090          << "could not find next edge of the contour"
    9681091          << std::endl;
    969         faces[iface].inew = DEFECTIVE_FACE;
     1092#endif
     1093        face.inew = DEFECTIVE_FACE;
    9701094        return;
    9711095      }
    … …  
    9761100
    9771101  int iedge;
    978   iedge = faces[iface].iold;
     1102  iedge = face.iold;
    9791103  if (what == 0 && ioldflag == 0 && iedge > 0) {
    9801104    for (;;) {
    … …  
    9861110        }
    9871111      }else{
    988         if (edges[iedge].i2 == edges[faces[iface].iold].i1) {
     1112        if (edges[iedge].i2 == edges[face.iold].i1) {
    9891113          edges[iedge].inext = ihead;   // set new face
    9901114          return;
    … …  
    9991123
    10001124  int iface2;
    1001   iedge = faces[iface].iold;
     1125  iedge = face.iold;
    10021126  while(iedge > 0) {
    10031127    iface2 = edges[iedge].iface2;
    … …  
    10051129    iedge = edges[iedge].inext;
    10061130  }
    1007   faces[iface].iold = ihead;            // set new face
     1131  face.iold = ihead;            // set new face
    10081132}
    10091133
    … …  
    11861310    unsuitable_faces.remove(i);
    11871311  }
     1312
     1313  //G.Barrand : begin
     1314  /* From S.Ponce
     1315   At last, there is a problem in the assemblePolyhedra method. At least, I
     1316  think it is there. The problem deals with boolean operations on solids,
     1317  when one of the two contains entirely the other one. It has no sense for
     1318  intersection and union but still has sense for subtraction. In this
     1319  case, faces from the inner solid are stored in the unknown_faces
     1320  FaceList. And an error occurs in the execute method. This may be correct
     1321  for intersection and union but in the case of subtraction, one should do
     1322  that in assemblePolyhedra :
     1323  */
     1324  //   Unknown faces are actually suitable face !!!
     1325   iface = unknown_faces.front();
     1326   while(iface > 0) {
     1327     i = iface;
     1328     faces[i].inew = ORIGINAL_FACE;
     1329     iface = faces[i].inext;
     1330     unknown_faces.remove(i);
     1331     result_faces.push_back(i);
     1332   }
     1333  /*
     1334   Otherwise, the inner hole that the second solid was building in the
     1335  first one does not exist. I'm not very clear on what to do for unions
     1336  and intersections. I think this kind of situation should be detected and
     1337  one of the solid should simply be ignored.
     1338  */
     1339  //G.Barrand : end
    11881340}
    11891341
    … …  
    12031355  a  = y1 - y2;
    12041356  b  = x2 - x1;
    1205   w  = std::abs(a)+std::abs(b);
     1357  //G.Barrand : w  = std::abs(a)+std::abs(b);
     1358  w  = ::fabs(a)+::fabs(b); //G.Barrand
    12061359  a /= w;
    12071360  b /= w;
    … …  
    12681421  int icontour, iedge, k1, k2;
    12691422  double x3, y3, x4, y4, a2, b2, c2, d1, d2;
    1270   for(icontour=0; icontour<external_contours.size(); icontour++) {
     1423  for(icontour=0; icontour<(int)external_contours.size(); icontour++) {
    12711424    iedge = external_contours[icontour];
    12721425    while(iedge > 0) {
    … …  
    12961449  //  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
    12971450
    1298   for(icontour=0; icontour<internal_contours.size(); icontour++) {
     1451  for(icontour=0; icontour<(int)internal_contours.size(); icontour++) {
    12991452    iedge = internal_contours[icontour];
    13001453    while(iedge > 0) {
    … …  
    14781631  //   L O O P   A L O N G   C O N T O U R 
    14791632
     1633  //std::cerr << "debug : contour : begin : =================" << std::endl;
     1634  //dump();//debug
     1635
    14801636  int iedge1, iedge2, iedge3, istart = 0;
    14811637  for (;;) {
    14821638    iedge1 = edges[ipnext].inext;
    14831639    iedge2 = edges[iedge1].inext;
     1640/*
     1641    std::cerr << "debug :"
     1642              << " ipnext " << ipnext
     1643              << " iedge1 " << iedge1
     1644              << " iedge2 " << iedge2
     1645              << " : istart " << istart
     1646              << std::endl;
     1647*/
    14841648    if (istart == 0) {
    14851649      istart = iedge1;
    … …  
    14901654        edges[iedge3].iface1 = faces.size();
    14911655        edges[iedge3].inext = 0;
    1492         faces.push_back(ExtFace());
     1656        faces.push_back(ExtFace(edges,0)); //G.Barrand : ok ?
    14931657        faces.back().iold = iedge1;
    14941658        faces.back().inew = ORIGINAL_FACE;
    … …  
    15001664    }else if (istart == iedge1) {
    15011665      processor_error = 1;
     1666#ifdef BP_DEBUG
    15021667      std::cerr
    15031668        << "BooleanProcessor::triangulateContour : "
    15041669        << "could not generate a triangle (infinite loop)"
    15051670        << std::endl;
     1671#endif
    15061672      break;
    15071673    }
    … …  
    15291695    edges[iedge2].inext = edges.size();
    15301696    edges.push_back(ExtEdge(i3, i1, iface2, -(edges.size()-1), -1));
    1531     faces.push_back(ExtFace());
     1697    faces.push_back(ExtFace(edges,0)); //G.Barrand : ok ?
    15321698    faces.back().iold   = iedge1;
    15331699    faces.back().inew   = ORIGINAL_FACE;
    … …  
    15621728  }
    15631729  processor_error = 1;
     1730#ifdef BP_DEBUG
    15641731  std::cerr
    15651732    << "BooleanProcessor::modifyReference : could not find the edge, "
    15661733    << "iface=" << iface << ", i1,i2=" << i1 << "," << i2 << ", iref=" << iref
    15671734    << std::endl;
     1735#endif
    15681736}
    15691737
    … …  
    15821750  //   S E T  IX, IY, IZ
    15831751
    1584   Normal3D<double> normal = faces[iface].plane.normal();
     1752#ifdef BP_GEANT4 //G.Barrand
     1753  HVNormal3D normal = faces[iface].plane.normal();
     1754#else
     1755  const HVNormal3D& normal = faces[iface].plane.getNormal();
     1756#endif
    15851757  int ix, iy, iz = 0;
    1586   if (std::abs(normal[1]) > std::abs(normal[iz])) iz = 1;
    1587   if (std::abs(normal[2]) > std::abs(normal[iz])) iz = 2;
     1758  //G.Barrand : if (std::abs(normal[1]) > std::abs(normal[iz])) iz = 1;
     1759  //G.Barrand : if (std::abs(normal[2]) > std::abs(normal[iz])) iz = 2;
     1760  if (::fabs(normal[1]) > ::fabs(normal[iz])) iz = 1; //G.Barrand
     1761  if (::fabs(normal[2]) > ::fabs(normal[iz])) iz = 2; //G.Barrand
    15881762  if (normal[iz] > 0) {
    15891763    ix = (iz+1)%3; iy = (ix+1)%3;
    … …  
    16061780        i1 = edges[iedge].i1;
    16071781        i2 = edges[iedge].i2;
    1608         z += nodes[i1].v[ix]*nodes[i2].v[iy]-nodes[i2].v[ix]*nodes[i1].v[iy];
     1782        ExtNode& node_1 = nodes[i1];
     1783        ExtNode& node_2 = nodes[i2];
     1784        z += node_1.v[ix]*node_2.v[iy]-node_2.v[ix]*node_1.v[iy];
    16091785        if (ifirst != i2) {
    16101786          iedge = edges[iedge].inext;
    … …  
    16171793          }else{ 
    16181794            processor_error = 1;
     1795#ifdef BP_DEBUG
    16191796            std::cerr
    16201797              << "BooleanProcessor::triangulateFace : too small contour"
    16211798              << std::endl;
     1799#endif
    16221800          }
    16231801          icontour = edges[iedge].inext;
    … …  
    16271805      }else{
    16281806        processor_error = 1;
     1807#ifdef BP_DEBUG
    16291808        std::cerr
    16301809          << "BooleanProcessor::triangulateFace : broken contour"
    16311810          << std::endl;
     1811#endif
    16321812        icontour = 0;
    16331813        break;
    … …  
    16391819
    16401820  int kint, kext;
    1641   for (kint=0; kint < internal_contours.size(); kint++) {
    1642     for (kext=0; kext < external_contours.size(); kext++) {
     1821  for (kint=0; kint < (int)internal_contours.size(); kint++) {
     1822    for (kext=0; kext < (int)external_contours.size(); kext++) {
    16431823      mergeContours(ix, iy, kext, kint);
    16441824      if (internal_contours[kint] == 0) break;
    16451825    }
    1646     if (kext == external_contours.size()) {
     1826    if (kext == (int)external_contours.size()) {
    16471827      processor_error = 1;
     1828#ifdef BP_DEBUG
    16481829      std::cerr
    16491830        << "BooleanProcessor::triangulateFace : "
    16501831        << "could not merge internal contour " << kint
    16511832        << std::endl;
     1833#endif
    16521834    }     
    16531835  }
    … …  
    16561838
    16571839  int nface = faces.size();
    1658   for (kext=0; kext < external_contours.size(); kext++) {
     1840  for (kext=0; kext < (int)external_contours.size(); kext++) {
    16591841    triangulateContour(ix, iy, external_contours[kext]);
     1842#ifdef BP_DEBUG
     1843    if(processor_error) { //G.Barrand
     1844      std::cerr
     1845        << "BooleanProcessor::triangulateFace : "
     1846        << "triangulateContour failed."
     1847        << std::endl;
     1848      break; //G.Barrand : ok ?
     1849    }
     1850#endif     
    16601851  }
    16611852  faces[iface].inew = UNSUITABLE_FACE;
    … …  
    16631854  //   M O D I F Y   R E F E R E N C E S
    16641855
    1665   for (int ifa=nface; ifa<faces.size(); ifa++) {
     1856  for (int ifa=nface; ifa<(int)faces.size(); ifa++) {
    16661857    iedge = faces[ifa].iold;
    16671858    while (iedge > 0) {
    16681859      if (edges[iedge].iface1 != ifa) {
    16691860        processor_error = 1;
     1861#ifdef BP_DEBUG
    16701862        std::cerr
    16711863          << "BooleanProcessor::triangulateFace : wrong reference to itself, "
    16721864          << "iface=" << ifa << ", iface1=" << edges[iedge].iface1
    16731865          << std::endl;
     1866#endif
    16741867      }else if (edges[iedge].iface2 > 0) {
    16751868        modifyReference(edges[iedge].iface2,
    … …  
    16971890  //   R E N U M E R A T E   N O D E S   A N D   F A C E S
    16981891
    1699   for (i=1; i<nodes.size(); i++) nodes[i].s = 0;
    1700 
    1701   for (i=1; i<faces.size(); i++) {
     1892  for (i=1; i<(int)nodes.size(); i++) nodes[i].s = 0;
     1893
     1894  for (i=1; i<(int)faces.size(); i++) {
    17021895    if (faces[i].inew == ORIGINAL_FACE) {
    17031896      faces[i].inew = ++nface;
    … …  
    17121905  }
    17131906
    1714   for (i=1; i<nodes.size(); i++) {
     1907  for (i=1; i<(int)nodes.size(); i++) {
    17151908    if (nodes[i].s == 1) nodes[i].s = ++nnode;
    17161909  }
    … …  
    17241917  //   S E T   N O D E S
    17251918
    1726   for (i=1; i<nodes.size(); i++) {
     1919  for (i=1; i<(int)nodes.size(); i++) {
    17271920    if (nodes[i].s != 0)  polyhedron.pV[nodes[i].s] = nodes[i].v;
    17281921  }
    … …  
    17311924
    17321925  int k, v[4], f[4];
    1733   for (i=1; i<faces.size(); i++) {
     1926  for (i=1; i<(int)faces.size(); i++) {
    17341927    if (faces[i].inew == 0) continue;
    17351928    v[3] = f[3] = k = 0;
    … …  
    17551948    }
    17561949    polyhedron.pF[faces[i].inew] =
    1757       G4Facet(v[0],f[0], v[1],f[1], v[2],f[2], v[3],f[3]);
     1950      G4Facet(v[0],f[0], v[1],f[1], v[2],f[2], v[3],f[3]); 
    17581951  }
    17591952  return polyhedron;
    17601953}
     1954
     1955int BooleanProcessor::ishift = 0; //G.Barrand
     1956int BooleanProcessor::get_shift() { return ishift;} //G.Barrand
     1957void BooleanProcessor::set_shift(int a_shift) { ishift = a_shift;} //G.Barrand
     1958#define NUM_SHIFT 8
     1959int BooleanProcessor::get_num_shift() { return NUM_SHIFT;} //G.Barrand
    17611960
    17621961HepPolyhedron BooleanProcessor::execute(int op,
    17631962                                        const HepPolyhedron & a,
    1764                                         const HepPolyhedron & b)
     1963                                        const HepPolyhedron & b,
     1964                                        int& err) //G.Barrand
    17651965/***********************************************************************
    17661966 *                                                                     *
    … …  
    17721972 ***********************************************************************/
    17731973{
    1774   static int ishift = 0;
    1775   static double shift[8][3] = {
     1974  //static int ishift = 0; //G.Barrand
     1975  //static double shift[8][3] = {
     1976  static double shift[NUM_SHIFT][3] = { //G.Barrand
    17761977    {  31,  23,  17},
    17771978    { -31, -23, -17},
    … …  
    17841985  };           
    17851986
     1987/*
     1988  std::cerr << "BooleanProcessor::execute : ++++++++++++++++++++++"
     1989            << a.getName().getString()
     1990            << b.getName().getString()
     1991            << std::endl;
     1992*/
     1993
    17861994  //   I N I T I A T E   P R O C E S S O R
    17871995
    … …  
    17901998  nodes.clear(); nodes.push_back(CRAZY_POINT);
    17911999  edges.clear(); edges.push_back(ExtEdge());
    1792   faces.clear(); faces.push_back(ExtFace());
     2000  faces.clear(); faces.push_back(ExtFace(edges,0)); //G.Barrand : ok ?
    17932001
    17942002  //   T A K E   P O L Y H E D R A
    … …  
    18012009      << "BooleanProcessor: corrapted input polyhedron"
    18022010      << std::endl;
     2011    err = processor_error; //G.Barrand
    18032012    return HepPolyhedron();
    18042013  }
    18052014  if (ifaces1 == ifaces2) {          // a is empty
     2015    err = processor_error; //G.Barrand
    18062016    switch (operation) {
    18072017    case OP_UNION:
    … …  
    18192029    }
    18202030  }
    1821   if (ifaces2 == faces.size()) {     // b is empty
     2031  if (ifaces2 == (int)faces.size()) {     // b is empty
     2032    err = processor_error; //G.Barrand
    18222033    switch (operation) {
    18232034    case OP_UNION:
    … …  
    18392050  //   W O R K A R O U N D   T O   A V O I D   I E   A N D   E E
    18402051         
     2052/*
     2053#define PROCESSOR_ERROR(a_what) \
     2054  std::cerr << "BooleanProcessor: boolean operation problem (" << a_what \
     2055            << "). Try again with other shifts."\
     2056            << std::endl;
     2057*/
     2058#define PROCESSOR_ERROR(a_what)
     2059
     2060  unsigned int try_count = 1;
     2061  while(true) { //G.Barrand
     2062
    18412063  double ddxx = del*shift[ishift][0];
    18422064  double ddyy = del*shift[ishift][1];
    18432065  double ddzz = del*shift[ishift][2];
    1844   ishift++; if (ishift == 8) ishift = 0;
    1845 
     2066  ishift++; if (ishift == get_num_shift()) ishift = 0;
     2067
     2068  processor_error = 0; //G.Barrand
    18462069  operation = op;
    18472070  nodes.clear(); nodes.push_back(CRAZY_POINT);
    18482071  edges.clear(); edges.push_back(ExtEdge());
    1849   faces.clear(); faces.push_back(ExtFace());
     2072  faces.clear(); faces.push_back(ExtFace(edges,0)); //G.Barrand : ok ?
    18502073
    18512074  ifaces1 = faces.size(); takePolyhedron(a,0,0,0);
    18522075  ifaces2 = faces.size(); takePolyhedron(b,ddxx,ddyy,ddzz);
     2076
     2077  if (processor_error) { PROCESSOR_ERROR(1) } //G.Barrand
    18532078
    18542079  del = findMinMax();
    … …  
    18592084  selectOutsideFaces(ifaces1, iout1);
    18602085  selectOutsideFaces(ifaces2, iout2);
     2086
     2087  if (processor_error) { PROCESSOR_ERROR(2) } //G.Barrand
    18612088
    18622089  //   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
    … …  
    18752102  }
    18762103
    1877 #define PROCESSOR_ERROR \
    1878 std::cerr << "BooleanProcessor: boolean operation failed" << std::endl;\
    1879 return a;
     2104  if (processor_error) { PROCESSOR_ERROR(3) } //G.Barrand
    18802105
    18812106  //   F I N D   N E W   E D G E S
    … …  
    18922117    }
    18932118  }
    1894   if (processor_error) { PROCESSOR_ERROR }
     2119  if (processor_error) { PROCESSOR_ERROR(4) } //G.Barrand
    18952120
    18962121  //   C O N S T R U C T   N E W   F A C E S
    18972122
    18982123  assembleNewFaces((operation == OP_INTERSECTION) ? 1 : 0, ifaces1);
    1899   if (processor_error) { PROCESSOR_ERROR }
     2124  if (processor_error) { PROCESSOR_ERROR(5) } //G.Barrand
    19002125  assembleNewFaces((operation == OP_UNION) ? 0 : 1, ifaces2);
    1901   if (processor_error) { PROCESSOR_ERROR }
     2126  if (processor_error) { PROCESSOR_ERROR(6) } //G.Barrand
    19022127
    19032128  //   A S S E M B L E   S U I T A B L E   F A C E S
    … …  
    19082133    if (unknown_faces.front() != 0) {
    19092134      processor_error = 1;
     2135#ifdef BP_DEBUG
    19102136      std::cerr
    19112137        << "BooleanProcessor::execute : unknown faces !!!"
    19122138        << std::endl;
     2139#endif
    19132140    }
    19142141    break;
    19152142  }
    1916   if (processor_error) { PROCESSOR_ERROR }
     2143  if (processor_error) { PROCESSOR_ERROR(7) } //G.Barrand
    19172144
    19182145  //   T R I A N G U L A T E   A C C E P T E D   F A C E S
    … …  
    19232150    ifa1 = faces[ifa2].inext;
    19242151    if (faces[ifa2].inew == NEW_FACE) triangulateFace(ifa2);
    1925     if (processor_error) { PROCESSOR_ERROR }
    1926   }
     2152    if (processor_error) {
     2153      PROCESSOR_ERROR(8) //G.Barrand
     2154      break; //G.Barrand
     2155    }
     2156  }
     2157
     2158  if(!processor_error) {   
     2159#ifdef BP_DEBUG
     2160    if(try_count!=1) {
     2161      std::cerr
     2162         << "BooleanProcessor::execute : had converged."
     2163         << std::endl;
     2164    }
     2165#endif
     2166    break;
     2167  }
     2168
     2169  if((int)try_count>get_num_shift()) {
     2170#ifdef BP_DEBUG
     2171    std::cerr << "BooleanProcessor: "
     2172              << " all shifts tried. Boolean operation (" << op << ") failure."
     2173              << " a name \"" << a.getName().getString() << "\""
     2174              << " b name \"" << b.getName().getString() << "\""
     2175              << std::endl;
     2176#endif
     2177    err = processor_error;
     2178    return a;
     2179  }
     2180
     2181#ifdef BP_DEBUG
     2182  std::cerr
     2183     << "BooleanProcessor::execute : try another tilt..."
     2184     << std::endl;
     2185#endif
     2186
     2187  try_count++;
     2188
     2189  } //G.Barrand : end while shift.
     2190#undef PROCESSOR_ERROR //G.Barrand
    19272191
    19282192  //   C R E A T E   P O L Y H E D R O N
    19292193 
     2194  err = processor_error;
    19302195  return createPolyhedron();
    19312196}
    … …  
    21492414}
    21502415*/
     2416
     2417void BooleanProcessor::dump() {//G.Barrand
     2418  unsigned int number = nodes.size();
     2419  std::cout << "nodes : " << number << endl;
     2420  for(unsigned int index=0;index<number;index++) {
     2421    const ExtNode& node = nodes[index];
     2422    std::cout << " " << index
     2423              << " x = " << node.v[0]
     2424              << " y = " << node.v[1]
     2425              << " z = " << node.v[2]
     2426              << std::endl;
     2427  }
     2428}

  • trunk/source/graphics_reps/src/HepPolyhedron.cc

    r1058 r1140  
    2525//
    2626//
    27 // $Id: HepPolyhedron.cc,v 1.32 2008/11/13 09:05:27 gcosmo Exp $
    28 // GEANT4 tag $Name: geant4-09-02-ref-02 $
     27// $Id: HepPolyhedron.cc,v 1.34 2009/10/28 13:36:32 allison Exp $
     28// GEANT4 tag $Name: $
    2929//
    3030//
    … …  
    22552255
    22562256#include "BooleanProcessor.src"
    2257 static BooleanProcessor processor;
    22582257
    22592258HepPolyhedron HepPolyhedron::add(const HepPolyhedron & p) const
    … …  
    22672266 ***********************************************************************/
    22682267{
    2269   return processor.execute(OP_UNION, *this, p);
     2268  int ierr;
     2269  BooleanProcessor processor;
     2270  return processor.execute(OP_UNION, *this, p,ierr);
    22702271}
    22712272
    … …  
    22802281 ***********************************************************************/
    22812282{
    2282   return processor.execute(OP_INTERSECTION, *this, p);
     2283  int ierr;
     2284  BooleanProcessor processor;
     2285  return processor.execute(OP_INTERSECTION, *this, p,ierr);
    22832286}
    22842287
    … …  
    22932296 ***********************************************************************/
    22942297{
    2295   return processor.execute(OP_SUBTRACTION, *this, p);
    2296 }
    2297 
    2298 bool HepPolyhedron::IsErrorBooleanProcess() const {
    2299   return processor.get_processor_error();
    2300 }
     2298  int ierr;
     2299  BooleanProcessor processor;
     2300  return processor.execute(OP_SUBTRACTION, *this, p,ierr);
     2301}
     2302
     2303//NOTE : include the code of HepPolyhedronProcessor here
     2304//       since there is no BooleanProcessor.h
     2305
     2306#undef INTERSECTION
     2307
     2308#include "HepPolyhedronProcessor.src"
     2309
Note: See TracChangeset for help on using the changeset viewer.