In This Package:

SoDetConverter Class Reference

#include <SoDetConverter.h>

Inheritance diagram for SoDetConverter:

[legend]Collaboration diagram for SoDetConverter:[legend]List of all members.

Public Types
	INVALID_ADDRESS
	INVALID_OBJECT
	NO_MEMORY
	BAD_STORAGE_TYPE
	NO_SOURCE_OBJECT
	ICONVERSIONSVC_LAST_ERROR
	SUCCESS
	NO_INTERFACE
	VERSMISMATCH
	LAST_ERROR
enum	Status
Public Member Functions
virtual StatusCode	initialize ()
	!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!//
virtual StatusCode	finalize ()
	!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!//
virtual long	repSvcType () const
	!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!//
	SoDetConverter (ISvcLocator *, CLID)
	!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!//
virtual	~SoDetConverter ()
	!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!//
SoNode *	volumeToSoDetectorTreeKit (const ILVolume &, const Gaudi::Transform3D &, bool=false)
	!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!//
MsgStream *	out ()
virtual StatusCode	queryInterface (const InterfaceID &riid, void **ppvInterface)
virtual unsigned long	addRef ()
virtual unsigned long	release ()
virtual StatusCode	setDataProvider (IDataProviderSvc *svc)
virtual IDataProviderSvc *	dataProvider () const
virtual StatusCode	setConversionSvc (IConversionSvc *svc)
virtual IConversionSvc *	conversionSvc () const
virtual StatusCode	setAddressCreator (IAddressCreator *creator)
virtual IAddressCreator *	addressCreator () const
virtual const CLID &	objType () const
virtual long	i_repSvcType () const
virtual StatusCode	createObj (IOpaqueAddress *pAddress, DataObject *&refpObject)
virtual StatusCode	fillObjRefs (IOpaqueAddress *pAddress, DataObject *pObject)
virtual StatusCode	updateObj (IOpaqueAddress *pAddress, DataObject *refpObject)
virtual StatusCode	updateObjRefs (IOpaqueAddress *pAddress, DataObject *pObject)
virtual StatusCode	createRep (DataObject *pObject, IOpaqueAddress *&refpAddress)
virtual StatusCode	fillRepRefs (IOpaqueAddress *pAddress, DataObject *pObject)
virtual StatusCode	updateRep (IOpaqueAddress *pAddress, DataObject *pObject)
virtual StatusCode	updateRepRefs (IOpaqueAddress *pAddress, DataObject *pObject)
StatusCode	service (const std::string &name, T *&psvc, bool createIf=false) const
StatusCode	service (const std::string &type, const std::string &name, T *&psvc) const
Static Public Member Functions
static const InterfaceID &	interfaceID ()
Public Attributes
	INVALID_ADDRESS
	INVALID_OBJECT
	NO_MEMORY
	BAD_STORAGE_TYPE
	NO_SOURCE_OBJECT
	ICONVERSIONSVC_LAST_ERROR
Protected Member Functions
ISvcLocator *	serviceLocator () const
IMessageSvc *	msgSvc () const
IMessageSvc *	messageService () const
IDataManagerSvc *	dataManager () const
Protected Attributes
ISoConversionSvc *	fSoCnvSvc
IUserInterfaceSvc *	fUISvc
Private Member Functions
SbPolyhedron *	solidToSbPolyhedron (const ISolid &)
	!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!//
SbPolyhedron *	simpleSolidToSbPolyhedron (const ISolid &)
	!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!//
SbPolyhedron *	booleanSolidToSbPolyhedron (const ISolid &)
	!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!//
Private Attributes
IVisualizationSvc *	m_visSvc
MsgStream *	m_out
SoStyleCache *	fStyleCache
int	fRotationSteps
bool	fDoBooleanOperation

---

Detailed Description

Definition at line 31 of file SoDetConverter.h.

---

Constructor & Destructor Documentation

SoDetConverter::SoDetConverter	(	ISvcLocator *	,
		CLID
	)

!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!//

Definition at line 75 of file SoDetConverter.cpp.

  :Converter(So_TechnologyType, clid, aSvcLoc)
  ,fSoCnvSvc(0)
  ,fUISvc(0)
  ,m_visSvc(0)
  ,m_out(0)
  ,fStyleCache(0)
  ,fRotationSteps(None)
  ,fDoBooleanOperation(true)
{
  m_out = new MsgStream(msgSvc(),"SoDetConverter");
  StatusCode sc = aSvcLoc->service ("VisualizationSvc", m_visSvc, true);
  if (!sc.isSuccess()) {
    (*m_out) << MSG::WARNING << "Unable to get VisualizationSvc" << endreq;
  }
  fStyleCache = new SoStyleCache;
  fStyleCache->ref();
}

SoDetConverter::~SoDetConverter

(

)

[virtual]

!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!//

Definition at line 96 of file SoDetConverter.cpp.

{
  //printf("debug : SoStyleCache children %d\n",fStyleCache->getNumChildren());
  fStyleCache->unref();

  delete m_out;
}

---

Member Function Documentation

StatusCode SoDetConverter::initialize

(

)

[virtual]

!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!//

Reimplemented from Converter.

Definition at line 106 of file SoDetConverter.cpp.

{
  StatusCode status = Converter::initialize();
  if(status.isFailure()) return status;
  status = serviceLocator()->service("SoConversionSvc",fSoCnvSvc);
  if(status.isFailure()) return status;
  status = serviceLocator()->service("OnXSvc",fUISvc);
  if(status.isFailure()) return status;
  return status;
}

StatusCode SoDetConverter::finalize

(

)

[virtual]

!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!//

Reimplemented from Converter.

Definition at line 119 of file SoDetConverter.cpp.

{
  //The below "release()" induce crash at exit :
  //debug if(fSoCnvSvc) fSoCnvSvc->release();
  //debug if(fUISvc) fUISvc->release();
  return StatusCode::SUCCESS;
}

long SoDetConverter::repSvcType

(

)

const [virtual]

!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!//

Implements Converter.

Definition at line 129 of file SoDetConverter.cpp.

{
  return i_repSvcType();
}

SoNode * SoDetConverter::volumeToSoDetectorTreeKit	(	const ILVolume &	,
		const Gaudi::Transform3D &	,
		bool	= false
	)

!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!//

Definition at line 138 of file SoDetConverter.cpp.

{
  ISession* session = fUISvc->session();
  if(!session) return 0;

  MsgStream log(msgSvc(), "SoDetConverter" );

  // Get visualization attributes :
  std::string value;
  double r = 0.5, g = 0.5, b = 0.5;
  //double hr = 1.0, hg = 1.0, hb = 1.0;
  double transparency = 0;
  bool modelingSolid = true;
  fRotationSteps = None;
  // Look in the ISession :
  if(session->parameterValue("modeling.color",value))
    if(!Lib::smanip::torgb(value,r,g,b)) { r = 0.5; g = 0.5; b = 0.5;}
  if(session->parameterValue("modeling.transparency",value))
    if(!Lib::smanip::todouble(value,transparency)) transparency = 0;
  //if(session->parameterValue("modeling.highlightColor",value))
  //  if(!Lib::smanip::torgb(value,hr,hg,hb)) { hr = 1; hg = 1; hb = 1;}
  if(session->parameterValue("modeling.modeling",value)) {
    modelingSolid = (value=="solid" ? true : false);
  } else { //Backward compatibility
    if(session->parameterValue("modeling.type",value)) {
      modelingSolid = (value=="solid" ? true : false);
    }
  }
  if(session->parameterValue("modeling.rotationSteps",value)) {
    if(!Lib::smanip::toint(value,fRotationSteps)) fRotationSteps = None;
  }
  if(session->parameterValue("modeling.doBooleanOperation",value)) {
    if(!Lib::smanip::tobool(value,fDoBooleanOperation)) fDoBooleanOperation = true;
  }

  bool modelingOpened = aOpened;
  bool modelingVisible = true;

  // Override with VisSvc is needed :
  bool useVisSvc = true;
  if(session->parameterValue("modeling.useVisSvc",value)) {
    if(!Lib::smanip::tobool(value,useVisSvc)) useVisSvc = true;
  }

  VisAttribute attr;
  if(m_visSvc && useVisSvc) {
    attr = m_visSvc->visAttribute(&aLVolume);
    const Color color = attr.color();
    if (color.isValid()) {
      r = color.red();
      g = color.green();
      b = color.blue();
      transparency = color.alpha();
    }
    if(attr.displayMode()==VisAttribute::WIRE_FRAME) {
      modelingSolid = false;
    }
    if(attr.openStatus()==VisAttribute::OPENED) {
      modelingOpened = true;
    }
    if(attr.visible()==VisAttribute::NOT_VISIBLE) {
      modelingVisible = false;
    }
  }

  log << MSG::DEBUG << " opened " << modelingOpened << endreq;

  // Logical volume
  SoNode* node = 0;
  const ISolid* solid = aLVolume.solid();
  if(!solid) {
    //This may happen.
  } else {
    SbPolyhedron* result = solidToSbPolyhedron(*solid);
    if(result) {
      SoPolyhedron* soPolyhedron = new SoPolyhedron(*result);
      delete (result);
      soPolyhedron->solid.setValue(modelingSolid);
      node = soPolyhedron;
    }
  }

  if(node) {
    std::string s;
    Lib::smanip::printf(s,128,"LVolume/0x%lx",(unsigned long)&aLVolume);
    node->setName(s.c_str());
  }

  // Deal with the Transformation :
  Gaudi::Rotation3D rot;
  Gaudi::XYZVector c;
  aMatrix.GetDecomposition(rot,c);
  c = c * -1.0;
  rot.Invert();
  //Gaudi::AxisAngle axisAngle(rot);
  const Gaudi::Quaternion q(rot);
  Gaudi::AxisAngle axisAngle( q );
  double angle;
  Gaudi::XYZVector v;
  axisAngle.GetComponents(v,angle);

  int childn = aLVolume.noPVolumes();
  log << MSG::DEBUG << " childn " << childn << " node " << node << endreq;
  if(childn==0) {

    //  Do not put an SoDetectorTreeKit here.
    // If so, "expanding" (with "ctrl-pick") will lead to an empty
    // scene without the possibility to "contract" by "shift-pick" something !

    // Only display if a node is present and if the visualization attribute
    // is ok
    if (node && modelingVisible) {
      SoSeparator* separator = new SoSeparator;
      separator->setName("sceneGraph");

      if(modelingSolid) {
        separator->addChild
          (fStyleCache->getMaterial(SbColor((float)r,(float)g,(float)b),(float)transparency));
        separator->addChild(fStyleCache->getLightModelPhong());
      } else { //SoLightModel::BASE_COLOR);
        separator->addChild
          (fStyleCache->getMaterial(SbColor((float)r,(float)g,(float)b),(float)transparency,TRUE));
        separator->addChild(fStyleCache->getLightModelBaseColor());
      }

      // The volume is placed and rotated :
      SbMatrix mtx;
      mtx.makeIdentity();
     {SbMatrix tmp;
      tmp.setRotate(SbRotation(SbVec3f((float)v.x(),(float)v.y(),(float)v.z()),
                                       (float)angle));
      mtx.multLeft(tmp);}
     {SbMatrix tmp;
      tmp.setTranslate(SbVec3f((float)c.x(),(float)c.y(),(float)c.z()));
      mtx.multLeft(tmp);} //Applied first.
  
      SoTransform* transform = new SoTransform;
      transform->setMatrix(mtx); //will set the SoFields (needed for VRML).

      // The volume is placed and rotated :
      separator->addChild(transform);
      separator->addChild(node);
      return separator;

    } else {
      if(node) node->unref();
      return 0;
    }

  } else {

    SoDetTreeKit* dtk = new SoDetTreeKit(aLVolume,modelingSolid,this);

    // Override the default SoEventCallback :
    SoEventCallback* evtCbk =
      (SoEventCallback*)dtk->getPart("callbackList[0]",FALSE);
    if(evtCbk) {
      SoEventCallback* eventCallback = new SoEventCallback;

      eventCallback->addEventCallback(SoMouseButtonEvent::getClassTypeId(),
                                      expand,dtk);
      eventCallback->addEventCallback(SoMouseButtonEvent::getClassTypeId(),
                                      contract,dtk);
      if(dtk->setPart("callbackList[0]",eventCallback)==FALSE)
        eventCallback->unref();
    }

    // The volume is placed and rotated :
    SbMatrix mtx;
    mtx.makeIdentity();
   {SbMatrix tmp;
    tmp.setRotate(SbRotation(SbVec3f((float)v.x(),(float)v.y(),(float)v.z()),
                                     (float)angle));
    mtx.multLeft(tmp);}
   {SbMatrix tmp;
    tmp.setTranslate(SbVec3f((float)c.x(),(float)c.y(),(float)c.z()));
    mtx.multLeft(tmp);} //Applied first.

    SoTransform* transform = (SoTransform*)dtk->getPart("transform",TRUE);
    transform->setMatrix(mtx); //will set the SoFields (needed for VRML).

    // Only display if a node is present and if the visualization attributes
    // are ok (visibility and open status)

    SoSeparator* previewSeparator =
      (SoSeparator*)dtk->getPart("previewSeparator",TRUE);

    bool childOpened = false;
    if (node && modelingVisible) {

      SoSeparator* separator = new SoSeparator;
      separator->setName("sceneGraph");

      if(modelingSolid) {
        separator->addChild
          (fStyleCache->getMaterial
            (SbColor((float)r,(float)g,(float)b),(float)transparency));
        separator->addChild(fStyleCache->getLightModelPhong());
      } else { //SoLightModel::BASE_COLOR);
        separator->addChild
          (fStyleCache->getMaterial
           (SbColor((float)r,(float)g,(float)b),(float)transparency,TRUE));
        separator->addChild(fStyleCache->getLightModelBaseColor());
      }

      separator->addChild(new SoTransform); // For manipulators.
      separator->addChild(node);

      previewSeparator->addChild(separator);

      if(modelingOpened) dtk->setPreview(FALSE);
    } else {
      dtk->setPreview(FALSE);
      if(node) node->unref();
      else childOpened = aOpened;
    }

    SoSeparator* fullSeparator =
      (SoSeparator*)dtk->getPart("fullSeparator",TRUE);

    // Only display children if no node present or the node is opened
    if (!node || modelingOpened) {
      // Descend to find a level with something to represent.
      for(int count=0;count<childn;count++) {
        const IPVolume* pvolume = aLVolume[count];
        if (!pvolume) {
          log << MSG::ERROR << "found a null pvolume in " << aLVolume.name()
              << " at index " << count
              << ". Check the name of the logical volume associated to it"
              << endreq;
        } else {
          if(!pvolume->lvolume()) {
            log << MSG::ERROR << "pvolume with a null lvolume." << endreq;
          } else {
            SoNode* child = volumeToSoDetectorTreeKit(*(pvolume->lvolume()),
                                                      pvolume->matrix(),
                                                      childOpened);
            if (child) fullSeparator->addChild(child);
          }
        }
      }
    }

    if(fullSeparator->getNumChildren()==0) {
      // Nothing to visualize in daughters.
      dtk->setPreview(TRUE);
      if(previewSeparator->getNumChildren()==0) {
        // Nothing to preview too.
        // Can't have an SoDetectorTreeKit, else "expanding" it
        // will lead to an empty scene.
        dtk->unref();
        return 0;
      }
    }
    // Note that we can have a dtk with daughters but
    // with nothing to preview. Have to protect the "contract".

    return dtk;
  }

}

MsgStream * SoDetConverter::out

(

)

Definition at line 136 of file SoDetConverter.cpp.

{ return m_out;}

SbPolyhedron * SoDetConverter::solidToSbPolyhedron

(

const ISolid &

)

[private]

!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!//

Definition at line 406 of file SoDetConverter.cpp.

{
  SbPolyhedron* result = simpleSolidToSbPolyhedron(aSolid);
  if(!result) result = booleanSolidToSbPolyhedron(aSolid);
  if(!result) {
    std::string type = aSolid.typeName();
    MsgStream log(msgSvc(),"SoDetConverter::solidToSbPolyhedron");
    log << MSG::INFO
        << " type " << type << " not treated."
        << endreq;
  }
  return result;
}

SbPolyhedron * SoDetConverter::simpleSolidToSbPolyhedron

(

const ISolid &

)

[private]

!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!//

Definition at line 424 of file SoDetConverter.cpp.

{
#ifdef WIN32 //FIXME. Waiting code of HEPVis of OSC-v15r0p2
  //SbPolyhedron::GetNumberOfRotationSteps() is unusable on WIN32.
  int oldRotationSteps = DEFAULT_NUMBER_OF_STEPS;
#else
  int oldRotationSteps = SbPolyhedron::GetNumberOfRotationSteps() ;
#endif

  if(fRotationSteps!=None)
    SbPolyhedron::SetNumberOfRotationSteps(fRotationSteps);

  SbPolyhedron* result = 0;

  if(const SolidBox* box = dynamic_cast<const SolidBox*>(&aSolid)) {
    result = new SbPolyhedronBox(box->xHalfLength(),
                                 box->yHalfLength(),
                                 box->zHalfLength());
  } else if(const SolidCons* cons = dynamic_cast<const SolidCons*>(&aSolid)) {
    result = new SbPolyhedronCons(cons->innerRadiusAtMinusZ(),
                                  cons->outerRadiusAtMinusZ(),
                                  cons->innerRadiusAtPlusZ(),
                                  cons->outerRadiusAtPlusZ(),
                                  cons->zHalfLength(),
                                  cons->startPhiAngle(),
                                  cons->deltaPhiAngle());
  } else if(const SolidPolycone* cons =
            dynamic_cast<const SolidPolycone*>(&aSolid)) {
    unsigned int nb = cons->number();
    if(nb<=0) {
      MsgStream log(msgSvc(), "SoDetConverter::simpleSolidToSbPolyhedron");
      log << MSG::INFO
          << " SolidPolycone with null cons->number()."
          << endreq;
    } else {
      double* z = new double[nb];
      double* innerRadius = new double[nb];
      double* outerRadius = new double[nb];
      unsigned int i = 0;
      for (SolidPolycone::Iterator it=cons->begin();it < cons->end();it++) {
        z[i] = (*it).first;
        outerRadius[i] = (*it).second.first;
        innerRadius[i] = (*it).second.second;
        i++;
      }
      result =  new SbPolyhedronPcon(cons->startPhiAngle(),
                                     cons->deltaPhiAngle(),
                                     nb,
                                     z,
                                     innerRadius,
                                     outerRadius);
      delete [] z;
      delete [] innerRadius;
      delete [] outerRadius;

    }
  } else if(const SolidSphere* sphere =
            dynamic_cast<const SolidSphere*>(&aSolid)) {

    if( (sphere->deltaPhiAngle()<=0) || (sphere->deltaThetaAngle()<=0) ){
      MsgStream log(msgSvc(), "SoDetConverter::simpleSolidToSbPolyhedron");
      log << MSG::INFO
          << " SolidSphere with null deltaPhiAngle or deltaThetaAngle."
          << endreq;
    } else {

      // The default SbPolyhedronSphere algorithm takes
      // SbPolyhedron::DEFAULT_NUMBER_OF_STEPS (24) for a compleete sphere.

      // Have SbPolyhedron::GetNumberOfRotationSteps() steps for the
      // piece of sphere only.

      // Customize the modeling number of rotation steps :
      int nphi = int(M_PI_2 / sphere->deltaPhiAngle());
      int ntheta = int(M_PI / sphere->deltaThetaAngle());

      //int rotationSteps =
      //SbMaximum(nphi,ntheta) * SbPolyhedron::GetNumberOfRotationSteps();

      int rotationSteps = SbMaximum(nphi,ntheta);
#ifdef WIN32 //FIXME. Waiting code of HEPVis of OSC-v15r0p2
      //SbPolyhedron::GetNumberOfRotationSteps() is unusable on WIN32.
      rotationSteps *=
        (fRotationSteps!=None ? fRotationSteps : DEFAULT_NUMBER_OF_STEPS);
#else
      rotationSteps *= SbPolyhedron::GetNumberOfRotationSteps();
#endif
      if(rotationSteps<=0) rotationSteps = DEFAULT_NUMBER_OF_STEPS;
      SbPolyhedron::SetNumberOfRotationSteps(rotationSteps);

      result = new SbPolyhedronSphere(sphere->insideRadius(),
                                      sphere->outerRadius(),
                                      sphere->startPhiAngle(),
                                      sphere->deltaPhiAngle(),
                                      sphere->startThetaAngle(),
                                      sphere->deltaThetaAngle());

    }

  } else if(const SolidTubs* tubs = dynamic_cast<const SolidTubs*>(&aSolid)) {

    if( (tubs->deltaPhiAngle()<=0) ){
      MsgStream log(msgSvc(), "SoDetConverter::simpleSolidToSbPolyhedron");
      log << MSG::INFO
          << " SolidTubs with null deltaPhiAngle."
          << endreq;
    } else {

      // The default SbPolyhedronSphere algorithm takes
      // SbPolyhedron::DEFAULT_NUMBER_OF_STEPS (24) for a compleete tubs.

      // Have SbPolyhedron::GetNumberOfRotationSteps() steps for the
      // piece of tubs only.

      // Customize the modeling number of rotation steps :
      int rotationSteps = int(M_PI_2 / tubs->deltaPhiAngle());

#ifdef WIN32 //FIXME. Waiting code of HEPVis of OSC-v15r0p2
      //SbPolyhedron::GetNumberOfRotationSteps() is unusable on WIN32.
      rotationSteps *=
        (fRotationSteps!=None ? fRotationSteps : DEFAULT_NUMBER_OF_STEPS);
#else
      rotationSteps *= SbPolyhedron::GetNumberOfRotationSteps();
#endif
      if(rotationSteps<=0) rotationSteps = DEFAULT_NUMBER_OF_STEPS;
      SbPolyhedron::SetNumberOfRotationSteps(rotationSteps);

      result = new SbPolyhedronTubs(tubs->innerRadius(),
                                    tubs->outerRadius(),
                                    tubs->zHalfLength(),
                                    tubs->startPhiAngle(),
                                    tubs->deltaPhiAngle());
    }

  } else if(const SolidTrd* trd = dynamic_cast<const SolidTrd*>(&aSolid)) {
    result = new SbPolyhedronTrd2(trd->xHalfLength1(),
                                  trd->xHalfLength2(),
                                  trd->yHalfLength1(),
                                  trd->yHalfLength2(),
                                  trd->zHalfLength());
  } else if(const SolidTrap* trap = dynamic_cast<const SolidTrap*>(&aSolid)) {
    result = new SbPolyhedronTrap(trap->zHalfLength(),
                                  trap->theta(),
                                  trap->phi(),
                                  trap->dyAtMinusZ(),
                                  trap->dxAtMinusZMinusY(),
                                  trap->dxAtMinusZPlusY(),
                                  trap->alphaAtMinusZ(),
                                  trap->dyAtPlusZ(),
                                  trap->dxAtPlusZMinusY(),
                                  trap->dxAtPlusZPlusY(),
                                  trap->alphaAtPlusZ());
  } else {
    // Continue without message.
  }

  SbPolyhedron::SetNumberOfRotationSteps(oldRotationSteps);

  return result;
}

SbPolyhedron * SoDetConverter::booleanSolidToSbPolyhedron

(

const ISolid &

)

[private]

!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!//

Definition at line 589 of file SoDetConverter.cpp.

{
  if (const SolidSubtraction* sub =
      dynamic_cast<const SolidSubtraction*>(&aSolid)) {

    MsgStream log(msgSvc(),"SoDetConverter::booleanSolidToSbPolyhedron");
    log << MSG::DEBUG << " SolidSubtraction" << endreq;

    if(!sub->first()) return 0;

    SbPolyhedron* sbPoly = solidToSbPolyhedron(*(sub->first()));
    if(!sbPoly) return 0;
    sbPoly->setName(sub->first()->name().c_str()); //OSC_VERSION_16_3
    if(!fDoBooleanOperation) return sbPoly;

    SbPolyhedronProcessor sbPP; //OSC_VERSION_16_3

    int childn = sub->noChildrens();
    for(int count=0;count<childn;count++) {
      if(!((*sub)[count])) {
        delete sbPoly;
        return 0;
      }
      const SolidChild* solidChild  =
        dynamic_cast<const SolidChild*>((*sub)[count]);
      if(!solidChild) {
        delete sbPoly;
        return 0;
      }
      const ISolid* solidChildSolid = solidChild->solid();
      if(!solidChildSolid) {
        delete sbPoly;
        return 0;
      }
      SbPolyhedron* scsPoly = solidToSbPolyhedron(*solidChildSolid);
      if(!scsPoly) {
        delete sbPoly;
        return 0;
      }
      scsPoly->setName(solidChildSolid->name().c_str()); //OSC_VERSION_16_3

      // Rotated then placed (the reverse of the logical/physical placement) :
      Gaudi::XYZVector trans;
      Gaudi::Rotation3D rot;
      solidChild->matrix().GetDecomposition(rot,trans);
      trans = trans * -1.0;
      rot.Invert();
      //Gaudi::AxisAngle axisAngle(rot);
      const Gaudi::Quaternion q(rot);
      Gaudi::AxisAngle axisAngle( q );
      Gaudi::XYZVector v;
      double angle;
      axisAngle.GetComponents(v,angle);

      //OSC_VERSION_16_3
      scsPoly->Transform(HEPVis::SbRotation(SbVec3d(1, 0, 0),0),
                         SbVec3d(trans.x(),trans.y(),trans.z()));
      scsPoly->Transform(HEPVis::SbRotation(SbVec3d(v.x(),v.y(),v.z()),angle),
                         SbVec3d(0, 0, 0));
      sbPP.push_back(SbPolyhedronProcessor::SUBTRACTION,*scsPoly);

      //OSC_VERSION_16_2
      //scsPoly->Transform(SbRotation(SbVec3f(1, 0, 0),0),
      //                   SbVec3f((float)trans.x(),(float)trans.y(),(float)trans.z()));
      //scsPoly->Transform(SbRotation(SbVec3f((float)v.x(),(float)v.y(),(float)v.z()),(float)angle),SbVec3f(0, 0, 0));
      //*sbPoly = sbPoly->subtract(*scsPoly);

      delete scsPoly;
    }

    //OSC_VERSION_16_3
    if(sbPP.execute(*sbPoly)==FALSE) {
      log << MSG::INFO << " SolidSubtraction failed" << endreq;
    }

    return sbPoly;

  } else if(const SolidIntersection* inter =
            dynamic_cast<const SolidIntersection*>(&aSolid)) {

    MsgStream log(msgSvc(),"SoDetConverter::booleanSolidToSbPolyhedron");
    log << MSG::DEBUG << " SolidIntersection" << endreq;

    if(!inter->first()) return 0;

    SbPolyhedron* sbPoly = solidToSbPolyhedron(*(inter->first()));
    if(!sbPoly) return 0;
    sbPoly->setName(inter->first()->name().c_str()); //OSC_VERSION_16_3
    if(!fDoBooleanOperation) return sbPoly;

    SbPolyhedronProcessor sbPP; //OSC_VERSION_16_3

    int childn = inter->noChildrens();
    for(int count=0;count<childn;count++) {
      if(!((*inter)[count])) {
        delete sbPoly;
        return 0;
      }
      const SolidChild* solidChild  =
        dynamic_cast<const SolidChild*>((*inter)[count]);
      if(!solidChild) {
        delete sbPoly;
        return 0;
      }
      const ISolid* solidChildSolid = solidChild->solid();
      if(!solidChildSolid) {
        delete sbPoly;
        return 0;
      }
      SbPolyhedron* scsPoly = solidToSbPolyhedron(*solidChildSolid);
      if(!scsPoly) {
        delete sbPoly;
        return 0;
      }
      scsPoly->setName(solidChildSolid->name().c_str()); //OSC_VERSION_16_3
      // Rotated then placed (the reverse of the logical/physical placement) :

      Gaudi::XYZVector trans;
      Gaudi::Rotation3D rot;
      solidChild->matrix().GetDecomposition(rot,trans);
      trans = trans * -1.0;
      rot.Invert();
      //Gaudi::AxisAngle axisAngle(rot);
      const Gaudi::Quaternion q(rot);
      Gaudi::AxisAngle axisAngle( q );
      Gaudi::XYZVector v;
      double angle;
      axisAngle.GetComponents(v,angle);

      //OSC_VERSION_16_3
      scsPoly->Transform(HEPVis::SbRotation(SbVec3d(1, 0, 0),0),
                         SbVec3d(trans.x(),trans.y(),trans.z()));
      scsPoly->Transform(HEPVis::SbRotation(SbVec3d(v.x(),v.y(),v.z()),angle),
                         SbVec3d(0, 0, 0));
      sbPP.push_back(SbPolyhedronProcessor::INTERSECTION,*scsPoly);

      //OSC_VERSION_16_2
      //scsPoly->Transform(SbRotation(SbVec3f(1, 0, 0),0),
      //                   SbVec3f((float)trans.x(),(float)trans.y(),(float)trans.z()));
      //scsPoly->Transform(SbRotation(SbVec3f((float)v.x(),(float)v.y(),(float)v.z()),(float)angle),SbVec3f(0, 0, 0));
      //*sbPoly = sbPoly->intersect(*scsPoly);

      delete scsPoly;
    }

    //OSC_VERSION_16_3
    if(sbPP.execute(*sbPoly)==FALSE) {
      log << MSG::INFO << " SolidIntersection failed" << endreq;
    }

    return sbPoly;

  } else if(const SolidUnion* un = dynamic_cast<const SolidUnion*>(&aSolid)) {

    MsgStream log(msgSvc(),"SoDetConverter::booleanSolidToSbPolyhedron");
    log << MSG::DEBUG << " SolidUnion" << endreq;

    if(!un->first()) return 0;

    SbPolyhedron* sbPoly = solidToSbPolyhedron(*(un->first()));
    if(!sbPoly) return 0;
    sbPoly->setName(un->first()->name().c_str()); //OSC_VERSION_16_3
    if(!fDoBooleanOperation) return sbPoly;

    SbPolyhedronProcessor sbPP; //OSC_VERSION_16_3

    int childn = un->noChildrens();
    for(int count=0;count<childn;count++) {
      if(!((*un)[count])) {
        delete sbPoly;
        return 0;
      }
      const SolidChild* solidChild  =
        dynamic_cast<const SolidChild*>((*un)[count]);
      if(!solidChild) {
        delete sbPoly;
        return 0;
      }
      const ISolid* solidChildSolid = solidChild->solid();
      if(!solidChildSolid) {
        delete sbPoly;
        return 0;
      }
      SbPolyhedron* scsPoly = solidToSbPolyhedron(*solidChildSolid);
      if(!scsPoly) {
        delete sbPoly;
        return 0;
      }
      scsPoly->setName(solidChildSolid->name().c_str()); //OSC_VERSION_16_3

      // Rotated then placed (the reverse of the logical/physical placement) :
      Gaudi::XYZVector trans;
      Gaudi::Rotation3D rot;
      solidChild->matrix().GetDecomposition(rot,trans);
      trans = trans * -1.0;
      rot.Invert();
      //Gaudi::AxisAngle axisAngle(rot);
      const Gaudi::Quaternion q(rot);
      Gaudi::AxisAngle axisAngle( q );
      Gaudi::XYZVector v;
      double angle;
      axisAngle.GetComponents(v,angle);

      //OSC_VERSION_16_3
      scsPoly->Transform(HEPVis::SbRotation(SbVec3d(1, 0, 0),0),
                         SbVec3d(trans.x(),trans.y(),trans.z()));
      scsPoly->Transform(HEPVis::SbRotation(SbVec3d(v.x(),v.y(),v.z()),angle),
                         SbVec3d(0, 0, 0));
      sbPP.push_back(SbPolyhedronProcessor::UNION,*scsPoly);

      //OSC_VERSION_16_2
      //scsPoly->Transform(SbRotation(SbVec3f(1, 0, 0),0),
      //                   SbVec3f((float)trans.x(),(float)trans.y(),(float)trans.z()));
      //scsPoly->Transform(SbRotation(SbVec3f((float)v.x(),(float)v.y(),(float)v.z()),(float)angle),SbVec3f(0, 0, 0));
      //*sbPoly = sbPoly->add(*scsPoly);

      delete scsPoly;
    }

    //OSC_VERSION_16_3
    if(sbPP.execute(*sbPoly)==FALSE) {
      log << MSG::INFO << " SolidUnion failed" << endreq;
    }

    return sbPoly;
  }
  return 0;
}

---

Member Data Documentation

ISoConversionSvc* SoDetConverter::fSoCnvSvc [protected]

Definition at line 48 of file SoDetConverter.h.

IUserInterfaceSvc* SoDetConverter::fUISvc [protected]

Definition at line 49 of file SoDetConverter.h.

IVisualizationSvc* SoDetConverter::m_visSvc [private]

Definition at line 51 of file SoDetConverter.h.

MsgStream* SoDetConverter::m_out [private]

Definition at line 52 of file SoDetConverter.h.

SoStyleCache* SoDetConverter::fStyleCache [private]

Definition at line 53 of file SoDetConverter.h.

int SoDetConverter::fRotationSteps [private]

Definition at line 54 of file SoDetConverter.h.

bool SoDetConverter::fDoBooleanOperation [private]

Definition at line 55 of file SoDetConverter.h.

---

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

• /home/dayabay/installs/trunk_2011_04_11_opt/NuWa-trunk/lhcb/Vis/SoDet/src/SoDetConverter.h
• /home/dayabay/installs/trunk_2011_04_11_opt/NuWa-trunk/lhcb/Vis/SoDet/src/SoDetConverter.cpp

---