source: osgVisual/trunk/include/object/visual_object.h @ 293

#pragma once
/* -*-c++-*- osgVisual - Copyright (C) 2009-2011 Torben Dannhauer
 *
 * This library is based on OpenSceneGraph, open source and may be redistributed and/or modified under 
 * the terms of the OpenSceneGraph Public License (OSGPL) version 0.0 or
 * (at your option) any later version.  The full license is in LICENSE file
 * included with this distribution, and on the openscenegraph.org website.
 *
 * osgVisual requires for some proprietary modules a license from the correspondig manufacturer.
 * You have to aquire licenses for all used proprietary modules.
 * 
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * OpenSceneGraph Public License for more details.
*/

#include <osg/MatrixTransform>
#include <osg/Matrix>
#include <osg/NodeCallback>
#include <osg/CoordinateSystemNode>
#include <osg/Notify>

#include <osgDB/ReadFile>
#include <osgDB/FileUtils>

#include <osgText/Text>

#include <osgGA/CameraManipulator>

#include <object_updater.h>
#include <visual_dataIO.h>
#include <visual_util.h>

#include <string.h>
#include <iostream>

// XML Parser
#include <stdio.h>
#include <libxml/parser.h>
#include <libxml/tree.h>

namespace osgVisual
{
class visual_objectPositionCallback;
class object_updater;
}

/**
 * \brief Standard namespace of osgVisual
 * 
 */ 
namespace osgVisual
{

/**
 * \brief This class provides object management for displaying objects in the 3D scene.
 * 
 * It allows to control an object in position, attitude and size. To control this object automatically, use object_updaters.
 * To object itself is invisible, you have to connect a visible geometry to this object.
 * To display geometries, it provides function to load geometries by geometry pointer or filename.
 * To correct wrong coordinate frames in the geometries to display,
 * you can configure a geometry off set in translation in translation and rotation
 * For object mounted camera, you can configure the camera offset in rotation and translation.
 * 
 * All angles are defined in degree.
 * 
 * Derive from this class to implement your custom visual_object.
 * 
 * \todo: Labelmanagement to allow to display a label attached to this object: set/unset label, size, color, offset to object, LOD for label display.
 * 
 * @author Torben Dannhauer
 * @date  Apr 2010
 */ 
class visual_object  : public osg::MatrixTransform
{
        #include <leakDetection.h>
public:
        META_Node(osgVisual,visual_object);
        visual_object() {};
        visual_object(const osgVisual::visual_object& object_, const osg::CopyOp& copyop=osg::CopyOp::SHALLOW_COPY):
            MatrixTransform(object_,copyop),
                        upVector(object_.upVector),
                        lat(object_.lat),
                        lon(object_.lon),
                        alt(object_.alt),
                        azimuthAngle_psi(object_.azimuthAngle_psi),
                        pitchAngle_theta(object_.pitchAngle_theta),
                        bankAngle_phi(object_.bankAngle_phi),
                        scaleX(object_.scaleX),
                        scaleY(object_.scaleY),
                        scaleZ(object_.scaleZ),
                        cameraMatrix(object_.cameraMatrix),
                        cameraTranslationOffset(object_.cameraTranslationOffset),
                        cameraRotationOffset(object_.cameraRotationOffset),
                        geometry_offset_rotation(object_.geometry_offset_rotation),
                        geometry(object_.geometry),
                        updater(object_.updater),
                        trackingId(object_.trackingId),
                        labels(object_.labels)          
                        {}

        /**
         * \brief Constuctor: Adds this object to the scenegraph,
         * initializes this object and installs the callback to calculate its local to world matrix
         * 
         * @param sceneRoot_ : Scenegraph to add this object to.
         * @param nodeName_ : Name of this object, is used for further identification.
         */ 
        visual_object( osg::CoordinateSystemNode* sceneRoot_, std::string nodeName_ );
        
        /**
         * \brief Empty destructor.
         * 
         */ 
        ~visual_object();

        static visual_object* createNodeFromXMLConfig(osg::CoordinateSystemNode* sceneRoot_, xmlNode* a_node);

        /**
         * \brief This functions searches in the scene graph for a node with a tracking ID
         * 
         * @param trackingID : Id to search for.
         * @param currNode_ : Scene graph to search in.
         * @return : Pointer to the first found node, otherwise NULL.
         */ 
        static osg::Node* findNodeByTrackingID(int trackingID, osg::Node* currNode_);


/** @name Position and attitude
 *  These functions control objects position and attitude
 */
/*@{*/

        /**
         * \brief This function updates the objects position and attitude. 
         * 
         * @param lat_ : Latitude to set.
         * @param lon_ : Longitude to set.
         * @param alt_ : Altitude over ellipsoid to set.
         * @param azimuthAngle_psi_ : Psi angle () to set. 
         * @param pitchAngle_theta_ : Theta angle () to set.
         * @param bankAngle_phi_ : Phi angle () to set.
         * 
         * All angles are rad!
         * 
         * \todo: Erklären welche Wirkung die drei Winkel haben.
         */ 
        void setNewPositionAttitude( double lat_, double lon_, double alt_, double azimuthAngle_psi_, double pitchAngle_theta_, double bankAngle_phi_ );
        
        /**
         * \brief This function updates the objects position.
         * 
         * @param lat_ : Latitude to set.
         * @param lon_ : Longitude to set.
         * @param alt_ : Altitude over ellipsoid to set.
         */ 
        void setNewPosition( double lat_, double lon_, double alt_ );

        /**
         * \brief This function updates the objects attitude.
         * 
         * @param azimuthAngle_psi_ : Psi angle () to set. 
         * @param pitchAngle_theta_ : Theta angle () to set.
         * @param bankAngle_phi_ : Phi angle () to set.
         * 
         * All angles are rad!
         * 
         * \todo: Erklären welche Wirkung die drei Winkel haben.
         */ 
        void setNewAttitude( double azimuthAngle_psi_, double pitchAngle_theta_, double bankAngle_phi_ );
/*@}*/
/** @name Geometry management
 *  These functions control which geometry visual_object should display.
 */
/*@{*/
        /**
         * \brief This function configures the geometry offset
         * 
         * @param rotX_ : Geometry rotation along the X axis.
         * @param rotY_ : Geometry rotation along the Y axis.
         * @param rotZ_ : Geometry rotation along the Z axis.
         * 
         * It rotates along the axis of the visual_object, not along the geometry axis!
         * 
         * \todo: Erklären, welche Achsen welche Richtung sind.
         */ 
        void setGeometryOffset( double rotX_, double rotY_, double rotZ_ );

        /**
         * \brief This function set the scale to all 3 axis. Use this function to scale objects without distortion.
         * 
         * @param scale_ : Scale to set for every axis.
         */ 
        void setScale( double scale_ );

        /**
         * \brief This function sets the scale factor for all 3 axis independently.
         * 
         * @param scaleX_ : Scalefactor along X axis.
         * @param scaleY_ : Scalefactor along Y axis.
         * @param scaleZ_ : Scalefactor along Z axis.
         */ 
        void setScale( double scaleX_, double scaleY_, double scaleZ_ );

        /**
         * \brief this function loads a geometry from a file and connects it to this visual_object. All filetypes OSG is aware of can be used.
         * 
         * @param filename_ : File to load and connect.
         * @return : True if loading was successfully
         */ 
        bool loadGeometry( std::string filename_);

        /**
         * \brief This function connects a geometry to this visual_object.
         * 
         * @param geometry_ : Geometry to connect.
         * @return : True if successful.
         */ 
        bool setGeometry(osg::Node* geometry_);

        /**
         * \brief This function disconnects the connected object.
         * 
         */ 
        void unsetGeometry();

        /**
         * \brief This function returns the pointer to the loaded geometry.
         *
         * It returns NULL if no geometry is connected.
         * 
         * @return : Pointer to the geometry if loaded, otherwise NULL.
         */ 
        osg::Node* getGeometry(){return geometry;}

/*@}*/
/** @name Object updater
 *  These functions control objects updater.
 */
/*@{*/
        /**
         * \brief This function adds an Updater to this object.
         * 
         * The updaters postUpdate und preUpdate functions are executed during eventTraversal traversal.
         * The preUdate is executed before the objects matrix is calculated from position, the postUpdate is executed after the matrix calculation. 
         * 
         * @param updater_ : Updater to add.
         */ 
        void addUpdater( object_updater* updater_ );

        /**
         * \brief Removes all updater from the visual_object. 
         * 
         */ 
        void clearAllUpdater();

        /**
         * \brief This function returns a vector containing pointer to all updater of the object.
         * 
         * @return : vector with pointers to all object_updater.
         */ 
        std::vector<object_updater*> getUpdaterList();

/*@}*/
/** @name Camera management
 *  These functions control the camera attitude and position.
 */
/*@{*/
        /**
         * \brief This function returns the camera matrix of the scene camera.
         * 
         * @return : Camera matrix
         */ 
        osg::Matrixd& getCameraMatrix() {return cameraMatrix;};

        /**
         * \brief This function rotates and translate the objects camera position.
         * 
         *  The translation coordinate frame is object fixed, the rotation coordinate frame is camera fixed.
         * 
         * @param x_ : Translation along object's x axis.
         * @param y_ : Translation along object's y axis.
         * @param z_ : Translation along object's z axis (positive axis points downwards).
         * @param rotX_ : Rotation around camera's x axis in [rad].
         * @param rotY_ : Rotation around camera's y axis in [rad]. 
         * @param rotZ_ : Rotation around camera's z axis in [rad].
         */ 
        void setCameraOffset(double x_, double y_, double z_, double rotX_, double rotY_, double rotZ_);

        /**
         * \brief This function configures the camera offset rotation in that object.
         * 
         * The coordinate frame for this rotation is camera fixed, NOT object fixed 
         * (e.g. rotation around x axis (bank) rotatates always around the cameras visual axis, 
         * independent from pitch or azimuth)
         * 
         * @param rotX_ : Rotation around camera's x axis in [rad].
         * @param rotY_ : Rotation around camera's y axis in [rad]. 
         * @param rotZ_ : Rotation around camera's z axis in [rad].
         */ 
        void setCameraOffsetRotation(double rotX_, double rotY_, double rotZ_);

        /**
         * \brief This function configures the camera offset translation in that object.
         * 
         * @param x_ : Translate in longitudinal direction. x>0: Camera is in front if the ob
         * ject, x<0 behind the object.
         * @param y_ : Translate in transversal direction. x>0: Camera is right of the object, x<0 left of the object.
         * @param z_ : Translate in vertical direction. x>0: Camera is below the Object, x<0 above the object. (Positiv Z axis points downwards!)
         */ 
        void setCameraOffsetTranslation( double x_, double y_, double z_);

        /**
         * \brief This function sets the trackingId to allow to identify the visual_obejct for tracking purposes.
         * 
         * See also getTrackingId() and trackingId
         * 
         * @param trackingId_ : trackingId to set.
         */ 
        void setTrackingId(int trackingId_) {trackingId = trackingId_;};

        /**
         * \brief This function returns the trackingId to allow to identify the visual_obejct for tracking purposes.
         * 
         * @return : -1 If no trackingId is set, othwerwise the trackingId.
         */ 
        int getTrackingId() {return trackingId;};

/*@}*/
/** @name Label management
 *  These functions allow to display labels attached to visual_object.
 */
/*@{*/
        /**
         * \brief This function removes all labels attached to this object.
         * 
         */ 
        void clearLabels();

        /**
         * \brief This function adds a label to the object.  
         * 
         * @param idString_ : Identifiy string, which is used to find and manipulate the label later.
         * @param label_ : Message to display as label.
         * @param color_ : Textcolor. Defaults to white.
         * @param offset_ : Offset im meter in the objects local coordinate frame
         */ 
        void addLabel(std::string idString_, std::string label_, osg::Vec4 color_ = osg::Vec4(1.0f,1.0f,1.0f,1.0f), osg::Vec3 offset_ = osg::Vec3(0,0,0));
        
        /**
         * \brief This function removes the specified label.
         * 
         * @param idString_ : idString of the label to remove.
         * @return : True if a label with the specified idString_ was found, false if no label with that idString was found.
         */ 
        bool removeLabel(std::string idString_);

        /**
         * \brief Update the message of the label specified with the idString_.
         * 
         * @param idString_ : idString of the label to update.
         * @param label_ : New message to set.
         * @return : Return true if the specified label was found, return false if the specified label was not found.
         */ 
        bool updateLabelText(std::string idString_, std::string label_);

        /**
         * \brief returns the message string of the specified label.
         * 
         * @param idString_ : idString of the label to return message.
         * @return : Pointer to the Label (osgText::Text) if found, otherwise NULL
         */ 
        osgText::Text* getLabel(std::string idString_); 

        /**
         * \brief This functions sets the draw mode of the specified label.
         * 
         * @param idString_ : Label to configure.
         * @param drawAsOverlay : Set true to draw the label always over the scene. Set false to draw it 3D into the scene (maybe occluded party by objects)
         * @return : Return true if the specified label was found, return false if the specified label was not found. 
         */ 
        bool setDrawLabelAsOverlay(std::string idString_, bool drawAsOverlay);

        /**
         * \brief This function returns if the specified label is configured as overlay.
         * 
         * @param idString_ : Label to configure.
         * @return : True if configured as overlay, false if configured for simple draw
         */ 
        bool getDrawLabelAsOverlay(std::string idString_ );
/*@}*/

protected:
        /**
         * \brief Callback class for updating the visual_object while traversing the scenegraph in the event stage.
         * 
         * @author Torben Dannhauer
         * @date  Jul 2009
         */ 
        class visual_objectPositionCallback : public osg::NodeCallback
        {
        public:
                /**
                 * \brief Constructor: Empty
                 * 
                 */ 
                visual_objectPositionCallback()
                {
                   // nothing
                }
            
                /**
                 * \brief This function is executed by the callback during update traversal.
                 * 
                 */ 
                virtual void operator()(osg::Node* node, osg::NodeVisitor* nv);
        };

        osg::Vec3 upVector;
        
// Position
        /**
         * Latitude of the object in RAD.
         */ 
        double lat;

        /**
         * Longitude of the object in RAD.
         */ 
        double lon;

        /**
         * Altitude of the object over the ellipsoid in meter. 
         */ 
        double alt;

// Attitude
        /**
         * Azimuth angle (Rotation along Z axis, "heading") of the object in RAD.
         */ 
        double azimuthAngle_psi;

        /**
         * Pitch ("nose relative to horizon") angle of the object in RAD.
         */ 
        double pitchAngle_theta;

        /**
         * Bank angle of the object in RAD.
         */ 
        double bankAngle_phi;

// Scale
        /**
         * Object scale along X axis.
         */ 
        double scaleX;

        /**
         * Object scale along Y axis.
         */ 
        double scaleY;

        /**
         * Object scale along Z axis.
         */ 
        double scaleZ;

// Camera offset
        /**
         * This is the matrix containing the camera position for the  manipulators
         */ 
        osg::Matrixd cameraMatrix;

        /**
         * This is the camera matrix containing offset translation
         */ 
        osg::Matrix cameraTranslationOffset;

        /**
         * This is the camera matrix containing offset rotation
         */ 
        osg::Matrix cameraRotationOffset;

        /**
         * Geometry offset (If a model's coordinate system has wrong orientation.)
         */ 
        osg::Quat geometry_offset_rotation;     

        /**
         * Pointer to the geometry, associated with this object.
         */ 
        osg::ref_ptr<osg::Group> geometry;

        /**
         * Pointer to the updater class which updates this visual_object.
         */ 
        osg::ref_ptr<object_updater> updater;

        /**
         * Tracking ID of the visual_object. Used to identify which node should be tracked by tracking-manipulators.
         */ 
        int trackingId;

// Labels
        /**
         * Pointer to the labels group which holds all labels associated with this object.
         */ 
        osg::ref_ptr<osg::Geode> labels;

        // Friend classes
        friend class visual_objectPositionCallback; // To allow the callback access to all member variables.
        friend class object_updater;    // To allow updater to modify all members.

};

} // END NAMESPACE