VoxelCube.h

Go to the documentation of this file.

#pragma once

#include "../common/standard.h"

#include <list>
#include <map>
#include <vector>
#include <set>

#include "MatrixTypes.h"
#include "Shapes2d.h"
#include "../ProgressiveMeshSupport/QEM_ProgMesh.h"
#include "Viewpoint.h"

typedef struct 
{
    Vertex pos;
    RgbByte color;
} ColorVertex;


class VoxelPos : public Position< 3, unsigned short > 
{
public:
    VoxelPos (unsigned short x, unsigned short y, unsigned short z)
    {
        array[0] = x; 
        array[1] = y; 
        array[2] = z;
    }

    VoxelPos () {}

    bool operator<(const VoxelPos &vp) const
    {
        return (memcmp (this, &vp, sizeof(VoxelPos)) < 0);
    }
};


typedef std::map< VoxelPos, RgbByte > ColorMap;

class ColoredVoxelPos : public VoxelPos
{
public:
    ColoredVoxelPos (VoxelPos &data, RgbByte &clr) 
    { 
        memcpy (array, &data[0], sizeof(array)); color = clr;
    }
    
    RgbByte color;

    bool operator<(const VoxelPos &vp) const
    {
        return (memcmp (this, &vp, sizeof(ColoredVoxelPos)) < 0);
    }
};


class SurfaceVoxelList 
{
public:
    typedef std::list< VoxelPos >::iterator iterator;

    SurfaceVoxelList() {}

    iterator begin() { return voxelList.begin(); }
    
    iterator end() { return voxelList.end(); }
    
    void push_back (VoxelPos p)
    {
        if (voxelSet.find(p) == voxelSet.end())
        {
            voxelList.push_back(p);
            voxelSet.insert(p);
        }
    }

    unsigned int size()
    {
        return voxelSet.size();
    }

    iterator erase(iterator &i)
    {

        VoxelPos &p = *i;
        voxelSet.erase(p);
        return voxelList.erase(i);
    }

    void clear()
    {
        voxelSet.clear();
        voxelList.clear();
    }

private:
    std::set< VoxelPos > voxelSet;
    std::list< VoxelPos > voxelList;
};


// this will be the final product, composed at the end
typedef std::vector< ColoredVoxelPos > ColoredSurfaceVoxelList;


class VoxelCube 
{
public:
    void draw(bool bTranslateToCenter);

/*
 * Accessors
 */
    double getMinimumFarPlane (Vertex COP, Vertex lookatPoint) const;

    bool     isTransparent (int x, int y, int z) const;
    bool     isTransparent (const VoxelPos &p) const;

    int      getVoxelsPerSide()                  const { return voxelsPerSide; }

    void fillItemBufferArray (Viewpoint &image);

    std::vector< Vertex > calculateVoxelCorners (int x, int y, int z) const;

    Rect< double > getBoundingRect (std::vector< Vertex > &vertices, const double modelMatrix[16], const double projMatrix[16], const int viewport[4]) const;

    unsigned int PosToIdentifier (int x, int y, int z) const;

    unsigned int PosToIndex (int x, int y, int z) const;

    Vertex getCenter() const { return center; }

    double getVoxelSize () const { return voxelSize; }

    unsigned int GetEdgeID(unsigned int nX, unsigned int nY, unsigned int nZ, unsigned int nEdgeNo);

/*
 * Methods
 */
    void setFinalColor (SurfaceVoxelList::iterator i, RgbByte &color);

/*
 * Mutators
 */
    void setVoxelsPerSide (int vps);

    void exposeSurroundingVoxels (SurfaceVoxelList::iterator i);

    void VoxelCube::setTransparent(SurfaceVoxelList::iterator i);


    void setCenter (Vertex new_center) { center = new_center; }
   

    void setVoxelSize (double voxel_size)
    {
        if (voxel_size <= 0)
            throw ArgError("VoxelCube::setVoxelSize(): you can't set a voxel to a size <= 0.");

        voxelSize = voxel_size;
    }

    void makeMesh(float isoLevel, QEM::ProgMesh &mesh);

    SurfaceVoxelList svl;
private:
    ColorVertex calculateIntersection(ColVector< 3, unsigned int> &curOrigin, unsigned int nEdgeNo, float isoLevel, ColorMap &colorMap);
    ColoredSurfaceVoxelList svlColored;
    void constructColorMap (ColorMap &colorMap);
    Vertex center;
    double voxelSize;
    int voxelsPerSide;

    typedef std::vector< bool > OpaqueLookupTable;


    OpaqueLookupTable solids;
};

---