cbviz_util.H

Go to the documentation of this file.

// Copyright (C) 2005 Pablo Mejia
// Copyright (C) 2004 University of Louisiana at Lafayette
// Authors: Suresh Golconda, Nitin, Arun Pratap, Pablo Mejia

#ifndef CAJUN_SIM_UTIL_H
#define CAJUN_SIM_UTIL_H

#define REAL2SIM_DIST_RATIO 1
#define SIM2REAL_DIST_RATIO 1/REAL2SIM_DIST_RATIO

#define POSX 0
#define POSY 1
#define POSZ 2

#define ANGLEX 0
#define ANGLEY 1
#define ANGLEZ 2

#include "data_type.H"
#include "milkshapeModel.H"
#include "cb_time.H"
#include <cstring>
#include <string>
#include <vector>

namespace cajun
{
        struct color_node_t
        {
                double r;
                double g;
                double b;
        };

        class chart_color_t
        {
                double m_r, m_g, m_b;
        public:
                chart_color_t () {};
                chart_color_t (double red, double green, double blue)
                        {
                                set (red, green, blue);
                        }
                double red () { return m_r; };
                double blue () { return m_b; };
                double green () { return m_g; };

                void set (double red, double green, double blue)
                        {
                                m_r = red;
                                m_g = green;
                                m_b = blue;
                        };
                void select ()
                        {
                                glColor3f (m_r, m_g, m_b);
                        };
        };

        static chart_color_t white_color (1, 1, 1);
        static chart_color_t red_color (1, 0, 0);
        static chart_color_t green_color (0, 1, 0);
        static chart_color_t blue_color (0, 0, 1);
        static chart_color_t black_color (0, 0, 0);
        static chart_color_t grey_color (0.3, 0.3, 0.3);
        static chart_color_t light_grey_color (0.5, 0.5, 0.5);
        static chart_color_t color011 (0, 1, 1);
        static chart_color_t color101 (1, 0, 1);
        static chart_color_t color110 (1, 1, 0);

        static chart_color_t grid_line_color = blue_color;
        static chart_color_t chart_boundary_color = red_color;
        static chart_color_t road_color[2] =
        {
                chart_color_t (0.3, 0.3, 0.3),          // PRIMARY
                chart_color_t (0.6, 0.6, 0.6)           // SECONDARY
        };

        void draw_axes (double length);
        void color_contour (double value, double max_value,
                            double &r, double &g, double &b);
        void color_contour (double value, double max_value,
                            unsigned char &r, unsigned char &g,
                            unsigned char &b);

        void color_gradient (double value, double max_value,
                             double &r, double &g, double &b);
        void color_gradient (double value, double max_value,
                             unsigned char &r, unsigned char &g,
                             unsigned char &b);
        void color_gradient (double value, double max_value,
                             unsigned short &r, unsigned short &g,
                             unsigned short &b);

// Color coding in a cyclic form, switching between 100->010->001. Each of the
// transformation interval is provided as argument, (interval), similar
// starting point for red (100) is ref_r
        void color_gradient (double value, double interval, double ref_r,
                             unsigned short &r, unsigned short &g,
                             unsigned short &b);

        void split_filename (const char *filename,
                             char* dirname, unsigned dirsize,
                             char *filepart, unsigned fpartsize);

        bool loadMilkshapeModelData ( Model *pModel, const char *filename);
        void load_ppm_p6 (char *fname, unsigned int *w, unsigned int *h,
                          unsigned char **data, int mallocflag);
        void load_ppm_p3 (char *fname, unsigned int *w, unsigned int *h,
                          unsigned char **data, int mallocflag);
        bool read_ppm_texture (const char *fname,
                               unsigned char*& image_data_,
                               unsigned &width_, unsigned &height_);
        GLuint setup_ppm_texture (const unsigned char *image_data_,
                                  unsigned width_, unsigned height_);
        GLuint setup_ppm_texture (const char *fname);
        void Normal_Plane (float v[3],float x[3],float y[3],float z[3]);
        void Render_Polygon (float v[4][3],float color[3],
                             int texon, char *ppmname);
        void Render_Quadric (int type,float radius,float outerradius,
                             float length,chart_color_t color,
                             int texon, char *ppmname);
        void draw_cylinder (double  radius, double  height);
        void draw_sphere (double radius);
        void Render_box (float dimensions[3],float color[3],
                         int texon, char *ppmname);
        void Render_Ground (float size,float color[3],int texon,char *ppmname);
        void Render_Sky (float size,float color[3],int texon,char *ppmname);
        void get_rotation_matrix (double rot[16],
                                  double heading, double pitch, double roll);
        void output_text (int posx,int posy,int posz, char const *str);
        void output_text (int posx, int posy, char const *str);
        void output_text (double posx, double posy, double posz, char const *str);
        void output_string_number (int posx, int posy, std::string num);
        void output_string_number (double posx, double posy, double posz,
                                   std::string num);
        void output_int_number (int posx,int posy, int posz, int num);
        void output_float_number (int posx,int posy,double num);
        void output_float_number (double posx, double posy, double posz,
                                  double num);
        void output_int_number (double posx, double posy, double posz, int num);
        void draw_cube (double dimensions[3]);
        void draw_square (double x, double y, double square_length);
        void draw_line (double x1, double y1, double z1, double x2, double y2,
                        double z2 );
        void draw_rectangle (double x1, double y1, double x2, double y2,
                             double height, cajun::chart_color_t color);
        void draw_filled_rectangle (double x1, double y1, double x2, double y2,
                                    double height, cajun::chart_color_t color);
        void draw_circle (double x, double y, double height, double radius,
                          chart_color_t color);
        void draw_leg (float a1, float b1, float a2, float b2, float w);
        void draw_flag (double x, double y, double bot_z);
        bool IsGLExtensionSupported (const char* szTargetExtension);
        void calculate_normal (tri_ver_t &tri_ver_, float &x_,
                               float &y_, float &z_);

        extern char const *progname;
};
#endif

---