RTVolumeRendering/Source/VolumeTexture.cpp

Go to the documentation of this file.

#include <assert.h>
#include <stdlib.h>
#include <fstream>
#include <sstream>
#include <string>
#include "Error.h"
#include "VolumeTexture.h"

//----------------------------------------------------------
VolumeTexture::VolumeTexture() : tex(0), boundUnit(-1) 
{
        memset((void*)histogram, 0, sizeof(unsigned int)*256);
}

//----------------------------------------------------------
VolumeTexture::~VolumeTexture()
{
        if(tex)
                glDeleteTextures(1, &tex);
}

//----------------------------------------------------------
bool VolumeTexture::Load(const char *file, const char *path, VTInfo *info)
{
        std::string fullPath = path;
        fullPath += file;
        
        std::ifstream f(fullPath.c_str());
        if(!f.is_open())
        {
                std::stringstream msg;
                msg << "The Volume Texture Description file could not be opened: " << file;
                ErrorMessage(msg.str().c_str());
                return false;
        }

        // Skips leading comments
        std::string line;
        do
        {
                getline(f, line);
        } while(f.good() && line.length() > 0 && line[0] == '#');

        unsigned int version, width, height, depth, components;
        std::string type, filename;

        std::istringstream read1(line);
        if( (read1 >> version).fail() )
        {
                std::stringstream msg;
                msg << "Version number could not be read: " << file;
                ErrorMessage(msg.str().c_str());
                return false;
        }
        
        if(version != 1)
        {
                std::stringstream msg;
                msg << "The Volume Texture Description file version '" << version << "' is not supported: " << file;
                ErrorMessage(msg.str().c_str());
                return false;
        }
        
        if(!getline(f, line))
        {
                std::stringstream msg;
                msg << "Unexpected end of file: " << file;
                ErrorMessage(msg.str().c_str());
                return false;
        }
        
        std::istringstream read2(line);
        if( (read2 >> width).fail() ||
            (read2 >> height).fail() ||
            (read2 >> depth).fail() ||
            (read2 >> components).fail() )
        {
                std::stringstream msg;
                msg << "Size data could not be read: " << file;
                ErrorMessage(msg.str().c_str());
                return false;
        }
        
        if(components < 1 || components > 2)
        {
                std::stringstream msg;
                msg << "The number of components must be 1 or 2: " << file;
                ErrorMessage(msg.str().c_str());
                return false;
        }
        
        if(!getline(f, line))
        {
                std::stringstream msg;
                msg << "Unexpected end of file: " << file;
                ErrorMessage(msg.str().c_str());
                return false;
        }

        std::istringstream read3(line);
        if( (read3 >> type).fail() || (read3 >> filename).fail() )
        {
                std::stringstream msg;
                msg << "File type could not be read: " << file;
                ErrorMessage(msg.str().c_str());
                return false;
        }
        
        if(type == "RAW")
        {
                std::string newPath = path;
                newPath += filename;
                
                if( !LoadRAW(newPath.c_str(), width, height, depth, components) )
                        return false;
                
                loadedVTinfo.width      = width;
                loadedVTinfo.height     = height;
                loadedVTinfo.depth      = depth;
                loadedVTinfo.components = components;
                loadedVTinfo.size       = width * height * depth * components;
                
                if(info)
                        *info = loadedVTinfo;
                
                return true;
        }

        std::stringstream msg;
        msg << "Unsuported image type '" << type << "': " << file;
        ErrorMessage(msg.str().c_str());
        return false;
}

//----------------------------------------------------------
bool VolumeTexture::LoadRAW(const char *filename, int w, int h, int d, int components)
{
        if(components != 1)
                return false;

        std::ifstream f(filename, std::ios::in | std::ios::binary);
        if(!f.is_open())
        {
                std::string msg = "The Volume Texture could not be opened: ";
                msg += filename;
                ErrorMessage(msg.c_str());
                return false;
        }
        
        int size = w*h*d*components;
        unsigned char *data = new unsigned char[size];
        f.read((char*)data, size);

        // Pads the data with zeros to avoid streaching.
        int dim = std::max(w, std::max(h, d));
        int paddSize = dim*dim*dim;
        unsigned char *image = new unsigned char[paddSize*4];
        memset(image, 0, sizeof(unsigned char)*paddSize*4);
        
        int offset = ((dim - d) / 2) * w * h * 4;

        Precompute(data, w, h, d, image + offset);

        delete [] data;

        if(tex)
                glDeleteTextures(1, &tex);
        
        glGenTextures(1, &tex);
        glBindTexture(GL_TEXTURE_3D, tex);
        glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
        glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
        glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_S, GL_CLAMP);
        glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_T, GL_CLAMP);
        glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_R, GL_CLAMP);

        glTexImage3D(GL_TEXTURE_3D, 0, GL_RGBA, dim, dim, dim, 0, GL_RGBA, GL_UNSIGNED_BYTE, (GLvoid*)image);

        glBindTexture(GL_TEXTURE_3D, 0);
        
        delete [] image;
        
        return true;
}

//----------------------------------------------------------
void VolumeTexture::Precompute(const unsigned char *data, int w, int h, int d, unsigned char *res)
{
        memset((void*)histogram, 0, sizeof(unsigned int)*256);

        for(int k = 0; k < d; k++)
        {
                for(int j = 0; j < h; j++)
                {
                        for(int i = 0; i < w; i++)
                        {
                                Vector3f n = ComputeNormal(data, i, j, k, w, h, d);

                                // convets the normal into an int in the range [0,255]
                                int x = (int)((n.x + 1.0f) * 127.0f);
                                int y = (int)((n.y + 1.0f) * 127.0f);
                                int z = (int)((n.z + 1.0f) * 127.0f);

                                int dataValue = data[i + j*w + k*w*h];
                                histogram[dataValue]++;

                                int index = 4*(i + w*(j + k*h)); // i*4 + j*w*4 + k*w*h*4
                                res[index] = dataValue;
                                res[index + 1] = (unsigned char)x;
                                res[index + 2] = (unsigned char)y;
                                res[index + 3] = (unsigned char)z;
                        }
                }
        }
}

//----------------------------------------------------------
Vector3f VolumeTexture::ComputeNormal(const unsigned char *data, int x, int y, int z, int w, int h, int d)
{
        int x0 = std::min(x + 1, w - 1); 
        int x1 = std::max(x - 1, 0);

        float dx = (data[x0 + y*w + z*w*h] - data[x1 + y*w + z*w*h]) / 2.0f;

        int y0 = std::min(y + 1, h - 1); 
        int y1 = std::max(y - 1, 0);

        float dy = (data[x + y0*w + z*w*h] - data[x + y1*w + z*w*h]) / 2.0f;

        int z0 = std::min(z + 1, d - 1); 
        int z1 = std::max(z - 1, 0);

        float dz = (data[x + y*w + z0*w*h] - data[x + y*w + z1*w*h]) / 2.0f;

        Vector3f g(dx, dy, dz);
        if(g.SquaredLength() == 0.0f)
                return g;

        return -Normalize(g);
}

//----------------------------------------------------------
int VolumeTexture::CopyHistogram(unsigned int *data, int n)
{
        int i;

        for(i = 0; i < 256 && i < n; i++)
        {
                data[i] = histogram[i];
        }

        return 256 - i;
}

//----------------------------------------------------------
void VolumeTexture::Bind(int unit)
{
        if(unit < 0 || unit > GL_MAX_TEXTURE_UNITS)
                return;

        if(boundUnit != -1)
                return; // we are already bound to a texture unit

        glActiveTexture(GL_TEXTURE0 + unit);
        glBindTexture(GL_TEXTURE_3D, tex);

        boundUnit = unit;
}

//----------------------------------------------------------
void VolumeTexture::UnBind()
{
        if(boundUnit != -1)
        {
                glActiveTexture(GL_TEXTURE0 + boundUnit);
                glBindTexture(GL_TEXTURE_3D, 0);

                boundUnit = -1;
        }
}

---