qwt3d_types.h

#if defined(_MSC_VER) /* MSVC Compiler */
#pragma warning(disable : 4786)
#endif
 
#ifndef __DATATYPES_H__
#define __DATATYPES_H__
 
#ifdef _DEBUG
#include <fstream>
#endif
 
#include <string>
 
#include "qwt3d_global.h"
 
#if defined(Q_OS_WIN)
#include <windows.h>
#endif
 
#ifndef WHEEL_DELTA
#define WHEEL_DELTA 120
#endif
 
#include "qwt3d_portability.h"
#include "qwt3d_helper.h"
#include "qwt3d_openglhelper.h"
#include <QColor>
 
namespace Qwt3D
{
 
const double PI = 3.14159265358979323846264338328;
 
enum PLOTSTYLE
{
    NOPLOT,      // No visible data
    WIREFRAME,   // Wireframe style
    HIDDENLINE,  // Hidden Line style
    FILLED,      // Color filled polygons w/o edges
    FILLEDMESH,  // Color filled polygons w/ separately colored edges
    POINTS,      // User defined style (used by Enrichments)
    USER         // User defined style (used by Enrichments)
};
 
enum SHADINGSTYLE
{
    FLAT,    // Flat shading (OpenGL)
    GOURAUD  // Gouraud Shading (OpenGL)
};
 
enum COORDSTYLE
{
    NOCOORD,  // Coordinate system is not visible
    BOX,      // Boxed
    FRAME     // Frame - 3 visible axes
};
 
enum SCALETYPE
{
    LINEARSCALE,  // Linear scaling
    LOG10SCALE,   // Logarithmic scaling (base 10)
    USERSCALE     // User-defined (for extensions)
};
 
enum FLOORSTYLE
{
    NOFLOOR,   // Empty floor
    FLOORISO,  // Isoline projections visible
    FLOORDATA  // Projected polygons visible
};
 
enum DATATYPE
{
    GRID,    // Rectangular grid
    POLYGON  // Convex polygon
};
 
enum AXIS
{
    X1 = 0,   // 1st x-axis
    X2 = 3,   // 2nd x-axis
    X3 = 4,   // 3rd x-axis
    X4 = 5,   // 4th x-axis
    Y1 = 1,   // 1st y-axis
    Y2 = 8,   // 2nd y-axis
    Y3 = 7,   // 3rd y-axis
    Y4 = 6,   // 4th y-axis
    Z1 = 2,   // 1st z-axis
    Z2 = 9,   // 2nd z-axis
    Z3 = 11,  // 3rd z-axis
    Z4 = 10   // 4th z-axis
};
 
enum SIDE
{
    NOSIDEGRID = 0,
    LEFT       = 1 << 0,
    RIGHT      = 1 << 1,
    CEIL       = 1 << 2,
    FLOOR      = 1 << 3,
    FRONT      = 1 << 4,
    BACK       = 1 << 5
};
 
enum ANCHOR
{
    BottomLeft,
    BottomRight,
    BottomCenter,
    TopLeft,
    TopRight,
    TopCenter,
    CenterLeft,
    CenterRight,
    Center
};
 
struct QWT3D_EXPORT Tuple
{
    // Calls Tuple(0,0)
    Tuple() : x(0), y(0)
    {
    }
    // Initialize Tuple with x and y
    Tuple(double X, double Y) : x(X), y(Y)
    {
    }
    // Tuple coordinates
    double x, y;
};
 
struct QWT3D_EXPORT Triple
{
    // Initialize Triple with x,y and z
    explicit Triple(double xv = 0, double yv = 0, double zv = 0) : x(xv), y(yv), z(zv)
    {
    }
 
#ifndef QWT3D_NOT_FOR_DOXYGEN
#ifdef Q_OS_IRIX
    Triple(const Triple& val)
    {
        if (&val == this)
            return;
        x = val.x;
        y = val.y;
        z = val.z;
    }
    const Triple& operator=(const Triple& val)
    {
        if (&val == this)
            return *this;
        x = val.x;
        y = val.y;
        z = val.z;
        return *this;
    }
#endif
#endif  // QWT3D_NOT_FOR_DOXYGEN
 
    // Triple coordinates
    double x, y, z;
 
    Triple& operator+=(Triple t)
    {
        x += t.x;
        y += t.y;
        z += t.z;
 
        return *this;
    }
 
    Triple& operator-=(Triple t)
    {
        x -= t.x;
        y -= t.y;
        z -= t.z;
 
        return *this;
    }
    Triple& operator*=(double d)
    {
        x *= d;
        y *= d;
        z *= d;
 
        return *this;
    }
    Triple& operator/=(double d)
    {
        x /= d;
        y /= d;
        z /= d;
 
        return *this;
    }
    Triple& operator*=(Triple t)  // scale
    {
        x *= t.x;
        y *= t.y;
        z *= t.z;
 
        return *this;
    }
 
    bool operator!=(Triple t) const
    {
        return !isPracticallyZero(x, t.x) || !isPracticallyZero(y, t.y) || !isPracticallyZero(z, t.z);
    }
 
    bool operator==(Triple t) const
    {
        return !operator!=(t);
    }
 
    double length() const
    {
        double l2 = x * x + y * y + z * z;
        return (isPracticallyZero(l2)) ? 0 : sqrt(l2);
    }
 
    void normalize()
    {
        double l = length();
        if (l)
            *this /= l;
    }
};
 
inline const Triple operator+(const Triple& t, const Triple& t2)
{
    return Triple(t) += t2;
}
inline const Triple operator-(const Triple& t, const Triple& t2)
{
    return Triple(t) -= t2;
}
inline const Triple operator*(double d, const Triple& t)
{
    return Triple(t) *= d;
}
inline const Triple operator*(const Triple& t, double d)
{
    return Triple(t) *= d;
}
inline const Triple operator/(double d, const Triple& t)
{
    return Triple(t) /= d;
}
inline const Triple operator/(const Triple& t, double d)
{
    return Triple(t) /= d;
}
inline const Triple operator*(const Triple& t, const Triple& t2)
{
    return Triple(t) *= t2;
}
 
struct QWT3D_EXPORT ParallelEpiped
{
    // Construct non-initialized Parallelepiped
    ParallelEpiped()
    {
    }
 
    // Construct initialized Parallelepiped: minv -> minVertex, maxv -> maxVertex
    ParallelEpiped(Triple minv, Triple maxv) : minVertex(minv), maxVertex(maxv)
    {
    }
 
    Triple minVertex;
    Triple maxVertex;
};
 
struct QWT3D_EXPORT FreeVector
{
    FreeVector()
    {
    }
 
    // Construct initialized vector: b -> base, e -> top
    FreeVector(Triple b, Triple t) : base(b), top(t)
    {
    }
 
    Triple base;
    Triple top;
};
 
using FreeVectorField = std::vector< FreeVector >;
 
using TripleField = std::vector< Triple >;
 
using Cell = std::vector< unsigned >;
 
using CellField = std::vector< Cell >;
 
// Returns the sum over the sizes of the single cells
unsigned tesselationSize(Qwt3D::CellField const& t);
 
struct QWT3D_EXPORT RGBA
{
    RGBA() : r(0), g(0), b(0), a(1)
    {
    }
    RGBA(double rr, double gg, double bb, double aa = 1) : r(rr), g(gg), b(bb), a(aa)
    {
    }
    double r, g, b, a;
};
 
using ColorVector = std::vector< RGBA >;
 
#ifndef QWT3D_NOT_FOR_DOXYGEN
 
// RGB -> QColor
QWT3D_EXPORT QColor GL2Qt(GLdouble r, GLdouble g, GLdouble b);
// QColor -> RGBA
QWT3D_EXPORT Qwt3D::RGBA Qt2GL(QColor col);
 
using Vertex     = double*;
using DataRow    = std::vector< Vertex >;
using DataMatrix = std::vector< DataRow >;
 
class Data
{
public:
    Qwt3D::DATATYPE datatype;
    Data()
    {
        datatype = Qwt3D::POLYGON;
    }
    virtual ~Data()
    {
    }
    // Destroy content
    virtual void clear()       = 0;
    // No data
    virtual bool empty() const = 0;
    void setHull(Qwt3D::ParallelEpiped const& h)
    {
        hull_p = h;
    }
    Qwt3D::ParallelEpiped const& hull() const
    {
        return hull_p;
    }
 
protected:
    Qwt3D::ParallelEpiped hull_p;
};
 
class GridData : public Data
{
public:
    GridData();
    // See setSize()
    GridData(unsigned int columns, unsigned int rows);
    ~GridData()
    {
        clear();
    }
 
    int columns() const;
    int rows() const;
 
    // Destroy content
    void clear();
    bool empty() const
    {
        return vertices.empty();
    }
    // Destroys content and set new size, elements are uninitialized
    void setSize(unsigned int columns,
                 unsigned int rows);
 
    // Mesh vertices
    DataMatrix vertices;
    // Mesh normals
    DataMatrix normals;
    void setPeriodic(bool u, bool v)
    {
        uperiodic_ = u;
        vperiodic_ = v;
    }
    bool uperiodic() const
    {
        return uperiodic_;
    }
    bool vperiodic() const
    {
        return vperiodic_;
    }
 
private:
    bool uperiodic_, vperiodic_;
};
 
class CellData : public Data
{
public:
    CellData()
    {
        datatype = Qwt3D::POLYGON;
    }
    ~CellData()
    {
        clear();
    }
 
    // Destroy content
    void clear();
    bool empty() const
    {
        return cells.empty();
    }
 
    Triple const& operator()(unsigned cellnumber, unsigned vertexnumber);
 
    // Polygon/cell mesh
    CellField cells;
    TripleField nodes;
    // Mesh normals
    TripleField normals;
};
 
inline Triple normalizedcross(Triple const& u, Triple const& v)
{
    Triple n;
 
    /* compute the cross product (u x v for right-handed [ccw]) */
    n.x = u.y * v.z - u.z * v.y;
    n.y = u.z * v.x - u.x * v.z;
    n.z = u.x * v.y - u.y * v.x;
 
    /* normalize */
    double l = n.length();
    if (l) {
        n /= l;
    } else {
        n = Triple(0, 0, 0);
    }
 
    return n;
}
 
inline double dotProduct(Triple const& u, Triple const& v)
{
    return u.x * v.x + u.y * v.y + u.z * v.z;
}
 
void convexhull2d(std::vector< unsigned >& idx, const std::vector< Qwt3D::Tuple >& src);
 
#endif  // QWT3D_NOT_FOR_DOXYGEN
 
}  // ns
 
#endif