In This Package:

Types.cpp

Go to the documentation of this file.

// This :
#include "Types.h"

// Lib :
#include <Lib/Property.h>
#include <Lib/Variable.h>
#include <Lib/Manager.h>

// DetDesc :
#include <DetDesc/ILVolume.h>
#include <DetDesc/IPVolume.h>
#include <DetDesc/ISolid.h>
#include <DetDesc/IGeometryInfo.h>
#include <DetDesc/Material.h>

// OnXSvc :
#include <OnXSvc/Helpers.h>

// HEPVis :
#include <HEPVis/misc/SoStyleCache.h>

#ifdef WIN32
#include <sstream>
#endif

LVolumeType::LVolumeType(
 IPrinter& aPrinter
)
:BaseType(aPrinter)
,fType("LVolume")
{
  addProperty("id",Lib::Property::POINTER);
  addProperty("name",Lib::Property::STRING,70);
  addProperty("material",Lib::Property::STRING,70);
  addProperty("solid",Lib::Property::STRING,70);
}
std::string LVolumeType::name() const
{
  return fType;
}
Lib::Variable LVolumeType::value(
 Lib::Identifier aIdentifier
,const std::string& aName
,void*
) 


{
  const ILVolume* obj = (const ILVolume*)aIdentifier;
  if(aName=="id") {
    return Lib::Variable(printer(),(void*)obj);
  } else if(aName=="name") {
    return Lib::Variable(printer(),obj->name());
  } else if(aName=="material") {
    const Material* material = obj->material();
    return Lib::Variable(printer(),material ? material->name() : "(nil)");
  } else if(aName=="solid") {
    const ISolid* solid = obj->solid();
    if(solid) {
#if defined(__GNUC__) && (__GNUC__ <= 2)
      std::ostrstream os;
      os << solid << std::ends;
      const std::string s(os.str());
      return Lib::Variable(printer(),s);
#else
      std::ostringstream os;
      os << solid << std::ends;
      return Lib::Variable(printer(),os.str());
#endif
    } else {
      const std::string s = "(nil)";
      return Lib::Variable(printer(),s);
    }
  } else {
    return Lib::Variable(printer());
  }
}
// Inventor :
#include <Inventor/nodes/SoSeparator.h>
#include <Inventor/nodes/SoIndexedFaceSet.h>
#include <Inventor/nodes/SoNormal.h>
#include <Inventor/nodes/SoNormalBinding.h>
#include <Inventor/nodes/SoCoordinate3.h>
#include <Inventor/nodes/SoMaterial.h>
#include <Inventor/nodes/SoDrawStyle.h>
#include <Inventor/nodes/SoLightModel.h>

// HEPVis :
#include <HEPVis/nodes/SoHighlightMaterial.h>

// Gaudi :
#include <GaudiKernel/IMagneticFieldSvc.h>

// OnXSvc :
#include <OnXSvc/IUserInterfaceSvc.h>

// Lib :
#include <Lib/Interfaces/IIterator.h>
#include <Lib/Interfaces/ISession.h>
#include <Lib/smanip.h>

// OnX :
#include <OnX/Interfaces/IUI.h>

#define MINIMUM(a,b) ((a)<(b)?a:b)
#define MAXIMUM(a,b) ((a)>(b)?a:b)

MagneticFieldType::MagneticFieldType(
 IUserInterfaceSvc* aUISvc
,IMagneticFieldSvc* aMagneticFieldSvc
)
:OnX::BaseType(aUISvc->printer())
,fName("MagneticField")
,fUISvc(aUISvc)
,fMagneticFieldSvc(aMagneticFieldSvc)
{
  addProperty("id",Lib::Property::POINTER);
}
std::string MagneticFieldType::name() const
{
  return fName;
}
Lib::IIterator* MagneticFieldType::iterator(
) 


{
  // One shoot only iterator.
  class Iterator : public Lib::IIterator {
  public: //Lib::IIterator
    virtual Lib::Identifier object() { return fMagneticFieldSvc; }
    virtual void* tag() { return 0; }
    virtual void next() {fMagneticFieldSvc = 0;}
  public:
    Iterator(IMagneticFieldSvc* aMagneticFieldSvc)
      :fMagneticFieldSvc(aMagneticFieldSvc){}
  private:
    IMagneticFieldSvc* fMagneticFieldSvc;
  };

  return new Iterator(fMagneticFieldSvc);
}
Lib::Variable MagneticFieldType::value(
 Lib::Identifier aIdentifier
,const std::string& aName
,void*
) 


{
  if(aName=="id") {
    return Lib::Variable(printer(),(void*)aIdentifier);
  } else {
    return Lib::Variable(printer());
  }
}
void MagneticFieldType::visualize(
 Lib::Identifier aIdentifier
,void*
) 

// We subdivide a cutting plan into cells (then we have a cutting grid).
// At each center of the cell we compute the magnetic field strength.
// We colorize the cell according the field value.
// Cells with a field value below "fieldMin" are not drawn.
// See SoDet/scripts/Python/MagneticField.py for a triggering
// of the representation from python.
{
  if(!fMagneticFieldSvc) return;
  if(!fUISvc) return;
  if(!fUISvc->session()) return;
  ISession& session = *(fUISvc->session());

  SoRegion* soRegion = fUISvc->currentSoRegion();
  if(!soRegion) return;

  std::string value;
  double dvalue,d1,d2,d3;
  std::vector<double> ds;
  std::vector<int> ls;

  // Default values :
  float sx = 100;  // Size of a cell in x.
  float sy = 100;  // Size of a cell in y.
  unsigned int nx = 80; // Number of cell in x.
  unsigned int ny = 80; // Number of cell in y.
  SbVec3f gridStart(-(sx * nx)/2,-(sy * ny)/2,1000);
  SbVec3f gridX(1,0,0);
  SbVec3f gridY(0,1,0);
  float fieldMin = 0.0001F; // Below that, field is colored in grey.
  float fieldMax = 0.003F;
  float colorMin = 0.3F; // Color for fieldMin.
  float colorMax = 1;    // Color for fieldMax.
  float hr = 1, hg = 1, hb = 1;
  float transparency = 0;

  if(session.parameterValue("modeling.magneticField.gridPosition",value))
    if(Lib::smanip::todoubles(value,ds) && (ds.size()==3) ) {
      gridStart.setValue((float)ds[0],(float)ds[1],(float)ds[2]);
    }
  if(session.parameterValue("modeling.magneticField.gridX",value)) 
    if(Lib::smanip::todoubles(value,ds) && (ds.size()==3) ) {
      gridX.setValue((float)ds[0],(float)ds[1],(float)ds[2]);
    }
  if(session.parameterValue("modeling.magneticField.gridY",value))
    if(Lib::smanip::todoubles(value,ds) && (ds.size()==3) ) {
      gridY.setValue((float)ds[0],(float)ds[1],(float)ds[2]);
    }
  if(session.parameterValue("modeling.magneticField.gridCells",value))
    if(Lib::smanip::toints(value,ls) && (ls.size()==2) ) {
      nx = ls[0];
      ny = ls[1];
    }
  if(session.parameterValue("modeling.magneticField.gridCellSize",value))
    if(Lib::smanip::todoubles(value,ds) && (ds.size()==2) ) {
      sx = (float)ds[0];
      sy = (float)ds[1];
    }
  if(session.parameterValue("modeling.magneticField.min",value))
    if(Lib::smanip::todouble(value,dvalue)) fieldMin = (float)dvalue;
  if(session.parameterValue("modeling.magneticField.max",value))
    if(Lib::smanip::todouble(value,dvalue)) fieldMax = (float)dvalue;
  if(session.parameterValue("modeling.magneticField.colorMin",value))
    if(Lib::smanip::todouble(value,dvalue)) colorMin = (float)dvalue;
  if(session.parameterValue("modeling.magneticField.colorMax",value))
    if(Lib::smanip::todouble(value,dvalue)) colorMax = (float)dvalue;
  if(session.parameterValue("modeling.transparency",value))
    if(Lib::smanip::todouble(value,dvalue)) transparency = (float)dvalue;
  if(session.parameterValue("modeling.highlightColor",value))
    if(Lib::smanip::torgb(value,d1,d2,d3)) { 
      hr = (float)d1; 
      hg = (float)d2; 
      hb = (float)d3;
    }

  if(fieldMax<=fieldMin) return;
  if(colorMax<=colorMin) return;

  // Build name (for picking) :
  std::string s;
  Lib::smanip::printf(s,128,"MagneticField/0x%lx",(unsigned long)aIdentifier);
  SbName name(s.c_str());
    
  bool sceneEmpty = true;
  SoSeparator* cells = new SoSeparator;

  SoCoordinate3* coordinate3 = new SoCoordinate3;
  cells->addChild(coordinate3);

  int32_t coordIndex[5];
  int icoord = 0;

  float colorSlope = (colorMax-colorMin)/(fieldMax-fieldMin);
  for(unsigned int ix=0;ix<nx;ix++) {
    for(unsigned int iy=0;iy<ny;iy++) {

      SbVec3f center = 
        gridStart + gridX * (ix * sx + sx/2) + gridY * (iy * sy + sy/2);
      Gaudi::XYZPoint point(center[0],center[1],center[2]);
      Gaudi::XYZVector field;
      fMagneticFieldSvc->fieldVector( point, field);
      float value = (float)field.mag2();
      value = sqrt(value);
      
      if( (value<fieldMin) || (value>=fieldMax) ) continue;

      float r = colorSlope * (value - fieldMin) + colorMin;
      float g = 0;
      float b = 0;

      //FIXME : 
      //  A SoStyleCache for the below materials slows down the creation
      //  We should have a gradient table.
      // Material :
      SoHighlightMaterial* highlightMaterial = new SoHighlightMaterial;
      highlightMaterial->setName("highlight");
      highlightMaterial->diffuseColor.setValue(SbColor(r,g,b));
      highlightMaterial->highlightColor.setValue(SbColor(hr,hg,hb));
      highlightMaterial->transparency.setValue(transparency);
      cells->addChild(highlightMaterial);

      int32_t pointn = 4;
      SbVec3f line[4];
      line[0] = gridStart + gridX * (ix * sx) + gridY * (iy * sy);
      line[1] = gridStart + gridX * (ix * sx + sx) + gridY * (iy * sy);
      line[2] = gridStart + gridX * (ix * sx + sx) + gridY * (iy * sy + sy);
      line[3] = gridStart + gridX * (ix * sx) + gridY * (iy * sy + sy);
      coordIndex[0] = icoord + 0;
      coordIndex[1] = icoord + 1;
      coordIndex[2] = icoord + 2;
      coordIndex[3] = icoord + 3;
      coordIndex[4] = SO_END_FACE_INDEX;

      coordinate3->point.setValues(icoord,pointn,line);
      icoord += pointn;

      SoIndexedFaceSet* faceSet = new SoIndexedFaceSet;
      faceSet->coordIndex.setValues(0,pointn+1,coordIndex);
      faceSet->setName(name);
      cells->addChild(faceSet);

      sceneEmpty = false;
    }
  }
  
  if(sceneEmpty) {

    cells->unref();

  } else {
    // Build scene graph :
    SoSeparator* separator = new SoSeparator;
    separator->setName("sceneGraph");

    SoStyleCache* styleCache = soRegion->styleCache();

    separator->addChild(styleCache->getLightModelBaseColor());
    separator->addChild(styleCache->getFilled());
    separator->addChild(styleCache->getNormalBindingPerFace());
    separator->addChild(styleCache->getNormalZ());

    separator->addChild(cells);

    soRegion->resetUndo();    
    region_addToStaticScene(*soRegion,separator);

  }

}

---