PhastNode.h

Go to the documentation of this file.

/******************************************************************************
 *
 *  Copyright (C) 2008 Boris Iven, Max Hermann
 *
 *  This file is part of the "CEDRIC Event Display" application.
 *
 *****************************************************************************/

#ifndef PHASTNODE_H
#define PHASTNODE_H

#include <Phast.h>

#include <osg/ref_ptr>
#include <osg/Geode>
#include <osg/Drawable>
#include <osgText/Text>
#include <osg/Vec3>

#include <iostream>
#include <string>

#include "TypedTransform.h"
#include "Selectable.h"


class PhastNode : public TypedTransform, public Selectable
{
public:
        enum Type { GROUP=1, DETECTOR=2, CALORIMETER=4, RICH=8, TRACK=16, MAGNET=32, TARGET=64,
                    CLUSTER=128 };
        
        struct Magnet 
        {
                Magnet( const PaMagInfo& magInfo, const std::string& name_, const std::string& model_ )
                : name(name_), model(model_)
                {
                        x = magInfo.xcm *.1;
                        y = magInfo.ycm *.1;
                        z = magInfo.zcm *.1;
                }
                
                std::string name;
                std::string model;
                double x,y,z;
        };
        
        struct Target 
        {
                Target( const PaSetup& setup, const int ncells_, const std::vector<float>& polarization_)
                : ncells(ncells_), polarization(polarization_)
                {
                        name = "Target";
                        x = 0;
                        y = 0;
                        z = setup.TargetCenterZ();
                        if( z == -35.0 ) cout << "WARNING: Possibly target z position is not stored in mDST and default of -35cm is used." << endl;
                }
                std::string name;
                int ncells;
                double x,y,z;
                vector<float> polarization;
        };
        
        PhastNode();
        PhastNode( const PaDetect&      det  , osg::Vec4 color=osg::Vec4(1.f,1.f,1.f,1.f) );
        PhastNode( const PaCalorimeter& cal  , osg::Vec4 color=osg::Vec4(1.f,1.f,1.f,1.f) );
        PhastNode( const PaRich&        rich , osg::Vec4 color=osg::Vec4(1.f,1.f,1.f,1.f) );
        
        PhastNode( const PaTrack&       track, osg::Vec4 color=osg::Vec4(1.f,1.f,1.f,1.f) );
        PhastNode( const PaCaloClus&    cluster );
        
        PhastNode( const Magnet&       magnet, osg::Vec4 color=osg::Vec4(1.f,1.f,1.f,1.f) );
        PhastNode( const Target&       target, osg::Vec4 color=osg::Vec4(1.f,1.f,1.f,1.f) );
        
        bool isSetupEntity() { return m_type & DETECTOR || m_type & CALORIMETER || m_type & RICH || m_type & MAGNET || m_type & TARGET; }
        bool isEventEntity() { return m_type & TRACK || m_type & CLUSTER; }
        
        bool isGroup()       { return m_type & GROUP;       }
        bool isDetector()    { return m_type & DETECTOR;    }
        bool isCalorimeter() { return m_type & CALORIMETER; }
        bool isRich()        { return m_type & RICH;        }
        
        bool isTrack()       { return m_type & TRACK;       }
        bool isCluster()     { return m_type & CLUSTER;     }
        
        bool isMagnet()      { return m_type & MAGNET;      }
        bool isTarget()      { return m_type & TARGET;      }
        
        std::string getName() const { return m_name; }
        
        int getUID()  const { return m_uid;  }
        
        void setColor( osg::Vec3 color );
        void setAlpha( float alpha );
        void setVisible( bool visible );
        
        void highlight( bool highlighted );
        
        virtual bool onHighlight( bool highlight );
        virtual bool onSelect( bool select );
        virtual const std::string& toolTip( osg::Node* /*node*/ );
        
        virtual bool isPickable( osg::Node* node ) { return node != _shadow.get(); }
                
protected:
        osg::Geode* createHighlightBox( osg::BoundingBox bbox );

        osg::Node* createWireframe( osg::Node* node );

        osg::Node*  createShadow( osg::Node* /*node*/ ) { return new osg::Node; }
        void        createSimplifiedGeometry( osg::Vec4 /*color*/ ) {}

        void init( int type, const std::string& name );
        void assemble();
                
private:
        osg::ref_ptr<osg::Switch> _switch;  
        
        osg::ref_ptr<osg::Node>  _solid;    
        osg::ref_ptr<osg::Node>  _outlines; 
        osg::ref_ptr<osg::Node>  _shadow;   

        osg::ref_ptr<osg::Node> _highlight; 

        int m_uid;                          
        static int s_nextUID;
        static int createUID() { return s_nextUID++; }
        
        std::string m_name;                 
};

#endif