In This Package:

VisualizationSvc Class Reference

this interface defines a Visualization service that is able to answer many question concerning the visualization of the detector. More...

#include <VisDesc/VisualizationSvc.h>

Inheritance diagram for VisualizationSvc:

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

Public Types
	SUCCESS
	NO_INTERFACE
	VERSMISMATCH
	LAST_ERROR
enum	Status
Public Member Functions
	VisualizationSvc (const std::string &name, ISvcLocator *svc)
	Standard Constructor.
virtual	~VisualizationSvc ()
	default destructor
virtual StatusCode	initialize ()
	Initializes the service.
virtual StatusCode	queryInterface (const InterfaceID &riid, void **ppvInterface)
	Queries interfaces of Interface.
virtual const VisAttribute	visAttribute (const Material *mat) const
	This method returns the visualization attribute associated to a given material or 0 if there is no attribute associated to it.
virtual const VisAttribute	visAttribute (const ILVolume *vol) const
	This method returns the visualization attribute associated to a given logical volume or 0 if there is no attribute associated to it.
virtual void	reload ()
	this method erases the current set of attributes and loads a new set
virtual void	clear ()
	this method erases the current set of attributes
virtual unsigned long	addRef ()
virtual unsigned long	release ()
virtual const std::string &	name () const
virtual const InterfaceID &	type () const
virtual StatusCode	configure ()
virtual StatusCode	start ()
virtual StatusCode	stop ()
virtual StatusCode	finalize ()
virtual StatusCode	terminate ()
virtual Gaudi::StateMachine::State	FSMState () const
virtual Gaudi::StateMachine::State	targetFSMState () const
virtual StatusCode	reinitialize ()
virtual StatusCode	restart ()
virtual StatusCode	sysInitialize ()
virtual StatusCode	sysStart ()
virtual StatusCode	sysStop ()
virtual StatusCode	sysFinalize ()
virtual StatusCode	sysReinitialize ()
virtual StatusCode	sysRestart ()
virtual StatusCode	setProperty (const Property &p)
virtual StatusCode	setProperty (const std::string &s)
virtual StatusCode	setProperty (const std::string &n, const std::string &v)
StatusCode	setProperty (const std::string &name, const TYPE &value)
virtual StatusCode	getProperty (Property *p) const
virtual const Property &	getProperty (const std::string &name) const
virtual StatusCode	getProperty (const std::string &n, std::string &v) const
virtual const std::vector< Property * > &	getProperties () const
ISvcLocator *	serviceLocator () const
IMessageSvc *	msgSvc ()
IMessageSvc *	msgSvc () const
IMessageSvc *	messageService ()
IMessageSvc *	messageService () const
StatusCode	setProperties ()
StatusCode	service (const std::string &name, T *&psvc, bool createIf=true) const
StatusCode	service (const std::string &svcType, const std::string &svcName, T *&psvc) const
Property *	declareProperty (const std::string &name, T &property, const std::string &doc="none") const
Property *	declareRemoteProperty (const std::string &name, IProperty *rsvc, const std::string &rname="") const
IAuditorSvc *	auditorSvc () const
Static Public Member Functions
static const InterfaceID &	interfaceID ()
static const InterfaceID &	interfaceID ()
static const InterfaceID &	interfaceID ()
static const InterfaceID &	interfaceID ()
	Retrieve interface ID.
Public Attributes
	SUCCESS
	NO_INTERFACE
	VERSMISMATCH
	LAST_ERROR
Protected Member Functions
int	outputLevel () const
Protected Attributes
IntegerProperty	m_outputLevel
Gaudi::StateMachine::State	m_state
Gaudi::StateMachine::State	m_targetState
IMessageSvc *	m_messageSvc
Private Types
typedef std::map< std::string, VisAttribute >	AttributeSet
	This defines a set of attributes.
typedef std::map< std::string, std::string >	Dictionnary
	This defines a dictionnary.
Private Attributes
AttributeSet	m_attributeSet
	a map of attributes to be used
Dictionnary	m_material2Vis
	a dictionnary linking materials and VisAttributes
Dictionnary	m_logvol2Vis
	a dictionnary linking logical volumes and VisAttributes
Dictionnary	m_logvol_regex_2Vis
std::string	m_colorDbLocation
	The location of the Xml file containing all definitions.
Friends
class	SvcFactory< VisualizationSvc >
	Friend needed.
friend class	ServiceManager

---

Detailed Description

this interface defines a Visualization service that is able to answer many question concerning the visualization of the detector.

It is able to associate visualization attributes to materials and logical volumes. These describe the way these materials and volumes should be displayed

Author:

Sebastien Ponce

Definition at line 26 of file VisualizationSvc.h.

---

Member Typedef Documentation

typedef std::map<std::string, VisAttribute> VisualizationSvc::AttributeSet [private]

This defines a set of attributes.

Each one is associated to a name

Definition at line 98 of file VisualizationSvc.h.

typedef std::map<std::string, std::string> VisualizationSvc::Dictionnary [private]

This defines a dictionnary.

Definition at line 103 of file VisualizationSvc.h.

---

Constructor & Destructor Documentation

VisualizationSvc::VisualizationSvc	(	const std::string &	name,
		ISvcLocator *	svc
	)

Standard Constructor.

Parameters:

	name	String with service name
	svc	Pointer to service locator interface

Definition at line 48 of file VisualizationSvc.cpp.

                                                                           :
  Service (name, svc) {
  declareProperty ("ColorDbLocation", m_colorDbLocation="empty" );
}

virtual VisualizationSvc::~VisualizationSvc

(

)

[inline, virtual]

default destructor

Definition at line 44 of file VisualizationSvc.h.

{};

---

Member Function Documentation

StatusCode VisualizationSvc::initialize

(

)

[virtual]

Initializes the service.

Returns:

status depending on the completion of the call

Reimplemented from Service.

Definition at line 56 of file VisualizationSvc.cpp.

                                        {
  // Before anything we have to initialize grand mother
  StatusCode status = Service::initialize();
  if (!status.isSuccess()) {
    return status;  
  }
  if( m_colorDbLocation.empty() || "empty" == m_colorDbLocation ) { 
    if ( 0 != getenv("XMLVISROOT") ) {
      m_colorDbLocation  = getenv("XMLVISROOT");
      m_colorDbLocation += "/xml/colors.xml";
    } else {
      m_colorDbLocation = "";
    }
  }
  // loads the color set
  reload();
  // returns
  return StatusCode::SUCCESS;
}

StatusCode VisualizationSvc::queryInterface	(	const InterfaceID &	riid,
		void **	ppvInterface
	)			[virtual]

Queries interfaces of Interface.

Parameters:

	riid	ID of Interface to be retrieved
	ppvInterface	Pointer to Location for interface pointer

Returns:

status depending on the completion of the call

Reimplemented from Service.

Definition at line 416 of file VisualizationSvc.cpp.

                                                                             {
  if (IID_IVisualizationSvc.versionMatch(riid))  {
    *ppvInterface = (IVisualizationSvc*)this;
    addRef();
    return StatusCode::SUCCESS;
  } else {
    // Interface is not directly availible: try out a base class
    return Service::queryInterface(riid, ppvInterface);
  }
}

const VisAttribute VisualizationSvc::visAttribute

(

const Material *

mat

)

const [virtual]

This method returns the visualization attribute associated to a given material or 0 if there is no attribute associated to it.

Parameters:

mat

the material

Returns:

the visualization attribute that should be used to display this material

Implements IVisualizationSvc.

Definition at line 307 of file VisualizationSvc.cpp.

                                                         {
  VisAttribute attr;

  if (0 != mat) {
    Dictionnary::const_iterator it = 
      m_material2Vis.find (mat->registry()->identifier());
    if (it != m_material2Vis.end()) {
      AttributeSet::const_iterator it2 = m_attributeSet.find (it->second);
      if (it2 != m_attributeSet.end()) {
        attr = it2->second;
      } else {
        MsgStream log(msgSvc(), name());
        log << MSG::WARNING << "VisAttribute " << it->second << " unknown but"
            << " used for material " << mat->name() << "." << endmsg;
      }
    }
  }
  return attr;
}

const VisAttribute VisualizationSvc::visAttribute

(

const ILVolume *

vol

)

const [virtual]

This method returns the visualization attribute associated to a given logical volume or 0 if there is no attribute associated to it.

Parameters:

vol

the logical volume

Returns:

the visualization attribute that should be used to display this logical volume

Implements IVisualizationSvc.

Definition at line 332 of file VisualizationSvc.cpp.

                                                         {
  VisAttribute attr;

  if (0 != vol) {
    // try first to find an attribute associated directly to the logical volume
    std::string bnn = vol->name();

    Dictionnary::const_iterator it = m_logvol2Vis.find (bnn);
    if (it != m_logvol2Vis.end()) {
      AttributeSet::const_iterator it2 = m_attributeSet.find (it->second);
      if (it2 != m_attributeSet.end()) {
        attr = it2->second;
        // If the attribute is complete, just return
        if (attr.color().isValid() &&
            VisAttribute::NO_VISIBILITY != attr.visible() &&
            VisAttribute::NO_STATUS != attr.openStatus() &&
            VisAttribute::NO_MODE != attr.displayMode()) {
          return attr;
        }
      } else {
        MsgStream log(msgSvc(), name());
        log << MSG::WARNING << "VisAttribute " << it->second 
            << " unknown but"
            << " used for logical volume " << vol->name() << "." << endmsg;
        return attr;
      }
    }

    // look in LogVol Vis XMLs with regular expression :
   {Dictionnary::const_iterator it;
    for(it=m_logvol_regex_2Vis.begin();it!=m_logvol_regex_2Vis.end();it++) {
      boost::regex re(it->first);
      if(boost::regex_search(bnn,re)) {
        //printf("debug : for \"%s\", found \"%s\" with value \"%s\"\n",
        //       bnn.c_str(),it->first.c_str(),it->second.c_str());

        AttributeSet::const_iterator it2 = m_attributeSet.find (it->second);
        if (it2 != m_attributeSet.end()) {
          attr = it2->second;
          // If the attribute is complete, just return
          if (attr.color().isValid() &&
              VisAttribute::NO_VISIBILITY != attr.visible() &&
              VisAttribute::NO_STATUS != attr.openStatus() &&
              VisAttribute::NO_MODE != attr.displayMode()) {
            return attr;
          }
        } else {
          MsgStream log(msgSvc(), name());
          log << MSG::WARNING << "VisAttribute " << it->second 
              << " unknown but"
              << " used for logical volume " << vol->name() << "." << endmsg;
          return attr;
        }

        break;
      }
    }}
    
    // either we don't have an attribute or it may be interesting to
    // complete it using the material
    try {
      const VisAttribute attr2 = visAttribute(vol->material());
      attr.merge(attr2);
    } catch (LogVolumeException ex) {
      // This occurs when the material retrieval raises an exception
      // We display the exception message and return an invalid color
      MsgStream log (msgSvc(), "VisualizationSvc");
      log << MSG::WARNING
          << "Exception received in VisualizationSvc::logvolColor : "
          << endmsg;
      ex.printOut (log);
      log << MSG::WARNING << "Visualization attribute will be corrupted."
          << endmsg;
    }
  }
  
  return attr;

}

void VisualizationSvc::reload

(

)

[virtual]

this method erases the current set of attributes and loads a new set

Implements IVisualizationSvc.

Definition at line 89 of file VisualizationSvc.cpp.

                               {
  MsgStream log (msgSvc(), "VisualizationSvc");

  // erases the old set of attributes
  clear();

  // gets the XmlSvc
  IXmlSvc* xmlSvc;
  StatusCode status = serviceLocator()->service("XmlCnvSvc", xmlSvc, true);
  if (status.isFailure()) {
    log << MSG::ERROR << "Unable to get XmlCnvSvc. The visualization "
        << "attributes will not be loaded." << endmsg;
    return;
  }
  log << MSG::INFO << "Loading visualization attributes file \"" 
      << m_colorDbLocation << "\" ..." << endmsg;

  // parses the file containing the color definitions
  IOVDOMDocument* iovDoc = xmlSvc->parse(m_colorDbLocation.c_str());
  if (!iovDoc) {
    log << MSG::ERROR << "Unable to parse file " << m_colorDbLocation
        << ". The visualization attributes will not be loaded." << endmsg;
    return;
  }
  DOMDocument* document = iovDoc->getDOM();
  if (!document) {
    log << MSG::ERROR << "Document does not exist " << m_colorDbLocation
        << ". The visualization attributes will not be loaded." << endmsg;
    xmlSvc->releaseDoc(iovDoc);
    return;
  }

  // go through the tree of elements and fill in the attribute sets
  XMLCh* xs = xercesc::XMLString::transcode("VisAtt");
  DOMNodeList* domAttrList = document->getElementsByTagName(xs);
  if(!domAttrList) {
    xmlSvc->releaseDoc(iovDoc);
    return;
  }
  
  xercesc::XMLString::release(&xs);
  unsigned int i;
  for (i = 0; i < domAttrList->getLength(); i++) {
    DOMNode* attrNode = domAttrList->item(i);
    DOMElement* attr = (DOMElement*) attrNode;

    xs = xercesc::XMLString::transcode("name");
    std::string name = dom2Std (attr->getAttribute (xs));
    xercesc::XMLString::release(&xs);

    xs = xercesc::XMLString::transcode("visible");
    std::string visibleAttribute = dom2Std (attr->getAttribute (xs));
    xercesc::XMLString::release(&xs);

    xs = xercesc::XMLString::transcode("opened");
    std::string openedAttribute = dom2Std (attr->getAttribute (xs));
    xercesc::XMLString::release(&xs);

    xs = xercesc::XMLString::transcode("mode");
    std::string modeAttribute = dom2Std (attr->getAttribute (xs));
    xercesc::XMLString::release(&xs);
    
    // computes the values
    VisAttribute::Visibility visible = VisAttribute::NO_VISIBILITY;
    if ("Yes" == visibleAttribute) {
      visible = VisAttribute::VISIBLE;
    } else if ("No" == visibleAttribute) {
      visible = VisAttribute::NOT_VISIBLE;
    }
    VisAttribute::OpenStatus opened = VisAttribute::NO_STATUS;
    if ("Yes" == openedAttribute) {
      opened = VisAttribute::OPENED;
    } else if ("No" == openedAttribute) {
      opened = VisAttribute::CLOSED;
    }
    VisAttribute::DisplayMode mode = VisAttribute::NO_MODE;
    if ("Plain" == modeAttribute) {
      mode = VisAttribute::PLAIN;
    } else if ("WireFrame" == modeAttribute) {
      mode = VisAttribute::WIRE_FRAME;
    }
    
    // Looks whether a color node exists
    Color color;
    xs = xercesc::XMLString::transcode("Color");
    DOMNodeList* domColorList = attr->getElementsByTagName(xs);
    xercesc::XMLString::release(&xs);

    if (domColorList && domColorList->getLength() > 0) {
      DOMNode* colorNode = domColorList->item(0);
      DOMElement* colorElement = (DOMElement*) colorNode;

      xs = xercesc::XMLString::transcode("R");
      std::string RAttribute = dom2Std (colorElement->getAttribute (xs));
      xercesc::XMLString::release(&xs);

      xs = xercesc::XMLString::transcode("G");
      std::string GAttribute = dom2Std (colorElement->getAttribute (xs));
      xercesc::XMLString::release(&xs);

      xs = xercesc::XMLString::transcode("B");
      std::string BAttribute = dom2Std (colorElement->getAttribute (xs));
      xercesc::XMLString::release(&xs);

      xs = xercesc::XMLString::transcode("A");
      std::string AAttribute = dom2Std (colorElement->getAttribute (xs));
      xercesc::XMLString::release(&xs);

      // computes the values
      float red = 0.0;
      float green = 0.0;
      float blue = 0.0;
      float alpha = 0.0;
      if (!RAttribute.empty()) {
        red = (float)xmlSvc->eval(RAttribute, false);
      }
      if (!GAttribute.empty()) {
        green = (float)xmlSvc->eval(GAttribute, false);
      }
      if (!BAttribute.empty()) {
        blue = (float)xmlSvc->eval(BAttribute, false);
      }
      if (!AAttribute.empty()) {
        alpha = (float)xmlSvc->eval(AAttribute, false);
      }

      // creates the color
      color = Color (red, green, blue, alpha);
    }
    
    // creates the attribute and register it
    m_attributeSet[name] = VisAttribute(visible, opened, mode, color);
  }
  
  // go through the tree of elements and fill in the material2Vis map
  xs = xercesc::XMLString::transcode("Materials");
  DOMNodeList* domMaterialsList = document->getElementsByTagName(xs);
  xercesc::XMLString::release(&xs);

  if (domMaterialsList && domMaterialsList->getLength() > 0) {
    DOMNode* materialsNode = domMaterialsList->item(0);
    DOMElement* materialsElement = (DOMElement*) materialsNode;

    xs = xercesc::XMLString::transcode("Item");
    DOMNodeList* domMaterialList = materialsElement->getElementsByTagName(xs);
    xercesc::XMLString::release(&xs);

    if(domMaterialList) {
      unsigned int i;
      for (i = 0; i < domMaterialList->getLength(); i++) {
        DOMNode* materialNode = domMaterialList->item(i);
        DOMElement* material = (DOMElement*) materialNode;
        
        xs = xercesc::XMLString::transcode("name");
        std::string name = dom2Std (material->getAttribute (xs));
        xercesc::XMLString::release(&xs);
        
        xs = xercesc::XMLString::transcode("attr");
        std::string attr = dom2Std (material->getAttribute (xs));
        xercesc::XMLString::release(&xs);
        
        // register the association
        m_material2Vis[name] = attr;
      }
    }
  }

  // go through the tree of elements and fill in the logvol2Vis map
  xs = xercesc::XMLString::transcode("LogVols");
  DOMNodeList* domLogvolsList = document->getElementsByTagName(xs);
  xercesc::XMLString::release(&xs);

  if (domLogvolsList->getLength() > 0) {
    DOMNode* logvolsNode = domLogvolsList->item(0);
    DOMElement* logvolsElement = (DOMElement*) logvolsNode;

    xs = xercesc::XMLString::transcode("Item");
    DOMNodeList* domLogvolList = logvolsElement->getElementsByTagName(xs);
    xercesc::XMLString::release(&xs);

    unsigned int i;
    for (i = 0; i < domLogvolList->getLength(); i++) {
      DOMNode* logvolNode = domLogvolList->item(i);
      DOMElement* logvol = (DOMElement*) logvolNode;

      xs = xercesc::XMLString::transcode("name");
      std::string sname = dom2Std (logvol->getAttribute (xs));
      xercesc::XMLString::release(&xs);

      xs = xercesc::XMLString::transcode("regex");
      std::string sregex = dom2Std (logvol->getAttribute (xs));
      xercesc::XMLString::release(&xs);

      xs = xercesc::XMLString::transcode("attr");
      std::string attr = dom2Std (logvol->getAttribute (xs));
      xercesc::XMLString::release(&xs);
    
      // register the association
      if(sname.size()) {
        m_logvol2Vis[sname] = attr;
      } else if(sregex.size()) {
        m_logvol_regex_2Vis[sregex] = attr;
      } else { 
        MsgStream log(msgSvc(), name());
        log << MSG::WARNING << "LogVol with empty name or regex attribute." 
            << endmsg;
      }
    }
  }

  xmlSvc->releaseDoc(iovDoc);

}

void VisualizationSvc::clear

(

)

[virtual]

this method erases the current set of attributes

Definition at line 79 of file VisualizationSvc.cpp.

                              {
  m_attributeSet.clear();
  m_material2Vis.clear();
  m_logvol2Vis.clear();
  m_logvol_regex_2Vis.clear();
}

static const InterfaceID& IVisualizationSvc::interfaceID

(

)

[inline, static, inherited]

Retrieve interface ID.

Reimplemented from IInterface.

Definition at line 35 of file IVisualizationSvc.h.

{ return IID_IVisualizationSvc; }

---

Friends And Related Function Documentation

friend class SvcFactory< VisualizationSvc > [friend]

Friend needed.

Definition at line 30 of file VisualizationSvc.h.

---

Member Data Documentation

AttributeSet VisualizationSvc::m_attributeSet [private]

a map of attributes to be used

Definition at line 106 of file VisualizationSvc.h.

Dictionnary VisualizationSvc::m_material2Vis [private]

a dictionnary linking materials and VisAttributes

Definition at line 109 of file VisualizationSvc.h.

Dictionnary VisualizationSvc::m_logvol2Vis [private]

a dictionnary linking logical volumes and VisAttributes

Definition at line 112 of file VisualizationSvc.h.

Dictionnary VisualizationSvc::m_logvol_regex_2Vis [private]

Definition at line 113 of file VisualizationSvc.h.

std::string VisualizationSvc::m_colorDbLocation [private]

The location of the Xml file containing all definitions.

Definition at line 116 of file VisualizationSvc.h.

---

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

• /home/dayabay/installs/trunk_2011_04_11_opt/NuWa-trunk/lhcb/Vis/VisSvc/src/VisualizationSvc.h
• /home/dayabay/installs/trunk_2011_04_11_opt/NuWa-trunk/lhcb/Vis/VisSvc/src/VisualizationSvc.cpp

---