ATLAS Offline Software
SoPolyhedron.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
3 */
4 
6 // //
7 // Header file for class SoPolyhedron //
8 // //
9 // Author: Thomas H. Kittelmann (Thomas.Kittelmann@cern.ch) //
10 // //
11 // Initial version: November 2008 //
12 // //
13 // Update: Giorgi Gvaberidze (ggvaberi@cern.ch) //
14 // November 2010 //
15 // //
16 // Riccardo-Maria BIANCHI (rbianchi@cern.ch) //
17 // 13.12.2012 //
18 // //
20 
21 #include <VP1HEPVis/nodes/SoPolyhedron.h>
22 
23 #include <Inventor/SbBox.h>
24 #include <Inventor/actions/SoAction.h>
25 #include <Inventor/actions/SoPickAction.h>
26 #include <Inventor/SoPrimitiveVertex.h>
27 #include <Inventor/elements/SoTextureCoordinateElement.h>
28 #include <Inventor/elements/SoGLCacheContextElement.h>
29 
30 #include <Inventor/nodes/SoSeparator.h>
31 #include <Inventor/nodes/SoIndexedFaceSet.h>
32 #include <Inventor/nodes/SoVertexProperty.h>
33 
34 #include <Inventor/C/glue/gl.h>
35 
36 #include "SbMath.h"
37 #include <VP1HEPVis/SbPolyhedron.h>
38 
40 //#include "VP1Base/VP1Msg.h"
41 //#include <QString>
42 
43 
44 SO_NODE_SOURCE(SoPolyhedron)
45 
46 //____________________________________________________________________
47 void SoPolyhedron::initClass()
48 {
49  [[maybe_unused]] static const bool didInit = [&]() {
50  SO_NODE_INIT_CLASS(SoPolyhedron,SoShape,"Shape");
51  return true;
52  }();
53 }
54 
56 SoPolyhedron::SoPolyhedron(
57 )
58 :m_polyhedron(0), m_vertices(0), m_indices(0), m_vcount(0), m_icount(0)
61 {
62  SO_NODE_CONSTRUCTOR(SoPolyhedron);
63  // SO_NODE_ADD_FIELD(solid,(TRUE));
64  // SO_NODE_ADD_FIELD(reducedWireFrame,(TRUE));
65  SO_NODE_ADD_FIELD(alternateRep,(NULL));
66  setNodeType(EXTENSION);
67 }
69 SoPolyhedron::SoPolyhedron(
70  const SbPolyhedron& aPolyhedron
71 )
72 :m_polyhedron(0), m_vertices(0), m_indices(0), m_vcount(0), m_icount(0)
75 {
76  SO_NODE_CONSTRUCTOR(SoPolyhedron);
77  // SO_NODE_ADD_FIELD(solid,(TRUE));
78  // SO_NODE_ADD_FIELD(reducedWireFrame,(TRUE));
79  SO_NODE_ADD_FIELD(alternateRep,(NULL));
80 
81  m_polyhedron = new SbPolyhedron(aPolyhedron);
82  setNodeType(EXTENSION);
83  makeShape(m_polyhedron);
84 }
86 SoPolyhedron::SoPolyhedron(
87  const SbPolyhedron* aPolyhedron
88 )
89 :m_polyhedron(0), m_vertices(0), m_indices(0), m_vcount(0), m_icount(0)
92 {
93  SO_NODE_CONSTRUCTOR(SoPolyhedron);
94  // SO_NODE_ADD_FIELD(solid,(TRUE));
95  // SO_NODE_ADD_FIELD(reducedWireFrame,(TRUE));
96  SO_NODE_ADD_FIELD(alternateRep,(NULL));
97 
98  m_polyhedron = new SbPolyhedron(*aPolyhedron);
99  setNodeType(EXTENSION);
100  makeShape(m_polyhedron);
101 }
103 SoPolyhedron::~SoPolyhedron(
104 )
107 {
108  delete m_polyhedron;
109  if(m_vertices)
110  delete [] m_vertices;
111  if(m_indices)
112  delete [] m_indices;
113 }
115 void SoPolyhedron::generatePrimitives(
116  SoAction* aAction
117 )
120 {
121  if(!m_polyhedron) return;
122  if(m_polyhedron->GetNoFacets()<=0) return; // Abnormal polyhedron.
123 
124  SoState *state = aAction->getState();
125  if (!state)
126  return;
127  SbBool useTexFunction =
128  (SoTextureCoordinateElement::getType(state) ==
129  SoTextureCoordinateElement::FUNCTION);
130  const SoTextureCoordinateElement *tce = NULL;
131  SbVec4f texCoord;
132  if (useTexFunction) {
133  tce = SoTextureCoordinateElement::getInstance(state);
134  } else {
135  texCoord[2] = 0.0;
136  texCoord[3] = 1.0;
137  }
138 
139  // if(solid.getValue()==TRUE) {
140  if(true) {
141  SoPrimitiveVertex pv;
142  SbVec3f point, normal;
144  //----------------------------------------
145 #define GEN_VERTEX(pv,x,y,z,s,t,nx,ny,nz) \
146  point.setValue(x,y,z); \
147  normal.setValue(nx,ny,nz); \
148  if (useTexFunction) { \
149  texCoord=tce->get(point,normal); \
150  } else { \
151  texCoord[0]=s; \
152  texCoord[1]=t; \
153  } \
154  pv.setPoint(point); \
155  pv.setNormal(normal); \
156  pv.setTextureCoords(texCoord); \
157  shapeVertex(&pv);
158  //----------------------------------------
161  // For pick action use old method, for for see selected lines
163  if ( aAction->getTypeId().isDerivedFrom(SoPickAction::getClassTypeId()) ){ //comment this line to return on old method
164  // Assume all facets are convex quadrilaterals :
165  bool notLastFace;
166  do {
167  HVNormal3D unitNormal;
168  notLastFace = m_polyhedron->GetNextUnitNormal(unitNormal);
169 
170  beginShape(aAction,POLYGON);
171  bool notLastEdge;
172  int edgeFlag = 1;
173  do {
174  HVPoint3D vertex;
175  notLastEdge = m_polyhedron->GetNextVertex(vertex,edgeFlag);
176  GEN_VERTEX(pv,
177  vertex[0],
178  vertex[1],
179  vertex[2],
180  0.0,0.0,
181  unitNormal[0],
182  unitNormal[1],
183  unitNormal[2]);
184  } while (notLastEdge);
185  endShape();
186  } while (notLastFace);
187  }
188  else
189  {
190  if(m_vertices){
191  glEnableClientState(GL_VERTEX_ARRAY);
192  glVertexPointer(3, GL_FLOAT, sizeof(Vertex), &m_vertices[0].pos);
193  glEnableClientState(GL_NORMAL_ARRAY);
194  glNormalPointer(GL_FLOAT, sizeof(Vertex), &m_vertices[0].nor);
196  //For I-Method. Comment it if u use II-Method
198  //glDrawElements(GL_TRIANGLES, m_icount, GL_UNSIGNED_INT, m_indices); //comment it if u use II-Method
200  //For II-Method. Comment it if u use I-Method
202  glDrawArrays(GL_TRIANGLES, 0, m_vcount); //comment it if u use I-Method
203  glDisableClientState(GL_VERTEX_ARRAY);
204  glDisableClientState(GL_NORMAL_ARRAY);
205  }
206  } //End of comment for return to old method */
207  } else {//lala
208 // SoPrimitiveVertex pvb,pve;
209 // pve.setTextureCoords(texCoord);
210 // pvb.setTextureCoords(texCoord);
211 
212 // #ifdef __COIN__ // To bypass a bug in invokeLineSegment when picking.
213 // beginShape(aAction,POLYGON);
214 // endShape();
215 // #endif
216 
217 // SbVec3f point;
218 // bool notLastFace;
219 // do {
220 // HVNormal3D unitNormal;
221 // notLastFace = m_polyhedron->GetNextUnitNormal(unitNormal);
222 
223 // SbVec3f normal;
224 // if( false ) {
225 // normal.setValue(0,0,1);
226 // } else {
227 // normal.setValue(unitNormal[0],unitNormal[1],unitNormal[2]);
228 // }
229 
230 // // Treat edges :
231 // int edgeFlag = 1;
232 // int prevEdgeFlag = edgeFlag;
233 // bool notLastEdge;
234 // SbBool firstEdge = TRUE;
235 // do {
236 // HVPoint3D vertex;
237 // notLastEdge = m_polyhedron->GetNextVertex(vertex,edgeFlag);
238 // if(reducedWireFrame.getValue()==FALSE) edgeFlag = 1;
239 // if(firstEdge) {
240 // if(edgeFlag) {
241 // pvb.setNormal(normal);
242 // point.setValue(vertex[0],vertex[1],vertex[2]);
243 // //DONOTHING projector.project(1,&point);
244 // pvb.setPoint(point);
245 // } else {
246 // }
247 // firstEdge = FALSE;
248 // prevEdgeFlag = edgeFlag;
249 // } else {
250 // if(edgeFlag!=prevEdgeFlag) {
251 // if(edgeFlag) { // Pass to a visible edge :
252 // pvb.setNormal(normal);
253 // point.setValue(vertex[0],vertex[1],vertex[2]);
254 // //DONOTHING projector.project(1,&point);
255 // pvb.setPoint(point);
256 // } else { // Pass to an invisible edge :
257 // pve.setNormal(normal);
258 // point.setValue(vertex[0],vertex[1],vertex[2]);
259 // //DONOTHING projector.project(1,&point);
260 // pve.setPoint(point);
261 // invokeLineSegmentCallbacks(aAction,&pvb,&pve);
262 // }
263 // prevEdgeFlag = edgeFlag;
264 // } else {
265 // if(edgeFlag) {
266 // pve.setNormal(normal);
267 // point.setValue(vertex[0],vertex[1],vertex[2]);
268 // //DONOTHING projector.project(1,&point);
269 // pve.setPoint(point);
270 // invokeLineSegmentCallbacks(aAction,&pvb,&pve);
271 // pvb = pve;
272 // } else {
273 // }
274 // }
275 // }
276 // } while (notLastEdge);
277 // } while (notLastFace);
278  }
279 
280  if (state&&state->isElementEnabled(SoGLCacheContextElement::getClassStackIndex())) {
281  //Encourage auto caching
282  SoGLCacheContextElement::shouldAutoCache(state, SoGLCacheContextElement::DO_AUTO_CACHE);
283 #if ((COIN_MAJOR_VERSION>=3)||((COIN_MAJOR_VERSION==2)&&(COIN_MINOR_VERSION>=5)))
284  SoGLCacheContextElement::incNumShapes(state);
285 #endif
286  }
287 }
289 void SoPolyhedron::computeBBox(
290  SoAction*
291 ,SbBox3f& aBox
292 ,SbVec3f& aCenter
293 )
296 {
297  if(!m_polyhedron) return;
298  if(m_polyhedron->GetNoFacets()<=0) { // Abnormal polyhedron.
299  SbVec3f vmin(-1,-1,-1);
300  SbVec3f vmax( 1, 1, 1);
301  aBox.setBounds(vmin,vmax);
302  aCenter.setValue(0,0,0);
303  } else {
304  // SbBool wireFrame = (solid.getValue()==TRUE ? FALSE : TRUE);
305  //DONOTHING HEPVis::SbProjector projector(wireFrame?fProjection:SbProjectionNone);
306  SbBool first = TRUE;
307  float xmn = 0,ymn = 0,zmn = 0;
308  float xmx = 0,ymx = 0,zmx = 0;
309  float xct = 0,yct = 0,zct = 0;
310  SbVec3f point;
311  int count = 0;
312  // Assume all facets are convex quadrilaterals :
313  bool notLastFace;
314  do {
315  HVNormal3D unitNormal;
316  notLastFace = m_polyhedron->GetNextUnitNormal(unitNormal);
317  bool notLastEdge;
318  do {
319  HVPoint3D vertex;
320  int edgeFlag = 1;
321  notLastEdge = m_polyhedron->GetNextVertex(vertex,edgeFlag);
322  point.setValue(vertex[0],vertex[1],vertex[2]);
323  //DONOTHING projector.project(1,&point);
324  if(first==TRUE) {
325  xct = xmx = xmn = point[0];
326  yct = ymx = ymn = point[1];
327  zct = zmx = zmn = point[2];
328  count++;
329  first = FALSE;
330  } else {
331  xmn = SbMinimum(xmn,point[0]);
332  ymn = SbMinimum(ymn,point[1]);
333  zmn = SbMinimum(zmn,point[2]);
334  //
335  xmx = SbMaximum(xmx,point[0]);
336  ymx = SbMaximum(ymx,point[1]);
337  zmx = SbMaximum(zmx,point[2]);
338  //
339  xct += point[0];
340  yct += point[1];
341  zct += point[2];
342  count++;
343  }
344  //
345  } while (notLastEdge);
346  } while (notLastFace);
347  SbVec3f vmin(xmn,ymn,zmn);
348  SbVec3f vmax(xmx,ymx,zmx);
349  aBox.setBounds(vmin,vmax);
350 
351  if(count==0) {
352  aCenter.setValue(0,0,0);
353  }
354  else {
355  aCenter.setValue(xct/count,yct/count,zct/count);
356  }
357  //DEBUG
358 // std::cout << "vmin: " << xmn << " " << ymn << " " << zmn << std::endl;
359 // std::cout << "vmax: " << xmx << " " << ymx << " " << zmx << std::endl;
360  }
361 
362 
363 }
364 
365 //---
366 //____________________________________________________________________
367 
368 /*
369 void SoPolyhedron::getPrimitiveCount(SoGetPrimitiveCountAction * action)
370 {
371  if(action)
372  action->addNumTriangles(10);
373 }
374 //*/
375 
377 void SoPolyhedron::generateAlternateRep()
378 {
379  if (alternateRep.getValue())
380  clearAlternateRep();
381  if( m_polyhedron && ( m_polyhedron->GetNoFacets() > 0 ) ){
382  //SoSeparator *sep = new SoSeparator;
383  SoVertexProperty *vertices = new SoVertexProperty();
384 
385  //Retreive geometry from polyhedron
386  int vno = m_polyhedron->GetNoVertices();
387  for(int i = 0; i < vno; i++){
388  HVPoint3D vertex;
389  vertex = m_polyhedron->GetVertex(i + 1);
390  vertices->vertex.set1Value (i, vertex[0], vertex[1], vertex[2]);
391  }
392 
393  int fno = m_polyhedron->GetNoFacets();
394  int fcr = 0;
395  int* aface = new int[8 * fno];
396  for(int i = 0; i < fno; i++){
397  int n, inodes[4];
398  //SbVec3d nr = m_polyhedron->GetNormal(i + 1); // not used, gives warning, commenting out:
399  //---
400  m_polyhedron->GetFacet(i + 1, n, inodes);
401  aface[fcr] = (inodes[0] <= vno) ? (inodes[0] - 1) : (0); fcr++;
402  aface[fcr] = (inodes[1] <= vno) ? (inodes[1] - 1) : (0); fcr++;
403  aface[fcr] = (inodes[2] <= vno) ? (inodes[2] - 1) : (0); fcr++;
404  if(n == 4) { aface[fcr] = (inodes[3] <= vno) ? (inodes[3] - 1) : (0); fcr++; }
405  aface[fcr] = -1; fcr++;
406  }
407  SoIndexedFaceSet * faceset = new SoIndexedFaceSet;
408  faceset->coordIndex.setValues(0, fcr, aface);
409  delete [] aface;
410  faceset->vertexProperty = vertices;
411  //sep->addChild(faceset);
412  alternateRep.setValue(faceset);
413  }
414 }
415 //*/
416 
417 //____________________________________________________________________
419 void SoPolyhedron::clearAlternateRep()
420 {
421  alternateRep.setValue(NULL);
422  //Hmm... no ref/unref??
423 }
424 //*/
425 
426 //____________________________________________________________________
428 inline long SoPolyhedron::hasVertex(Vertex* vertices, long len, Vertex& v){
429  for(long i = 0; i < len; i++){
430  if((v.pos[0] == vertices[i].pos[0]) && (v.pos[1] == vertices[i].pos[1]) && (v.pos[2] == vertices[i].pos[2]) &&
431  (v.nor[0] == vertices[i].nor[0]) && (v.nor[1] == vertices[i].nor[1]) && (v.nor[2] == vertices[i].nor[2]))
432  return i;
433  }
434  return -1;
435 }
436 //*/
437 
439 // I - Method, cooment it if u use II - Method
441 /*
442 void SoPolyhedron::makeShape(SbPolyhedron* sp)
443 {
444  if(!sp || (m_polyhedron->GetNoFacets() < 1))
445  return;
446 
447  if(m_vertices){
448  delete [] m_vertices;
449  m_vertices = 0;
450  m_vcount = 0;
451  }
452 
453  if(m_indices){
454  delete [] m_indices;
455  m_indices = 0;
456  m_icount = 0;
457  }
458 
459  int fno = m_polyhedron->GetNoFacets();
460  long faces = 0; //this is primitive face(triangle)
461  for(int i = 0; i < fno; i++){
462  int n, inodes[4];
463  m_polyhedron->GetFacet(i + 1, n, inodes);
464  if(n == 3)
465  faces += 1;
466  else if(n == 4)
467  faces += 2;
468  }
469 
470  if(faces < 1)
471  return;
472 
473  long fcr = 0;
474  m_icount = 3 * faces;
475  m_indices = new long[m_icount];
476 
477  Vertex* varr = new Vertex[m_icount];
478  long vidx = 0;
479  for(int i = 0; i < fno; i++){
480  int n, inodes[4];
481  SbVec3f nor = m_polyhedron->GetNormal(i + 1);
482  m_polyhedron->GetFacet(i + 1, n, inodes);
483 
484  for(int j = 0; j < n; j++){
485  Vertex v;
486  SbVec3f pos = m_polyhedron->GetVertex(inodes[j]);
487  v.pos[0] = pos[0], v.pos[1] = pos[1], v.pos[2] = pos[2];
488  v.nor[0] = nor[0], v.nor[1] = nor[1], v.nor[2] = nor[2];
489  long iarr = hasVertex(varr, vidx, v);
490  if(iarr < 0){
491  varr[vidx] = v;
492  inodes[j] = vidx;
493  vidx++;
494  }else{
495  inodes[j] = iarr;
496  }
497  }
498 
499  if(n >= 3){
500  m_indices[fcr] = (inodes[0] <= m_icount) ? (inodes[0]) : (0); fcr++;
501  m_indices[fcr] = (inodes[1] <= m_icount) ? (inodes[1]) : (0); fcr++;
502  m_indices[fcr] = (inodes[2] <= m_icount) ? (inodes[2]) : (0); fcr++;
503  if(n == 4){
504  m_indices[fcr] = (inodes[0] <= m_icount) ? (inodes[0]) : (0); fcr++;
505  m_indices[fcr] = (inodes[1] <= m_icount) ? (inodes[2]) : (0); fcr++;
506  m_indices[fcr] = (inodes[2] <= m_icount) ? (inodes[3]) : (0); fcr++;
507  }
508  }
509  }
510  m_vcount = vidx;
511  m_vertices = new Vertex[m_vcount];
512  memcpy(m_vertices, varr, m_vcount * sizeof(Vertex));
513  delete [] varr;
514 }
515 //*/
516 
518 // II - Method, comment it if u use I - Method
521 void SoPolyhedron::makeShape(SbPolyhedron* sp)
522 {
523  if(!sp || (m_polyhedron->GetNoFacets() < 1))
524  return;
525 
526  if(m_vertices){
527  delete [] m_vertices;
528  m_vertices = 0;
529  m_vcount = 0;
530  }
531 
532  if(m_indices){
533  delete [] m_indices;
534  m_indices = 0;
535  m_icount = 0;
536  }
537 
538  int fno = m_polyhedron->GetNoFacets();
539  long faces = 0; //this is primitive face(triangle)
540  for(int i = 0; i < fno; i++){
541  int n, inodes[4];
542  m_polyhedron->GetFacet(i + 1, n, inodes);
543  if(n == 3)
544  faces += 1;
545  else if(n == 4)
546  faces += 2;
547  }
548 
549  if(faces < 1)
550  return;
551 
552  long fcr = 0;
553  long vno = m_polyhedron->GetNoVertices();
554  m_vcount = 3 * faces;
555  m_vertices = new Vertex[m_vcount];
556  for(int i = 0; i < fno; i++){
557  int n, inodes[4];
558  HVPoint3D pos[4];
559 
560  // rbianchi
561  // SbVec3f nor = m_polyhedron->GetNormal(i + 1);
562  HVNormal3D nor = m_polyhedron->GetNormal(i + 1);
563  //---
564  m_polyhedron->GetFacet(i + 1, n, inodes);
565  pos[0] = (inodes[0] <= vno) ? (m_polyhedron->GetVertex(inodes[0])) : (m_polyhedron->GetVertex(1));
566  pos[1] = (inodes[1] <= vno) ? (m_polyhedron->GetVertex(inodes[1])) : (m_polyhedron->GetVertex(1));
567  pos[2] = (inodes[2] <= vno) ? (m_polyhedron->GetVertex(inodes[2])) : (m_polyhedron->GetVertex(1));
568  if(n == 4)
569  pos[3] = (inodes[3] <= vno) ? (m_polyhedron->GetVertex(inodes[3])) : (m_polyhedron->GetVertex(1));
570 
571  if(n >= 3){
572  m_vertices[fcr].pos[0] = pos[0][0]; m_vertices[fcr].nor[0] = nor[0];
573  m_vertices[fcr].pos[1] = pos[0][1]; m_vertices[fcr].nor[1] = nor[1];
574  m_vertices[fcr].pos[2] = pos[0][2]; m_vertices[fcr].nor[2] = nor[2];
575  fcr++;
576  m_vertices[fcr].pos[0] = pos[1][0]; m_vertices[fcr].nor[0] = nor[0];
577  m_vertices[fcr].pos[1] = pos[1][1]; m_vertices[fcr].nor[1] = nor[1];
578  m_vertices[fcr].pos[2] = pos[1][2]; m_vertices[fcr].nor[2] = nor[2];
579  fcr++;
580  m_vertices[fcr].pos[0] = pos[2][0]; m_vertices[fcr].nor[0] = nor[0];
581  m_vertices[fcr].pos[1] = pos[2][1]; m_vertices[fcr].nor[1] = nor[1];
582  m_vertices[fcr].pos[2] = pos[2][2]; m_vertices[fcr].nor[2] = nor[2];
583  fcr++;
584  if(n == 4){
585  m_vertices[fcr].pos[0] = pos[0][0]; m_vertices[fcr].nor[0] = nor[0];
586  m_vertices[fcr].pos[1] = pos[0][1]; m_vertices[fcr].nor[1] = nor[1];
587  m_vertices[fcr].pos[2] = pos[0][2]; m_vertices[fcr].nor[2] = nor[2];
588  fcr++;
589  m_vertices[fcr].pos[0] = pos[2][0]; m_vertices[fcr].nor[0] = nor[0];
590  m_vertices[fcr].pos[1] = pos[2][1]; m_vertices[fcr].nor[1] = nor[1];
591  m_vertices[fcr].pos[2] = pos[2][2]; m_vertices[fcr].nor[2] = nor[2];
592  fcr++;
593  m_vertices[fcr].pos[0] = pos[3][0]; m_vertices[fcr].nor[0] = nor[0];
594  m_vertices[fcr].pos[1] = pos[3][1]; m_vertices[fcr].nor[1] = nor[1];
595  m_vertices[fcr].pos[2] = pos[3][2]; m_vertices[fcr].nor[2] = nor[2];
596  fcr++;
597  }
598  }
599  }
600 }
601 //*/
SoPolyhedron::m_indices
long * m_indices
Definition: SoPolyhedron.h:79
SbPolyhedron
Definition: SbPolyhedron.h:231
SbPolyhedron::GetVertex
HVPoint3D GetVertex(int index) const
Definition: SbPolyhedron.cxx:929
SbPolyhedron::GetNextVertex
bool GetNextVertex(HVPoint3D &vertex, int &edgeFlag) const
Definition: SbPolyhedron.cxx:957
SoPolyhedron::~SoPolyhedron
virtual ~SoPolyhedron()
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!//
Definition: SoPolyhedron.cxx:103
SoPolyhedron::computeBBox
virtual void computeBBox(SoAction *, SbBox3f &, SbVec3f &)
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!//
Definition: SoPolyhedron.cxx:289
SbPolyhedron::GetFacet
void GetFacet(int iFace, int &n, int *iNodes, int *edgeFlags=0, int *iFaces=0) const
Definition: SbPolyhedron.cxx:1117
PlotCalibFromCool.vmin
vmin
Definition: PlotCalibFromCool.py:696
SoPolyhedron::m_vcount
long m_vcount
Definition: SoPolyhedron.h:80
SbMath.h
SoPolyhedron::SoPolyhedron
SoPolyhedron()
Definition: SoPolyhedron.cxx:56
SoPolyhedron::makeShape
void makeShape(SbPolyhedron *)
Definition: SoPolyhedron.cxx:521
SoPolyhedron::clearAlternateRep
virtual void clearAlternateRep()
Definition: SoPolyhedron.cxx:419
SbPolyhedron::GetNormal
HVNormal3D GetNormal(int iFace) const
Definition: SbPolyhedron.cxx:1203
SoPolyhedron::Vertex::nor
float nor[3]
Definition: SoPolyhedron.h:75
XMLtoHeader.count
count
Definition: XMLtoHeader.py:85
SoPolyhedron::hasVertex
long hasVertex(Vertex *vertices, long len, Vertex &v)
Definition: SoPolyhedron.cxx:428
SoPolyhedron.h
SbPolyhedron::GetNoFacets
int GetNoFacets() const
Definition: SbPolyhedron.h:296
lumiFormat.i
int i
Definition: lumiFormat.py:92
SoPolyhedron::Vertex::pos
float pos[3]
Definition: SoPolyhedron.h:74
beamspotman.n
n
Definition: beamspotman.py:731
python.Constants.TRUE
bool TRUE
for job options legacy (TODO: get rid of these!) ----------------------—
Definition: Control/AthenaCommon/python/Constants.py:22
SoPolyhedron::generatePrimitives
virtual void generatePrimitives(SoAction *)
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!//
Definition: SoPolyhedron.cxx:115
SoPolyhedron::Vertex
Definition: SoPolyhedron.h:73
SoPolyhedron::m_polyhedron
SbPolyhedron * m_polyhedron
Definition: SoPolyhedron.h:69
SoPolyhedron::alternateRep
SoSFNode alternateRep
Definition: SoPolyhedron.h:54
SoPolyhedron::m_vertices
Vertex * m_vertices
Definition: SoPolyhedron.h:78
python.Constants.FALSE
bool FALSE
Definition: Control/AthenaCommon/python/Constants.py:23
python.LumiBlobConversion.pos
pos
Definition: LumiBlobConversion.py:18
SbMinimum
#define SbMinimum(a, b)
Definition: SbMath.h:10
SoPolyhedron::m_icount
long m_icount
Definition: SoPolyhedron.h:81
python.PyAthena.v
v
Definition: PyAthena.py:157
Trk::vertex
@ vertex
Definition: MeasurementType.h:21
DeMoScan.first
bool first
Definition: DeMoScan.py:534
python.changerun.pv
pv
Definition: changerun.py:81
GEN_VERTEX
#define GEN_VERTEX(pv, x, y, z, s, t, nx, ny, nz)
SoPolyhedron::generateAlternateRep
virtual void generateAlternateRep()
Definition: SoPolyhedron.cxx:377
SbPolyhedron::GetNoVertices
int GetNoVertices() const
Definition: SbPolyhedron.h:293
SoPolyhedron
SoPolyhedron is an Inventor encapsulation of the HepPolyedron class written by E.Chernyaev.
Definition: SoPolyhedron.h:47
SbMaximum
#define SbMaximum(a, b)
Definition: SbMath.h:11
Ringer::getType
T getType(const char *cStr)
Return Ringer enumeration of type T identifying string type:
SbPolyhedron::GetNextUnitNormal
bool GetNextUnitNormal(HVNormal3D &normal) const
Definition: SbPolyhedron.cxx:1276
SbPolyhedron.h
HVPoint3D
Definition: SbPolyhedron.h:188
PlotCalibFromCool.vmax
vmax
Definition: PlotCalibFromCool.py:697
Generated on Thu Jul 4 2024 21:27:14 for ATLAS Offline Software by   doxygen 1.8.18