src/common.h

Go to the documentation of this file.

#pragma once

#include "compiler_options.h"

#include <glew/glew.h>
#include <GL/glu.h>
#include <devil/il.h>

#include <windows.h>
#include <commdlg.h>
#include <stdlib.h>
#include <io.h>
#include <math.h>

#include <iostream>
#include <sstream>
#include <string>


// workaround: incompatibilities with header files
#undef min
#undef max

#define TF_TEXTURE_SIZE 4096

#ifndef PI
        #define PI 3.14159265f
#endif

#define BOUNDARY 0.9125f

#define SLIDER_RANGE           4096   // range for QSlider elements
#define STEP_SLIDER_RANGE          1000   // range for the maximum number of steps for the RC-ray
#define LIGHT_SLIDER_RANGE     100    // range of light settings

#define DENSITY_COUNT          4096   // 4096 different density levels in Volume

#define OPENGL_SLICE_VIEW_SIZE 250  // size of slice-views (width = heigth)
#define OPENGL_3D_VIEW_SIZE    600  // size of 3d-view (width = heigth)

#define NUMBER_OF_GL_WIDGETS 4    // number of glWidgets for independent OpenGL-views
#define OPENGL_3D_VIEW       3    // number of glWidget for 3D-OpenGL-view

#define RENDER_3D_VIEW       3    // render-flag 'on' for glWidget for 3D-OpenGL-view
#define NO_RENDER_3D_VIEW    4    // render-flag 'off' for glWidget for 3D-OpenGL-view

#define SHOW_VOLUME          1    // flag for showing volume in 3D-view
#define SHOW_FRONT_SIDE      2    // flag for showing front-side-cube in 3D-view
#define SHOW_BACK_SIDE       3    // flag for showing back-side-cube in 3D-view


typedef enum AXIS {X_AXIS, Y_AXIS, Z_AXIS} AXIS;        // describes axis better than 0..1..2
typedef enum SHADES {RED, GREEN, BLUE, ALPHA, SHADES_COUNT} SHADES;

typedef enum RENDER_MODE {comp = 0, mip   = 1, fh     = 2, 
                          avg  = 3, avgTF = 4, compPh = 5 } RENDER_MODE; // saved in oglWidget::m_rendermode

typedef enum LIGHT_MODEL {diffuse = 0, ambient, specular, gloss } LIGHT_MODEL;

// converts from string to Type
template <class Type>
inline const Type fromString(const std::string & strString)
{
        Type tValue;
        std::stringstream(std::string(strString)) >> tValue;
        return tValue;
};

// converts from string to Type, returns true if successful
template <class Type>
inline const bool fromString(Type & tValue, const std::string & strString)
{
        Type tTemp;

        std::stringstream ss;
        ss << strString;
        ss >> std::ws;

        if (ss >> tTemp)
        {
                ss >> std::ws;

                if (ss.eof())
                {
                        tValue = tTemp;
                        return true;
                }
        }

        return false;
};

// converts from Type to string
template <class Type>
inline const std::string toString(const Type & tValue)
{
        std::stringstream ss;
        ss << tValue;
        return ss.str();
};

// trims whitespace form the beginning of the string
inline const std::string trimLeft( const std::string &str, const std::string &strWhitespace = "\n\r\t ")
{
        size_t uIndex = str.find_first_not_of(strWhitespace);
        if( uIndex != std::string::npos )
                return str.substr(uIndex);

        return "";
};

// trims whitespace form the end of the string
inline const std::string trimRight( const std::string &str, const std::string &strWhitespace = "\n\r\t ")
{
        size_t  uIndex = str.find_last_not_of(strWhitespace);
        if( uIndex != std::string::npos )
                return str.substr(0,uIndex+1);

        return str;
};

// trims whitespace from beginning and end of the string
inline const std::string trim( const std::string &str, const std::string & strWhitespace = "\n\r\t ")
{
        return trimRight(trimLeft(str,strWhitespace),strWhitespace);
};


// Utility class for STL stream extraction operator
class eat
{
        friend std::istream & operator>>(std::istream &is, eat & e);

public:
        eat(const std::string & strString) : m_strString(strString)
        {
        };

private:
        void process(std::istream & is)
        {
                const unsigned int uLength = unsigned int(m_strString.size());

                if (uLength > 0)
                {
                        char c;
                        unsigned int uIndex = 0;

                        is >> std::ws;
                        std::ios::fmtflags f = is.flags();
                        is.unsetf(std::ios::skipws);

                        do
                        {
                                if (!(is >> c))
                                {
                                        break;
                                }
                                else
                                {
                                        if (c != m_strString[uIndex])
                                        {
                                                is.setstate(std::ios::failbit);
                                                break;
                                        }
                                }
                        }
                        while (++uIndex < uLength);

                        is.flags(f);

                        if (!is.fail())
                                is >> std::ws;
                }
        };

private:
        std::string m_strString;
};

inline std::istream & operator>> (std::istream &is, eat & e)
{
        e.process(is);
        return is;
}

---