aride_playerhandlers.h

/* -- 2007-05-07 -- 
 *  ardev - an augmented reality library for robot developers
 *  Copyright 2005-2007 - Toby Collett (ardev _at_ plan9.net.nz)
 *
 *  This library is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU Lesser General Public
 *  License as published by the Free Software Foundation; either
 *  version 2.1 of the License, or (at your option) any later version.
 *
 *  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 GNU
 *  Lesser General Public License for more details.
 *
 *  You should have received a copy of the GNU Lesser General Public
 *  License along with this library; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 
 *
 */
#ifndef ARIDE_PLAYERHANDLERS_H
#define ARIDE_PLAYERHANDLERS_H

//#include <ardev/render_player.h> 
#include <ardev/player.h>

#include "aride_objecthandler.h"
#include "aride_parameter.h"

/* --------------------------------------------
    Player Object Handlers
   -------------------------------------------- */
class CaptureStage;
class Position3dPlayerHandler;
class PositionPlayerPTZHandler;

// --- PlayerClientInterfaceHandler Handler ---
class PlayerClientInterfaceHandler : public ArideObjectHandler<PlayerClientInterface>
{
        public:
                PlayerClientInterfaceHandler() :
                        ServerName("PlayerServer","Player Server Address","localhost"),
                        ServerPort("PlayerPort","Player Server Port","6665")
                {
                        PlayerInterface=NULL;
                        Parameters.push_back(&ServerName);
                        Parameters.push_back(&ServerPort);
                };

                virtual ~PlayerClientInterfaceHandler() {delete PlayerInterface;};
                        
                PlayerClientInterface & GetObject() 
                { 
                        printf("playerclient inteface handler get object called\n");
                        if (PlayerInterface == NULL) 
                        {
                                PlayerInterface = new PlayerClientInterface(ServerName.Value.toAscii(), ServerPort.Value);  
                                if (PlayerInterface == NULL)
                                        throw aride_exception(ARIDE_ALLOC_ERROR,__FUNCTION__,__LINE__);
                        }
                        theMainWindow->InitialiseObject(PlayerInterface);
                        return *PlayerInterface;
                };
                void RemoveObject() { delete PlayerInterface; PlayerInterface = NULL;};

                static ObjectHandler * CreateHandler() {return static_cast<ObjectHandler * > (new PlayerClientInterfaceHandler);};
                
        protected:
                StringParameter ServerName;
                IntParameter ServerPort;        
                PlayerClientInterface * PlayerInterface;
};

// --- CapturePlayer Handler ---
class CapturePlayerHandler : public CaptureObjectHandler
{
        public:
                CapturePlayerHandler() :
                        ServerName("PlayerServer","Player Server Address","localhost"),
                        ServerPort("PlayerPort","Player Server Port","6665"),
                        CameraIndex("CameraIndex","Player Camera Index","0")
                {
                        Parameters.push_back(&ServerName);
                        Parameters.push_back(&ServerPort);
                        Parameters.push_back(&CameraIndex);
                        Obj=NULL;
                };

                virtual ~CapturePlayerHandler() {delete Obj;};
                        
                CaptureObject & GetObject() 
                { 
                        if (Obj == NULL) 
                        {
                                Obj = new CapturePlayer(ServerName.Value.toAscii(), ServerPort.Value, CameraIndex.Value);  
                                if (Obj == NULL)
                                        throw aride_exception(ARIDE_ALLOC_ERROR,__FUNCTION__,__LINE__);
                        }
                        theMainWindow->InitialiseObject(Obj);
                        return *Obj;
                };
                void RemoveObject() { delete Obj; Obj = NULL;};

                static ObjectHandler * CreateHandler() {return static_cast<ObjectHandler * > (new CapturePlayerHandler);};
                
        protected:
                StringParameter ServerName;
                IntParameter ServerPort;        
                IntParameter CameraIndex;
                CapturePlayer * Obj;
                
};

// --- PlayerClientInterface Parameter ---
class PlayerClientInterfaceParameter : public StringParameter
{
public: 
                PlayerClientInterfaceParameter(QString _Name, QString _Description, QString _DefaultValue="") : StringParameter(_Name,_Description,_DefaultValue) {Type="PlayerClientInterface";};
                virtual ~PlayerClientInterfaceParameter() {};

                PlayerClientInterfaceHandler * GetClass() 
                {
                        if (Value == "")
                                throw aride_exception(ARIDE_CLASS_NOT_FOUND, __FILE__, __LINE__);
                        aride_object * temp = theMainWindow->GetObjectByName(Value);
                        if (temp == NULL)
                                throw aride_exception(ARIDE_CLASS_NOT_FOUND, __FILE__, __LINE__);
                        if (temp->Section == ARIDE_MISC && temp->Type == "PlayerClientInterface")
                                return reinterpret_cast<PlayerClientInterfaceHandler *> (temp->Handler);
                        throw aride_exception(ARIDE_CLASS_NOT_FOUND, __FILE__, __LINE__);
                };                      

                virtual void ExternalNameChange(const QString & OldName, const QString & NewName) 
                {
                        if (Value == OldName)
                                fromString(NewName);
                };
};

// --- PlayerPosition3d Parameter ---
class PlayerPosition3dParameter : public StringParameter
{
public: 
                PlayerPosition3dParameter(QString _Name, QString _Description, QString _DefaultValue="") : StringParameter(_Name,_Description,_DefaultValue) {Type="Position3d";};
                virtual ~PlayerPosition3dParameter() {};

                Position3dPlayerHandler * GetClass() 
                {
                        if (Value == "")
                                throw aride_exception(ARIDE_CLASS_NOT_FOUND, __FILE__, __LINE__);
                        aride_object * temp = theMainWindow->GetObjectByName(Value);
                        if (temp == NULL)
                                throw aride_exception(ARIDE_CLASS_NOT_FOUND, __FILE__, __LINE__);
                        if (temp->Section == ARIDE_POSITION && temp->Type == "Position3dPlayer")
                                return reinterpret_cast<Position3dPlayerHandler *> (temp->Handler);
                        throw aride_exception(ARIDE_CLASS_NOT_FOUND, __FILE__, __LINE__);
                };                              
};


template<class Base>
class PlayerHandlerBase : public Base
{
        public:
                PlayerHandlerBase() : PlayerClient("PlayerClient","Player Client Object","playerclient")
                {
                        Base::Parameters.push_back(&PlayerClient);
                };

                virtual ~PlayerHandlerBase() {};
        
        protected:
                PlayerClientInterfaceParameter PlayerClient;
};

template <class T, class Base>
class PlayerHandler : public PlayerHandlerBase<Base>
{
        public:
                PlayerHandler() {Obj=NULL;};
                ~PlayerHandler() {delete Obj;};
        
                void RemoveObject() {delete Obj; Obj=NULL;};
        
        protected:
                T * Obj;
};

// --- Position Object Handlers ---
class PositionPlayerHandler : public PlayerHandlerBase<PositionObjectHandler>
{
        public:
                PositionPlayerHandler() {Obj=NULL;};
                ~PositionPlayerHandler() {delete Obj;};
        
                PositionObject & GetObject()
                {
                        if (Obj == NULL)
                        {       
                                if ((Obj = new PositionPlayer(PlayerClient.GetClass()->GetObject())) == NULL)
                                        throw aride_exception(ARIDE_ALLOC_ERROR,__FUNCTION__,__LINE__);
                        }

                        theMainWindow->InitialiseObject(Obj);   
                        return *Obj;                    
                }
        
                static ObjectHandler * CreateHandler() {return static_cast<ObjectHandler * > (new PositionPlayerHandler);};

        protected:
                PositionPlayer * Obj;
};

class Position3dPlayerHandler : public PlayerHandlerBase<PositionObjectHandler>
{
        public:
                Position3dPlayerHandler() {Obj=NULL;};
                ~Position3dPlayerHandler() {delete Obj;};
        
                PositionObject & GetObject()
                {
                        if (Obj == NULL)
                                if ((Obj = new PositionPlayer3d(PlayerClient.GetClass()->GetObject())) == NULL)
                                        throw aride_exception(ARIDE_ALLOC_ERROR,__FUNCTION__,__LINE__);
                        
                        theMainWindow->InitialiseObject(Obj);
                        
                        return *Obj;                    
                }
        
                static ObjectHandler * CreateHandler() {return static_cast<ObjectHandler * > (new Position3dPlayerHandler);};

        protected:
                PositionPlayer3d * Obj;
                
};

class PositionPlayerPTZHandler : public PlayerHandlerBase<PositionObjectHandler>
{
        public:
                PositionPlayerPTZHandler() {Obj=NULL;};
                ~PositionPlayerPTZHandler() {delete Obj;};
        
                PositionObject & GetObject()
                {
                        if (Obj == NULL)
                                if ((Obj = new PositionPlayerPTZ(PlayerClient.GetClass()->GetObject())) == NULL)
                                        throw aride_exception(ARIDE_ALLOC_ERROR,__FUNCTION__,__LINE__);
                        
                        theMainWindow->InitialiseObject(Obj);
                        
                        return *Obj;                    
                }
        
                static ObjectHandler * CreateHandler() {return static_cast<ObjectHandler * > (new PositionPlayerPTZHandler);};

        protected:
                PositionPlayerPTZ * Obj;
                
};

// --- Render Object Handlers ---
class RenderPlayerBumperHandler : public PlayerHandler<RenderPlayerBumper,RenderObjectHandler>
{
        public:
                RenderPlayerBumperHandler() : 
                        Index("Index","Interface Index","0"),
                        Height("Height","Bumper Panel Height","0.1")                    
                {
                        Obj=NULL;
                        Parameters.push_back(&Index);
                        Parameters.push_back(&Height);
                };
                ~RenderPlayerBumperHandler() 
                {
                        delete Obj;
                };

                RenderPlayerBumper & GetObject()
                {
                        if (Obj == NULL)
                        {
                                if ((Obj = new RenderPlayerBumper(PlayerClient.GetClass()->GetObject(),Index.Value, Height.Value)) == NULL)
                                        throw aride_exception(ARIDE_ALLOC_ERROR,__FUNCTION__,__LINE__);
                        }

                        theMainWindow->InitialiseObject(Obj);
                        BaseObject = Obj;
                        return *Obj;                    
                };              
                void RemoveObject() { delete Obj; Obj = NULL; BaseObject = Obj;};
                static ObjectHandler * CreateHandler() {return static_cast<ObjectHandler * > (new RenderPlayerBumperHandler);};

        protected:
                IntParameter Index;
                DoubleParameter Height;
};

class RenderPlayerLaserHandler : public PlayerHandler<RenderPlayerLaser,RenderObjectHandler>
{
        public:
                RenderPlayerLaser & GetObject()
                {
                        if (Obj == NULL)
                        {
                                if ((Obj = new RenderPlayerLaser(PlayerClient.GetClass()->GetObject())) == NULL)
                                        throw aride_exception(ARIDE_ALLOC_ERROR,__FUNCTION__,__LINE__);
                        }

                        theMainWindow->InitialiseObject(Obj);
                        BaseObject = Obj;
                        return *Obj;                    
                };              
                void RemoveObject() { delete Obj; Obj = NULL; BaseObject = Obj;};
                static ObjectHandler * CreateHandler() {return static_cast<ObjectHandler * > (new RenderPlayerLaserHandler);};

};

class RenderPlayerSonarHandler : public PlayerHandler<RenderPlayerSonar,RenderObjectHandler>
{
        public:
                RenderPlayerSonar & GetObject()
                {
                        if (Obj == NULL)
                                if ((Obj = new RenderPlayerSonar(PlayerClient.GetClass()->GetObject())) == NULL)
                                        throw aride_exception(ARIDE_ALLOC_ERROR,__FUNCTION__,__LINE__);

                        theMainWindow->InitialiseObject(Obj);
                        BaseObject = Obj;
                        return *Obj;                    
                };              
                void RemoveObject() { delete Obj; Obj = NULL; BaseObject = Obj;};
                static ObjectHandler * CreateHandler() {return static_cast<ObjectHandler * > (new RenderPlayerSonarHandler);};
                
};

class RenderPlayerIrHandler : public PlayerHandler<RenderPlayerIr,RenderObjectHandler>
{
        public:
                RenderPlayerIr & GetObject()
                {
                        if (Obj == NULL)
                                if ((Obj = new RenderPlayerIr(PlayerClient.GetClass()->GetObject())) == NULL)
                                        throw aride_exception(ARIDE_ALLOC_ERROR,__FUNCTION__,__LINE__);
                        
                        theMainWindow->InitialiseObject(Obj);
                        BaseObject = Obj;
                        return *Obj;                    
                };              
                void RemoveObject() { delete Obj; Obj = NULL; BaseObject = Obj;};
                static ObjectHandler * CreateHandler() {return static_cast<ObjectHandler * > (new RenderPlayerIrHandler);};
};


class RenderPlayerLocaliseHandler : public PlayerHandler<RenderPlayerLocalise,RenderObjectHandler>
{
        public:
                RenderPlayerLocalise & GetObject()
                {
                        if (Obj == NULL)
                                if ((Obj = new RenderPlayerLocalise(PlayerClient.GetClass()->GetObject())) == NULL)
                                        throw aride_exception(ARIDE_ALLOC_ERROR,__FUNCTION__,__LINE__);
                        
                        theMainWindow->InitialiseObject(Obj);
                        BaseObject = Obj;
                        return *Obj;                    
                };              
                void RemoveObject() { delete Obj; Obj = NULL; BaseObject = Obj;};
                static ObjectHandler * CreateHandler() {return static_cast<ObjectHandler * > (new RenderPlayerLocaliseHandler);};
};


class RenderPlayerMapHandler : public PlayerHandlerBase<RenderObjectHandler>
{
        public:
                RenderPlayerMapHandler() : Height("Height","Height of map blocks, 0 for 2d","0") {Obj=NULL;Parameters.push_back(&Height);};
                ~RenderPlayerMapHandler() {delete Obj;};

                RenderPlayerMap & GetObject()
                {
                        if (Obj == NULL)
                                if ((Obj = new RenderPlayerMap(PlayerClient.GetClass()->GetObject(), Height.Value)) == NULL)
                                        throw aride_exception(ARIDE_ALLOC_ERROR,__FUNCTION__,__LINE__);
                        
                        theMainWindow->InitialiseObject(Obj);
                        BaseObject = Obj;
                        return *Obj;                    
                };              
                void RemoveObject() { delete Obj; Obj = NULL; BaseObject = Obj;};
                static ObjectHandler * CreateHandler() {return static_cast<ObjectHandler * > (new RenderPlayerMapHandler);};
        protected:
                RenderPlayerMap * Obj;
                DoubleParameter Height;
};


class RenderPlayerPathHandler : public PlayerHandlerBase<RenderObjectHandler>
{
        public:
                RenderPlayerPathHandler() : Colour("Colour","Path Colour","1 0 0 ") {Obj=NULL;Parameters.push_back(&Colour);};
                ~RenderPlayerPathHandler() {delete Obj;};
        
                RenderObject & GetObject()
                {
                        if (Obj == NULL)
                                if ((Obj = new RenderPlayerPath(PlayerClient.GetClass()->GetObject(),Colour.Value.x,Colour.Value.y,Colour.Value.z)) == NULL)
                                        throw aride_exception(ARIDE_ALLOC_ERROR,__FUNCTION__,__LINE__);
                        
                        theMainWindow->InitialiseObject(Obj);
                        BaseObject = Obj;
                        return *Obj;                    
                }
                
                void RemoveObject() { delete Obj; Obj = NULL; BaseObject = Obj;};
                static ObjectHandler * CreateHandler() {return static_cast<ObjectHandler * > (new RenderPlayerPathHandler);};

        protected:
                RenderPlayerPath * Obj;
                ColourParameter Colour;
};

class RenderPlayerPTZHandler : public PlayerHandlerBase<RenderObjectHandler>
{
        public:
                RenderPlayerPTZHandler() : 
                        Aspect("Aspect","Aspect Ratio","1.3333"),
                        FOV("FOV","FOV (deg). 0 to read from player","0")               
                {Obj=NULL;Parameters.push_back(&Aspect);Parameters.push_back(&FOV);};
                ~RenderPlayerPTZHandler() {delete Obj;};
        
                RenderObject & GetObject()
                {
                        if (Obj == NULL)
                                if ((Obj = new RenderPlayerPTZ(PlayerClient.GetClass()->GetObject(),Aspect.Value, FOV.Value*M_PI/180.0)) == NULL)
                                        throw aride_exception(ARIDE_ALLOC_ERROR,__FUNCTION__,__LINE__);
                        
                        theMainWindow->InitialiseObject(Obj);
                        BaseObject = Obj;
                        return *Obj;                    
                }
                
                void RemoveObject() { delete Obj; Obj = NULL; BaseObject = Obj;};
                static ObjectHandler * CreateHandler() {return static_cast<ObjectHandler * > (new RenderPlayerPTZHandler);};

        protected:
                RenderPlayerPTZ * Obj;
                DoubleParameter Aspect;
                DoubleParameter FOV;
};

class RenderGraphics2DHandler : public RenderObjectHandler
{
        public:
                RenderGraphics2DHandler() {Obj=NULL;};
                ~RenderGraphics2DHandler() {delete Obj;};
        
                RenderObject & GetObject()
                {
                        if (Obj == NULL)
                                if ((Obj = new Graphics2DRenderer) == NULL)
                                        throw aride_exception(ARIDE_ALLOC_ERROR,__FUNCTION__,__LINE__);
                        
                        theMainWindow->InitialiseObject(Obj);
                        BaseObject = Obj;
                        return *Obj;                    
                }
                
                void RemoveObject() { delete Obj; Obj = NULL; BaseObject = Obj;};
                static ObjectHandler * CreateHandler() {return static_cast<ObjectHandler * > (new RenderGraphics2DHandler);};

        protected:
                Graphics2DRenderer * Obj;
};

// --- Capture Object Handlers ---

class CaptureStageHandler : public PlayerHandlerBase<CaptureObjectHandler>
{
        public:
                CaptureStageHandler();
                ~CaptureStageHandler();
        
                CaptureObject & GetObject();
                void RemoveObject();
        
                static ObjectHandler * CreateHandler() {return static_cast<ObjectHandler * > (new CaptureStageHandler);};
        protected:
                CaptureStage * Capture;
                CameraObjectParameter *CameraObject;
                PositionObjectParameter *CameraPositionObject;
                StringParameter *RobotName;
};


// ----------------------------------------------

void RegisterPlayerObjectHandlers();

#endif

---

Generated on Sat May 12 15:25:43 2007 for ardev by  1.5.1