robotgl.h

Go to the documentation of this file.

/*
Copyright (C) 2002-2003  Etienne Lachance

This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.

This program 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 General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA


Report problems and direct all questions to:

email: etienne.lachance@polymtl.ca or richard.gourdeau@polymtl.ca

Reference:
[1] M. Woo, J. Neider, T. Davis, D. Shreiner, "OpenGL Programming Guide, Third Edition,
    Addison-Wesley Publishing Company, 1999, ISBN=0-201-604458-2.
*/

#ifndef ROBOTGL_H
#define ROBOTGL_H


static const char header_robotgl_rcsid[] = "$Id: robotgl.h,v 1.7 2006/12/19 18:22:18 gourdeau Exp $";

#if defined __BORLANDC__
#include <mem.h>
#endif
#include "config.h"
#include "enviro.h"
#include "stl.h"

const unsigned short NbParametresPerLink = 6;

// ------------------------------ R O B O T  C L A S S ----------------------------

class Linkgl : public Basic_object, public STL_obj
{
 friend class Robotgl_basic;
 friend class Robotgl;
 friend class mRobotgl;
 public:
    Linkgl(bool DH = false);
    Linkgl(const std::vector<double> & parameters, const ColumnVector & pos,
           double jnt_radius, const bool DH = false, 
           const double stl_translation_x=0, const double stl_translation_y=0, 
           const double stl_translation_z=0, const double stl_rotation_x=0, 
           const double stl_rotation_y=0,    const double stl_rotation_z=0, 
           const double stl_scalling_x=1,    const double stl_scalling_y=1,
           const double stl_scalling_z=1,    const float red=0.5, 
           const float green=0, const float blue=0, const string stl_file="");
    Linkgl(const Linkgl & x);
    ~Linkgl();
    Linkgl & operator=(const Linkgl & x);
    double get_radius()const{ return radius; } 
    bool get_STL()const{ return STL; } 
    void create_list();
 private:
    bool DH,         
         STL;        
    double a,        
           d,        
           alpha,    
           radius;   
};

class Jointgl : public Basic_object, public STL_obj
{
 friend class Robotgl_basic;
 friend class Robotgl;
 friend class mRobotgl;
 public:
    Jointgl(bool DH = false);
    Jointgl(const std::vector<double> & parameters, const ColumnVector & pos,
            const bool DH = false, const double stl_translation_x=0, 
            const double stl_translation_y=0, const double stl_translation_z=0, 
            const double stl_rotation_x=0, const double stl_rotation_y=0,    
            const double stl_rotation_z=0, const double stl_scalling_x=1,    
            const double stl_scalling_y=1, const double stl_scalling_z=1, 
            const float red=0.5, const float green=0, 
            const float blue=0, const string stl_file="");
    Jointgl(const Jointgl & x);
    ~Jointgl();
    Jointgl & operator=(const Jointgl & x);
    bool get_STL(){ return STL; } 
    void create_list();
 private:
    bool DH,         
         STL;        
    short prismatic; 
    double radius,   
           hight;    
};

class Robotgl_basic: public Basic_object
{
 public:
    Robotgl_basic(const short ndof=1);
    Robotgl_basic(const Robotgl_basic & x);
    virtual ~Robotgl_basic();
    Robotgl_basic & operator=(const Robotgl_basic & x);
    void set_dof(const short dof);
    bool Is_STL();
    void create_list();
    virtual void draw()=0;

    Linkgl *linkgl;   
    Jointgl *jointgl; 
// private:
    short dof;        
    ColumnVector pos; 
    Axis *axis;       
};


class Robotgl : public Robot, public Robotgl_basic
{
 public:
    Robotgl(const short ndof=1);
    Robotgl(const Matrix & initrob, const ColumnVector & position);
    Robotgl(const Matrix & initrob, const Matrix & initrobm, 
            const ColumnVector & position);         
    Robotgl(const string & filename, const string & robotName,
            const ColumnVector & position);
    Robotgl(const Robotgl & x);
    ~Robotgl(){}        
    Robotgl & operator=(const Robotgl & x);
    virtual void draw();
};

class mRobotgl : public mRobot, public Robotgl_basic
{
 public:
    mRobotgl(const short ndof=1);
    mRobotgl(const Matrix & initrob, const ColumnVector & position);
    mRobotgl(const Matrix & initrob, const Matrix & initrobm, 
             const ColumnVector & position);        
    mRobotgl(const string & filename, const string & robotName,
             const ColumnVector & position);
    mRobotgl(const mRobotgl & x);
    ~mRobotgl(){};      
    mRobotgl & operator=(const mRobotgl & x);
    virtual void draw();
};

#endif

---