ardev.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 
 *
 */

// Global Documentation

#ifndef ARDEV_H
#define ARDEV_H


/* This file decleares the 5 basic classes that are used for the 
ardev Augmented Reality Development system interface */

/* Ardev is a class of static functions that can be used to control the 
debugging process */

#include <ardev/ardev_types.h>

#include <pthread.h>
#include <math.h>
#include <list>
#include <GL/gl.h>

#include <libthjc/geometry.h>
#include <libthjc/matrix.h>
#include <libthjc/misc.h>

#ifndef PI_OVER_ONEEIGHTY
#define PI_OVER_ONEEIGHTY (M_PI/180.0)
#endif

#ifndef RTOD
#define RTOD(x) (x*(180.0/M_PI))
#endif


using namespace std;



class RenderObject;
class PositionObject;
        

#define RENDERPAIR_POSITION_REVERSE 1

void ARDevInit(int argc, char **argv);

class RenderPair
{
        public: 
                RenderPair(RenderObject * _R, PositionObject * _P,int _Flags = 0) {Rend = _R; Pos = _P; Flags=_Flags;ThreadInitilised=false;};
                
                bool operator == (const RenderPair & rhs) {return Rend == rhs.Rend && Pos == rhs.Pos;};
                
                RenderObject * Rend; 
                PositionObject * Pos; 
                unsigned int Flags; 
                bool ThreadInitilised; 
};



class OutputObject;

class ARDev
{
        public:
                ARDev();
                ~ARDev() {};
                static int DebugLevel;

                static int Start(OutputObject * output, const char * Name="default");
                static int Pause(const char * Name="default");
                static int Resume(const char * Name="default");
                static int Stop(const char * Name="default");
                static int Add(RenderPair render, const char * Name="all");
                static int Remove(RenderPair render, const char * Name="all");
                static void Lock();
                static void Unlock();
        
        private:
                static list<OutputObject*> ActiveARList;        
                static pthread_mutex_t lock;
        
};

// ARDev Objects...all inherit from ARObject

class ARObject 
{
        public:
                ARObject(); 
                virtual ~ARObject(); 
                        
                virtual int Initialise(bool Active = true) {if(!(IsActive = Active)) Pause(); initialised = true; return 0;};
                virtual void Terminate() {initialised = false; if (thread) StopThread();};

                void StartThread();
                void StopThread();
                virtual void * Main() {return NULL;};

                virtual void Pause();
                virtual void Resume(); 
                
                virtual void Lock(); 
                virtual void Unlock(); 

                virtual bool Initialised() {return initialised;};

        protected:
                static void * DummyMain(void * ThisPtr);

                pthread_mutex_t lock; 
                pthread_t thread; 
                bool IsActive; 
        
                bool initialised; 
        
                friend class ARDev;
};



/* \brief Base class for all Misc Objects 
 *
 */
typedef ARObject MiscObject;

class CaptureObject : public ARObject
{
        public:
        CaptureObject() {};
        virtual const ARImage &GetFrame() = 0;
        virtual bool Fresh() {return true;};
        virtual int GetMaxWidth()=0;
        virtual int GetMaxHeight()=0;
};

class CaptureNull : public CaptureObject
{
        public:
                CaptureNull() {Frame.x_size = 640;Frame.y_size = 480;Frame.Allocate();Frame.Erase();};
                const ARImage & GetFrame() {return Frame;};
                virtual int GetMaxWidth() {return 640;};
                virtual int GetMaxHeight() {return 480;};
                
                ARImage Frame;
};

class CameraObject : public ARObject
{
        public:
                CameraObject() {};
                virtual const ARCamera GetCamera() {return GetCameraRef();};
                virtual ARCamera & GetCameraRef() = 0;
};

class CameraConstant : public CameraObject
{
        public:
                CameraConstant(const ARCamera & CamIn = ARCamera()) {Cam = CamIn;};
                ARCamera & GetCameraRef() {return Cam;};
                
        private:
                ARCamera Cam;
};

class PositionObject : public ARObject
{
        public:
                PositionObject() {present = true; Next = NULL;};
                virtual ~PositionObject() {};
                virtual ARPosition GetPosition() = 0;
                PositionObject * Next;
                virtual bool Present() {return present;};
                ARPosition GetTransformedPosition();
                bool FullChainPresent();
        protected:
                bool present;
                
};

class PositionNull : public PositionObject
{
        public:
                ARPosition GetPosition() {return ARPosition();};
};

class PositionConstant : public PositionObject
{
        public:
                PositionConstant(ARPosition in) {Pos = in;}; 
                virtual ARPosition GetPosition() {return Pos;};
                
                ARPosition Pos;
};

class PositionRotate : public PositionConstant
{
        public:
                PositionRotate(ARPosition in, ARPoint _Rate) : PositionConstant(in) {Rate=_Rate;Timer.GetElapsedDouble();}; 
                ARPosition GetPosition() 
                {
                        double Elapsed=Timer.GetElapsedDouble()/1000000;
                        Pos.Direction.x += Rate.x * Elapsed;
                        Pos.Direction.y += Rate.y * Elapsed;
                        Pos.Direction.z += Rate.z * Elapsed;
                        return Pos;
                };
                
                ARPoint Rate; //< Rate in radians per second, for each axis
                
        protected:
                StopWatch Timer;
        
};

class FrameProcessObject : public ARObject
{
        public:
                virtual void ProcessFrame(const ARImage & frame) = 0; 
};

typedef list<RenderPair> RenderList;
typedef list<FrameProcessObject *> PostProcessList;
typedef list<FrameProcessObject *> PreProcessList;

class OutputObject : public ARObject
{
        public:
                OutputObject(); 
                virtual void RenderFrame(RenderList & List, const ARImage & Frame, const ARCamera & cam, const ARPosition & pos, unsigned int Tick, double * Distance=NULL); 
                virtual const ARImage & GetFrame(); 

                virtual void ShowFrame() {};
        
                int width; 
                int height; 
                unsigned int TexWidth; 
                unsigned int TexHeight; 
                unsigned int Backdrop; 

                void Add(const RenderPair & render);
                void Remove(const RenderPair & render);

                void AddPost(FrameProcessObject * out);
                void RemovePost(FrameProcessObject * out);
                        
                void AddPre(FrameProcessObject * out);
                void RemovePre(FrameProcessObject * out);

                const char * Name; 
                bool Alive; 
                bool Paused; 
                        
        protected:
        
                RenderList RenderObjects;
                PostProcessList PostProcessObjects;
                PreProcessList PreProcessObjects;
                
        
                CaptureObject * Capture; 
                CameraObject * Camera; 
                PositionObject * CameraPosition; 
                //char * Name; ///< The name of the ARDev Object, used for calls to stop, add and remove

                void *Main(); 
        
                void DrawText(GLint x, GLint y, char * s, GLfloat r, GLfloat g, GLfloat b);
                
                StopWatch TimerFPS;
                StopWatch Timer;
                double FrameRate;
                double OtherTime;
                double CaptureTime;
                double TextureTime;
                double PreprocessTime;
                double RenderTime;
                double PostprocessTime;
                
};




class RenderObject : public ARObject
{
        public:
                RenderObject() {enabled = true; Size=0.1;}; 
                RenderObject(const ARColour & aColour) {enabled = true; Size=0.1; Colour = aColour;}; 
                virtual void ThreadInit() {};
                virtual void RenderBase() {};
                virtual void Render() {};
                virtual void RenderTransparent() {};
                virtual double TraceDistance(const Ray & Offset, const Ray & R, const ARPoint & Rotation);
                virtual bool Enabled() {return enabled;}
                virtual void SetEnabled(const bool EnableState) 
                {
                        enabled = EnableState;
                        if (!enabled && initialised)
                                Terminate();
                        if (enabled && !initialised)
                                Initialise();
                }
                
        protected:
                double Size;
                bool enabled;
                ARColour Colour;
};

class RenderAxes : public RenderObject
{
        public:
                void Render() 
                {
                        glBegin(GL_LINES);
                        glColor3f(0,1,1); // Cyan -> X
                        glVertex3f(0,0,0);
                        glVertex3f(1.000,0,0);
                        glColor3f(1,0,1); // Magenta -> Y
                        glVertex3f(0,0,0);
                        glVertex3f(0,1.000,0);
                        glColor3f(1,1,0); // Yellow -> Z
                        glVertex3f(0,0,0);
                        glVertex3f(0,0,1.000);
                        glEnd();
                }
};
        

                        
#endif

---

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