ardev_types.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 _ARDEV_TYPES_H_
#define _ARDEV_TYPES_H_


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

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

using namespace std;


// radian <-> degree conversions
#ifndef PI_OVER_ONEEIGHTY
#define PI_OVER_ONEEIGHTY (M_PI/180.0)
#endif

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

#ifndef RTOD
#define RTOD(x) (x*ONEEIGHTY_OVER_PI)
#endif

#ifndef DTOR
#define DTOR(x) (x*PI_OVER_ONEEIGHTY)
#endif



class ARPoint
{
public:
        ARPoint(double _x, double _y, double _z) {x = _x; y=_y; z=_z;}; 
        ARPoint() {x=y=z=0.0;}; 
        ARPoint & RotateX(double theta); 
        ARPoint & RotateY(double theta); 
        ARPoint & RotateZ(double theta); 
        ARPoint & RotateYPR(double Y, double P, double R); 
        ARPoint & RotateRPY(double R, double P, double Y); 
        
        double Mag() {return sqrt(x*x + y*y + z*z);}; 
        
        ARPoint operator + (const ARPoint & rhs) {return ARPoint(x+rhs.x, y+rhs.y, z+rhs.z);}; 
        ARPoint operator - (const ARPoint & rhs) const {return ARPoint(x-rhs.x, y-rhs.y, z-rhs.z);}; 
        ARPoint & operator += (const ARPoint & rhs) {x+=rhs.x; y+=rhs.y; z+=rhs.z; return *this;}; 
        ARPoint & operator *= (const double & rhs) {x*=rhs; y*=rhs; z*=rhs; return * this;};
        ARPoint operator * (const double & rhs) {return ARPoint(x*rhs,y*rhs,z*rhs);};
        bool operator == (const ARPoint & rhs) const {return x==rhs.x && y==rhs.y && z==rhs.z;};
        
        double DotProduct(const ARPoint & rhs);
        
        void Print() const {printf("(%f %f %f)",x,y,z);}; 
        
        double x; 
        double y; 
        double z; 
};


enum AR_CamType
{
        AR_CAMTYPE_SINGLE = 0,
        AR_CAMTYPE_LEFT = 1,
        AR_CAMTYPE_RIGHT = 2,
        AR_CAMTYPE_CONV_EXTERN = 4, // Updated externally
        AR_CAMTYPE_CONV_EXTERN_LEFT = 5, // Updated externally
        AR_CAMTYPE_CONV_EXTERN_RIGHT = 6, // Updated externally
        AR_CAMTYPE_CONV_GL = 8, // Updated internally from previous GL frame
        AR_CAMTYPE_CONV_GL_LEFT = 9, // Updated internally from previous GL frame
        AR_CAMTYPE_CONV_GL_RIGHT = 10 // Updated internally from previous GL frame

};

class ARPosition
{
        public:
                ARPosition() {Origin=ARPoint(0,0,0);Direction=ARPoint(0,0,0);};
                ARPosition(ARPoint _Origin, ARPoint _Direction) {Origin=_Origin;Direction=_Direction;};
                ARPoint Origin;
                ARPoint Direction;              
                ARPosition & Transform(const ARPosition & Transform)
                {
                        //Origin.RotateRPY(Transform.Direction.x, Transform.Direction.y, Transform.Direction.z);
                        Origin.RotateZ(Transform.Direction.z);
                        Origin.RotateY(Transform.Direction.y);
                        Origin.RotateX(Transform.Direction.x);
                        Direction += Transform.Direction;
                        Origin += Transform.Origin;
                        return * this;
                };
                
                ARPosition & operator += (const ARPosition & rhs) {Origin += rhs.Origin; Direction += rhs.Direction; return *this;}; 
                bool operator == (const ARPosition & rhs) const {return Origin == rhs.Origin && Direction == rhs.Direction;};
                void Print()
                { Origin.Print(); Direction.Print();};
};

class ARCamera
{
        public:
                ARCamera() {Direction=ARPoint(1,0,0);Up=ARPoint(0,0,1);aspect=1;y_fov=M_PI/4;CamType=AR_CAMTYPE_SINGLE;convergance=NULL;separation=NULL;sensor_width=0.008;};
                ARCamera(ARPoint _Origin, ARPoint LookAt, ARPoint _Up, double y_fov, double aspect);
                ARCamera(const char * CalibFile);

                ARPoint Origin; 
                ARPoint Direction; 
                ARPoint Up; 
                double y_fov; 
                double x_fov; 
                double aspect; 
                double sensor_width; 
                double sensor_height; 
                int frame_width; 
                int frame_height; 
                double FocalDistance; 
                double sx; 
                double sy; 
                
                
                double * convergance; 
                double * separation; 
                
                Matrix R; 
                Matrix RInv; 
                Matrix T; 

                enum AR_CamType CamType; 

                void SetDirectionFromPoint(ARPoint _In);
                //double GetDirection() const;
                
                void Print() const {Origin.Print();Direction.Print();Up.Print();printf("\n");};
                
                ARPoint GetCRFPointFromPixel(double x, double y); 
                ARPoint GetWRFDirFromCRF(ARPoint CRFPoint); 

                double Rx,Ry,Rz;
                double GetRx() {return Rx;};
                double GetRy() {return Ry;};
                double GetRz() {return Rz;};

};


class ARImage{
        public:
                ARImage() {DataSize=0;ColourFormat=GL_RGB; x_size=y_size=0; ByteDepth=3; data=NULL;};
                ~ARImage() {delete [] data; data=NULL;};
                unsigned int x_size; 
                unsigned int y_size; 
                unsigned char * data; 
                unsigned char ByteDepth; 
                unsigned int ColourFormat; 
        
                unsigned char & GetPixel(int x, int y) {return data[y*x_size*ByteDepth + x];}; 
                const unsigned char & GetPixel(int x, int y) const {return data[y*x_size*ByteDepth + x];}; 
                
                unsigned char * Allocate()
                {
                        if (DataSize == x_size*y_size*ByteDepth)
                                return data;
                                                        
                        delete [] data;
                        DataSize = x_size*y_size*ByteDepth;
                        return data = new unsigned char[DataSize];
                }; 
                
                int Erase()
                {
                        if (data)
                                memset(data,0,x_size*y_size*ByteDepth);
                        return 0;
                }; 
                
                ARImage(const ARImage & rhs) 
                {
                        //printf("Copy constructor called\n");
                        DataSize =0;
                        x_size = rhs.x_size; 
                        y_size = rhs.y_size; 
                        ByteDepth = rhs.ByteDepth;
                        //data = NULL;
                        if (Allocate())
                                memcpy(data,rhs.data,x_size*y_size*ByteDepth);
                };
                
                ARImage & operator =(const ARImage & rhs) 
                {
                        //printf("Assignement operator called\n");
                        x_size = rhs.x_size; 
                        y_size = rhs.y_size; 
                        ByteDepth = rhs.ByteDepth;
                        ColourFormat = rhs.ColourFormat;
                        Allocate();
        
                        if (data)
                                memcpy(data,rhs.data,x_size*y_size*ByteDepth);
                        
                        return *this;
                };
                unsigned int GetDataSize() {return DataSize;}; 
        protected:
                unsigned int DataSize; 

                
};


class ARColour
{
        public:
                ARColour() {r=g=b=a=1;}; 
                ARColour(float _r, float _g, float _b, float _a) {r=_r;g=_g;b=_b;a=_a;};
                ARColour(float _r, float _g, float _b)  {r=_r;g=_g;b=_b;a=1;};
        
                float r; 
                float g; 
                float b; 
                float a; 
};


#endif //_ARDEV_TYPES_H_

---

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