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