VolumeBuffer.cpp

#include <math.h>
#include <GL/glew.h>
#include <Cg/cgGL.h>
#include <stdio.h>

#include "VolumeBuffer.h"

#ifdef _WIN32
#include<windows.h>
#else
#include <string.h>
#endif

VolumeBuffer::VolumeBuffer(GLint format, int width, int height, int depth, int banks)
    : m_width(width),
      m_height(height),
      m_depth(depth),
      m_banks(banks),
      m_blendMode(BLEND_NONE)
{
        m_volume_size = m_width*m_height*m_depth;
        m_volume_data_raw = new unsigned char [m_volume_size];
        m_volume_data_rgba = new unsigned char [m_volume_size*4];

        m_volume_file_name = new char[FILE_NAME_LENGTH];

        //allocate memory for histogram
        m_histogram_bin_count = HISTOGRAM_BIN_COUNT;
        m_histogram = (unsigned int *)malloc(HISTOGRAM_SIZE);

        memset(m_volume_data_raw,0,m_volume_size*sizeof(unsigned char));
        memset(m_volume_data_rgba,0,m_volume_size*4*sizeof(unsigned char));

        //clear histogram to zeros
        memset(m_histogram,0,HISTOGRAM_SIZE);

    glGetIntegerv(GL_MAX_COLOR_ATTACHMENTS_EXT, &m_max_banks);
    if (m_banks > m_max_banks) m_banks = m_max_banks;

    // create textures
    m_tex = new GLuint [m_banks];
    for(int i=0; i<m_banks; i++) {
        m_tex[i] = create3dTexture(format, m_width, m_height, m_depth);
    }
}

VolumeBuffer::~VolumeBuffer()
{
    //delete m_fbo;
    for(int i=0; i<m_banks; i++) {
        glDeleteTextures(1, &m_tex[i]);
    }
    delete [] m_tex;
        delete [] m_volume_data_raw;
        delete [] m_volume_data_rgba;

        delete [] m_histogram;
        delete [] m_volume_file_name;
}

GLuint
VolumeBuffer::create3dTexture(GLint internalformat, int w, int h, int d)
{
    GLuint 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);
    GLint mode = GL_CLAMP_TO_BORDER;
    glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_S, mode);
    glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_T, mode);
    glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_R, mode);
        glTexImage3D(GL_TEXTURE_3D, 0, GL_RGBA, w, h, d, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
    return tex;
}

void
VolumeBuffer::setWrapMode(GLint mode, int bank)
{
    glBindTexture(GL_TEXTURE_3D, m_tex[bank]);
    glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_S, mode);
    glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_T, mode);
    glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_R, mode);
}

void
VolumeBuffer::setFiltering(GLint mode, int bank)
{
    glBindTexture(GL_TEXTURE_3D, m_tex[bank]);
    glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MIN_FILTER, mode);
    glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MAG_FILTER, mode);
}

void
VolumeBuffer::setData(unsigned char *data, int bank)
{
    glBindTexture(GL_TEXTURE_3D, m_tex[bank]);
        glTexImage3D(GL_TEXTURE_3D, 0, GL_RGBA, m_width, m_height, m_depth, 0 , GL_RGBA, GL_UNSIGNED_BYTE, data);
}

// draw a slice of the volume
void
VolumeBuffer::drawSlice(float z)
{
    glBegin(GL_QUADS);
    glTexCoord3f(0.0f, 0.0f, z); glVertex2f(-1.0f, -1.0f);
    glTexCoord3f(1.0f, 0.0f, z); glVertex2f(1.0f, -1.0f);
    glTexCoord3f(1.0f, 1.0f, z); glVertex2f(1.0f, 1.0f);
    glTexCoord3f(0.0f, 1.0f, z); glVertex2f(-1.0f, 1.0f);
    glEnd();
}

int
VolumeBuffer::readRawFile(char *filename)
{
        FILE *fp = fopen(filename, "rb");
    
        if (!fp) {
        fprintf(stderr, "Error opening file '%s'\n", filename);
        return 0;
    }

        size_t read = fread(m_volume_data_raw, sizeof(unsigned char), m_volume_size, fp);
        fclose(fp);

        int i, j, k, c;
        
        for (i = 0; i < m_depth; i++) {
                for (j = 0; j < m_height; j++) {
                        for (k = 0; k < m_width; k++) {
                                
                                c = m_volume_data_raw[(m_height*m_width)*i + (m_width)*j + k];
                            
                                m_volume_data_rgba[(m_height*m_width)*i*4 + ((m_width)*j + k)*4 + 0] = (GLubyte) c;
                                m_volume_data_rgba[(m_height*m_width)*i*4 + ((m_width)*j + k)*4 + 1] = (GLubyte) c;
                                m_volume_data_rgba[(m_height*m_width)*i*4 + ((m_width)*j + k)*4 + 2] = (GLubyte) c;
                                m_volume_data_rgba[(m_height*m_width)*i*4 + ((m_width)*j + k)*4 + 3] = (GLubyte) 255;
                        }
                }
        }

    printf("Read '%s', %d bytes\n", filename, read);

        updateHistogram();

}

void VolumeBuffer::updateHistogram()
{
        int i;

        printf("updating histogram...\n");

        //clear histogram
    for(i = 0; i < HISTOGRAM_BIN_COUNT; i++)
        {
        m_histogram[i] = 0;
        }

        int h_index;
        
        //read data and update histogram
        for(i = 0; i < m_volume_size; i++)
        {
                h_index = m_volume_data_raw[i];
                m_histogram[h_index]++;
        }

        /*
        printf("histogram: ");
    for(i = 0; i < HISTOGRAM_BIN_COUNT; i++)
        {
        printf("%d ", m_histogram[i]);
        }
        printf("\n");
        */
}

void VolumeBuffer::setVolumeFileName(char *file_name)
{
        strcpy(m_volume_file_name, file_name);
}

---