Eigene Dateien/Vis/src/VVolume.cpp

Go to the documentation of this file.

#include "VVolume.h"
#include "glew.h"
#include <fstream>
#include <iostream>

#define HISTOGRAM2D_RESOLUTION 1024*1024*4
#define HISTOGRAM2D_RESOLUTION_X 1024
#define HISTOGRAM2D_RESOLUTION_Y 1024


VVolume::VVolume() : 
                                                m_GLVolumeHandle(0), 
                                                m_DimX(0), 
                                                m_DimY(0), 
                                                m_DimZ(0), 
                                                m_maxdensity(0.0f),
                                                m_VolumeFilePath(""),  
                                                m_ModelMatrix(), 
                                                m_NormalMatrix()
{
        m_Histogram.resize(0);
        m_VolumeData.resize(0);

        m_histogram2d_texture.resize(HISTOGRAM2D_RESOLUTION);
        
}

VVolume::VVolume(std::string filepath) : 
                                                m_GLVolumeHandle(0), 
                                                m_DimX(0), 
                                                m_DimY(0), 
                                                m_DimZ(0), 
                                                m_maxdensity(0.0f),
                                                m_VolumeFilePath(filepath), 
                                                m_ModelMatrix(), 
                                                m_NormalMatrix()
{
        m_Histogram.resize(0);
        m_VolumeData.resize(0);
        int size[3];
        this->loadVolume(m_VolumeFilePath, size);

        m_histogram2d_texture.resize(HISTOGRAM2D_RESOLUTION);
        
}

VVolume::~VVolume()
{
        clear();

        m_histogram2d_texture.clear();
}

bool VVolume::loadVolume(std::string filepath, int *data)
{

        std::string fileend = filepath.substr(filepath.size()-5, filepath.size()-1);
        if(fileend.compare(".gdat") == 0)
        {
                return this->loadGDat(filepath, data);
        }
        
        fileend = filepath.substr(filepath.size()-4, filepath.size()-1);
        if(fileend.compare(".dat") == 0)
        {
                return this->loadDat(filepath, data);
        }
        return false;
}

bool VVolume::saveVolume(std::string filepath)
{
        if(filepath == "")
        {
                return true;
        }
        FILE *fp = NULL;

        std::cout << "Saving Volume File: " << filepath << std::endl;

        fopen_s(&fp,filepath.c_str(),"wb");

        if(!fp)
        {
                return false;
        }

        fwrite(reinterpret_cast<char*>(&m_DimX), sizeof(int), 1,fp);
        fwrite(reinterpret_cast<char*>(&m_DimY), sizeof(int), 1,fp);
        fwrite(reinterpret_cast<char*>(&m_DimZ), sizeof(int), 1,fp);

        for(int i = 0; i < m_DimZ; ++i)
        {
                for(int j = 0; j < m_DimY; ++j)
                {
                        for (int k = 0; k < m_DimX; ++k)
                        {
                                fwrite(reinterpret_cast<char*>(m_VolumeData[k + j * m_DimX + i * m_DimX * m_DimY].getDataPtr()), sizeof(float), 1,fp);
                                fwrite(reinterpret_cast<char*>(m_VolumeData[k + j * m_DimX + i * m_DimX * m_DimY].getGradientPtr()), sizeof(float), 3,fp);
                        }
                }
                std::cout << "\rSaving Data(" << (i*100)/(m_DimZ-1) << "%) ... ";
        }

        std::cout << "Saving Histograms" << std::endl;

        fwrite(reinterpret_cast<char*>(&m_Histogram[0]), sizeof(int), 4096,fp);
        

        unsigned int histsizex = HISTOGRAM2D_RESOLUTION_X;
        unsigned int histsizey = HISTOGRAM2D_RESOLUTION_Y;
        unsigned int numchannel = HISTOGRAM2D_RESOLUTION / (histsizey * histsizex);


        fwrite(reinterpret_cast<char*>(&histsizex), sizeof(unsigned int), 1,fp);
        fwrite(reinterpret_cast<char*>(&histsizey), sizeof(unsigned int), 1,fp);
        fwrite(reinterpret_cast<char*>(&numchannel), sizeof(unsigned int), 1,fp);
        fwrite(reinterpret_cast<char*>(&m_histogram2d_texture[0]), sizeof(unsigned char), HISTOGRAM2D_RESOLUTION, fp);

        fclose(fp);
        std::cout << std::endl << "Saving Volume Data Finished" << std::endl;
        return true;
}

int VVolume::getDimX()
{
        if (!GLEW_ARB_texture_non_power_of_two)
        {
                return getNextPowerOfTwo(m_DimX);
        }
        return m_DimX;
}

int VVolume::getDimY()
{
        if (!GLEW_ARB_texture_non_power_of_two)
        {
                return getNextPowerOfTwo(m_DimY);
        }
        return m_DimY;
}

int VVolume::getDimZ()
{
        if (!GLEW_ARB_texture_non_power_of_two)
        {
                return getNextPowerOfTwo(m_DimZ);
        }
        return m_DimZ;
}

bool VVolume::bindVolumeInOpenGL()
{
        std::cout << "Binding Volume in OpenGl" << std::endl;
        
        GLenum glError = GL_NO_ERROR;
        glGenTextures(1, &m_GLVolumeHandle);

        if (glError != GL_NO_ERROR)
        {
                std::cout << "Error generating texture " << gluErrorString(glError) << std::endl;
                return false;
        }

        glEnable(GL_TEXTURE_3D);
        glBindTexture(GL_TEXTURE_3D, m_GLVolumeHandle);

        float vfBorderColor[4] = {0.0f, 0.0f, 0.0f, 0.0f};
        glTexParameterfv(GL_TEXTURE_3D_EXT, GL_TEXTURE_BORDER_COLOR, vfBorderColor);

        if (GLEW_ARB_texture_border_clamp)
        {
                glTexParameteri(GL_TEXTURE_3D_EXT,GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER_ARB);
                glTexParameteri(GL_TEXTURE_3D_EXT,GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER_ARB);
                glTexParameteri(GL_TEXTURE_3D_EXT,GL_TEXTURE_WRAP_R_EXT, GL_CLAMP_TO_BORDER_ARB);
        }
        else
        {
                glTexParameteri(GL_TEXTURE_3D_EXT,GL_TEXTURE_WRAP_S, GL_CLAMP);
                glTexParameteri(GL_TEXTURE_3D_EXT,GL_TEXTURE_WRAP_T, GL_CLAMP);
                glTexParameteri(GL_TEXTURE_3D_EXT,GL_TEXTURE_WRAP_R_EXT, GL_CLAMP);
        }

        glTexParameteri(GL_TEXTURE_3D_EXT,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
        glTexParameteri(GL_TEXTURE_3D_EXT,GL_TEXTURE_MIN_FILTER,GL_LINEAR);
        

        int iInternalFormat = GL_RGBA;

        if (GLEW_ARB_texture_float)
                iInternalFormat = GL_RGBA16F_ARB;

        int iTextureWidth = m_DimX;
        int iTextureHeight = m_DimY;
        int iTextureDepth = m_DimZ;

        if (!GLEW_ARB_texture_non_power_of_two)
        {
                iTextureWidth = getNextPowerOfTwo(m_DimX);
                iTextureHeight = getNextPowerOfTwo(m_DimY);
                iTextureDepth = getNextPowerOfTwo(m_DimZ);                               
        }

        glTexImage3D(GL_TEXTURE_3D, 0, iInternalFormat, iTextureWidth, iTextureHeight, iTextureDepth, 0, GL_RGBA, GL_FLOAT, NULL);

        glError = glGetError();
        if (glError != GL_NO_ERROR )
        {
                std::cout << "Error creating texture" << std::endl;
        }

        glTexSubImage3D(GL_TEXTURE_3D, 0, 0, 0, 0, m_DimX, m_DimY, m_DimZ, GL_RGBA, GL_FLOAT, &(m_VolumeData[0]));


        glError = glGetError();
        if (glError != GL_NO_ERROR )
        {
                std::cout << "Error creating texture" << std::endl;
        }

        std::cout << "Binding Volume in OpenGL finished" << std::endl;
        glDisable(GL_TEXTURE_3D);
        return true;
}

bool VVolume::loadDat(std::string filename, int *data)
{
        FILE *fp = NULL;

        fopen_s(&fp,filename.c_str(),"rb");

        if(!fp)
        {
                return false;
        }

        std::cout << "Loading Volume File: " << filename << std::endl;
        unsigned short dimX, dimY, dimZ;

        fread(&dimX,sizeof(unsigned short),1,fp);
        fread(&dimY,sizeof(unsigned short),1,fp);
        fread(&dimZ,sizeof(unsigned short),1,fp);

        m_DimX = (int)dimX;
        m_DimY = (int)dimY;
        m_DimZ = (int)dimZ;

        data[0] = m_DimX;
        data[1] = m_DimY;
        data[2] = m_DimZ;

        std::cout << "File Header:" << std::endl;
        std::cout << "\t\tDimension X: " << m_DimX << std::endl;
        std::cout << "\t\tDimension Y: " << m_DimY << std::endl;
        std::cout << "\t\tDimension Z: " << m_DimZ << std::endl;

        if (!GLEW_ARB_texture_non_power_of_two)
        {
                const int iPotWidth = getNextPowerOfTwo(m_DimX);
                const int iPotHeight = getNextPowerOfTwo(m_DimY);
                const int iPotDepth = getNextPowerOfTwo(m_DimZ);

                const VVector vecScale = VVector(float(m_DimX)/float(iPotWidth),float(m_DimY)/float(iPotHeight),float(m_DimZ)/float(iPotDepth));
                const VVector vecTranslation = VVector(-float(iPotWidth - m_DimX)/float(m_DimX),-float(iPotHeight - m_DimY)/float(m_DimY),-float(iPotDepth - m_DimZ)/float(m_DimZ));

                m_ModelMatrix.scale(vecScale);
                m_ModelMatrix.translate(vecTranslation);
        }

        int numVoxels = m_DimX * m_DimY * m_DimZ;

        std::vector<unsigned short> tmpData(numVoxels);
        m_VolumeData.resize(numVoxels);

        fread((void*)&(tmpData.front()),sizeof(unsigned short),numVoxels,fp);
        fclose(fp);
        
        m_Histogram.clear();
        m_Histogram.resize(4096);
        m_maxdensity = 0.0f;

        for (int i = 0; i< HISTOGRAM2D_RESOLUTION; i++)
        {
                m_histogram2d_texture[i] = 0;
        }

        std::map<int, std::map<float, int>> m_Histogram2D;      

        const int iSlice = m_DimX * m_DimY;

        
        unsigned int max_probability = 0;

        for (int k=0;k<m_DimZ;k++)
        {
                const int i1nz = max(k-1,0);
                const int i0pz = k;
                const int i1pz = min(k+1,m_DimZ-1);

                for (int j=0;j<m_DimY;j++)
                {
                        const int i1ny = max(j-1,0);
                        const int i0py = j;
                        const int i1py = min(j+1,m_DimY-1);

                        for (int i=0;i<m_DimX;i++)
                        {
                                const int i1nx = max(i-1,0);
                                const int i0px = i;
                                const int i1px = min(i+1,m_DimX-1);

                                float samplesNegZOffset[9];
                                float samplesNoZOffset[9];
                                float samplesPosZOffset[9];

                                // Code taken from Stefan Bruckners Computational Aesthetics Framework
                                // only rewritten for nicer(but not as readable as the original) constructor

                                samplesNegZOffset[0] = min(1.0f,float(tmpData[i1nx + i1ny*m_DimX + i1nz*iSlice]) / 4095.0f);
                                samplesNegZOffset[1] = min(1.0f,float(tmpData[i0px + i1ny*m_DimX + i1nz*iSlice]) / 4095.0f);
                                samplesNegZOffset[2] = min(1.0f,float(tmpData[i1px + i1ny*m_DimX + i1nz*iSlice]) / 4095.0f);
                                samplesNegZOffset[3] = min(1.0f,float(tmpData[i1nx + i0py*m_DimX + i1nz*iSlice]) / 4095.0f);
                                samplesNegZOffset[4] = min(1.0f,float(tmpData[i0px + i0py*m_DimX + i1nz*iSlice]) / 4095.0f);
                                samplesNegZOffset[5] = min(1.0f,float(tmpData[i1px + i0py*m_DimX + i1nz*iSlice]) / 4095.0f);
                                samplesNegZOffset[6] = min(1.0f,float(tmpData[i1nx + i1py*m_DimX + i1nz*iSlice]) / 4095.0f);
                                samplesNegZOffset[7] = min(1.0f,float(tmpData[i0px + i1py*m_DimX + i1nz*iSlice]) / 4095.0f);
                                samplesNegZOffset[8] = min(1.0f,float(tmpData[i1px + i1py*m_DimX + i1nz*iSlice]) / 4095.0f);

                                samplesNoZOffset[0] = min(1.0f,float(tmpData[i1nx + i1ny*m_DimX + i0pz*iSlice]) / 4095.0f);
                                samplesNoZOffset[1] = min(1.0f,float(tmpData[i0px + i1ny*m_DimX + i0pz*iSlice]) / 4095.0f);
                                samplesNoZOffset[2] = min(1.0f,float(tmpData[i1px + i1ny*m_DimX + i0pz*iSlice]) / 4095.0f);
                                samplesNoZOffset[3] = min(1.0f,float(tmpData[i1nx + i0py*m_DimX + i0pz*iSlice]) / 4095.0f);
                                samplesNoZOffset[4] = min(1.0f,float(tmpData[i0px + i0py*m_DimX + i0pz*iSlice]) / 4095.0f);
                                samplesNoZOffset[5] = min(1.0f,float(tmpData[i1px + i0py*m_DimX + i0pz*iSlice]) / 4095.0f);
                                samplesNoZOffset[6] = min(1.0f,float(tmpData[i1nx + i1py*m_DimX + i0pz*iSlice]) / 4095.0f);
                                samplesNoZOffset[7] = min(1.0f,float(tmpData[i0px + i1py*m_DimX + i0pz*iSlice]) / 4095.0f);
                                samplesNoZOffset[8] = min(1.0f,float(tmpData[i1px + i1py*m_DimX + i0pz*iSlice]) / 4095.0f);

                                samplesPosZOffset[0] = min(1.0f,float(tmpData[i1nx + i1ny*m_DimX + i1pz*iSlice]) / 4095.0f);
                                samplesPosZOffset[1] = min(1.0f,float(tmpData[i0px + i1ny*m_DimX + i1pz*iSlice]) / 4095.0f);
                                samplesPosZOffset[2] = min(1.0f,float(tmpData[i1px + i1ny*m_DimX + i1pz*iSlice]) / 4095.0f);
                                samplesPosZOffset[3] = min(1.0f,float(tmpData[i1nx + i0py*m_DimX + i1pz*iSlice]) / 4095.0f);
                                samplesPosZOffset[4] = min(1.0f,float(tmpData[i0px + i0py*m_DimX + i1pz*iSlice]) / 4095.0f);
                                samplesPosZOffset[5] = min(1.0f,float(tmpData[i1px + i0py*m_DimX + i1pz*iSlice]) / 4095.0f);
                                samplesPosZOffset[6] = min(1.0f,float(tmpData[i1nx + i1py*m_DimX + i1pz*iSlice]) / 4095.0f);
                                samplesPosZOffset[7] = min(1.0f,float(tmpData[i0px + i1py*m_DimX + i1pz*iSlice]) / 4095.0f);
                                samplesPosZOffset[8] = min(1.0f,float(tmpData[i1px + i1py*m_DimX + i1pz*iSlice]) / 4095.0f);

                                m_VolumeData[i+j*m_DimX+k*iSlice] = VVoxel( samplesNegZOffset, samplesNoZOffset, samplesPosZOffset);
                                float fValue = m_VolumeData[i+j*m_DimX+k*iSlice].getData() * 4095.0f;
                                float magValue = m_VolumeData[i+j*m_DimX+k*iSlice].getGradientMagnitude();

                                int dens = (int)(m_VolumeData[i+j*m_DimX+k*iSlice].getData() * HISTOGRAM2D_RESOLUTION_X);
                                int gmag = (int)(m_VolumeData[i+j*m_DimX+k*iSlice].getGradientMagnitude()*HISTOGRAM2D_RESOLUTION_Y);

                                

                                m_histogram2d_texture[dens*4 + gmag*HISTOGRAM2D_RESOLUTION_X*4] += 1;
                                m_histogram2d_texture[dens*4 + gmag*HISTOGRAM2D_RESOLUTION_X*4 +1] += 1;
                                m_histogram2d_texture[dens*4 + gmag*HISTOGRAM2D_RESOLUTION_X*4 +2] += 1;
                                m_histogram2d_texture[dens*4 + gmag*HISTOGRAM2D_RESOLUTION_X*4 +3] += 1;

                                if( gmag > 512 &&
                                        max_probability < m_histogram2d_texture[dens*4 + gmag*HISTOGRAM2D_RESOLUTION_X*4])
                                {
                                        max_probability = m_histogram2d_texture[dens*4 + gmag*HISTOGRAM2D_RESOLUTION_X*4];
                                }


                                if(fValue != 0)
                                {
                                        m_Histogram[(int)(fValue)]++;
                                        if (fValue > 255.0 && m_Histogram[(int)(fValue)] > m_maxdensity) 
                                                m_maxdensity = m_Histogram[(int)(fValue)];
                                }
                        }
                }

                std::cout << "\rPreparing data (" << (k*100) / (m_DimZ-1) << "%) ...";
        }

        for (int i = 0; i< HISTOGRAM2D_RESOLUTION; i++)
        {

                if(m_histogram2d_texture[i]>0) 
                        
                {
                        m_histogram2d_texture[i]= 128 + min(127, (unsigned int)(127.0f * ( (float)m_histogram2d_texture[i]/ max_probability )) );
                }
                //m_histogram2d_texture[i] = min(255, (unsigned int)(255.0f * ( (float)m_histogram2d_texture[i]/ max_probability )) );
                
        }

        std::cout << std::endl << "Loading Volume Data Finished" << std::endl;
 
        data[3] = m_maxdensity;

        

        return (this->bindVolumeInOpenGL());
}

bool VVolume::loadGDat(std::string filename, int *data)
{
        FILE *fp = NULL;

        fopen_s(&fp,filename.c_str(),"rb");

        if(!fp)
        {
                return false;
        }

        std::cout << "Loading Volume File: " << filename << std::endl;
        int dimX, dimY, dimZ;

        fread(&dimX,sizeof(int),1,fp);
        fread(&dimY,sizeof(int),1,fp);
        fread(&dimZ,sizeof(int),1,fp);


        m_DimX = (int)dimX;
        m_DimY = (int)dimY;
        m_DimZ = (int)dimZ;

        data[0] = m_DimX;
        data[1] = m_DimY;
        data[2] = m_DimZ;

        std::cout << "File Header:" << std::endl;
        std::cout << "\t\tDimension X: " << m_DimX << std::endl;
        std::cout << "\t\tDimension Y: " << m_DimY << std::endl;
        std::cout << "\t\tDimension Z: " << m_DimZ << std::endl;

        if (!GLEW_ARB_texture_non_power_of_two)
        {
                const int iPotWidth = getNextPowerOfTwo(m_DimX);
                const int iPotHeight = getNextPowerOfTwo(m_DimY);
                const int iPotDepth = getNextPowerOfTwo(m_DimZ);

                const VVector vecScale = VVector(float(m_DimX)/float(iPotWidth),float(m_DimY)/float(iPotHeight),float(m_DimZ)/float(iPotDepth));
                const VVector vecTranslation = VVector(-float(iPotWidth - m_DimX)/float(m_DimX),-float(iPotHeight - m_DimY)/float(m_DimY),-float(iPotDepth - m_DimZ)/float(m_DimZ));

                m_ModelMatrix.scale(vecScale);
                m_ModelMatrix.translate(vecTranslation);
        }

        int numVoxels = m_DimX * m_DimY * m_DimZ;

        std::vector<VVoxel> tmpData(numVoxels);
        m_VolumeData.resize(numVoxels);

        
        m_Histogram.clear();
        m_Histogram.resize(4096);
        m_maxdensity = 0.0f;

        for(int i = 0; i < m_DimZ; ++i)
        {
                for(int j = 0; j < m_DimY; ++j)
                {
                        for (int k = 0; k < m_DimX; ++k)
                        {
                                float density;
                                fread((void*)&density,sizeof(float),1,fp);
                                float gradient[3];
                                fread((void*)gradient,sizeof(float),3,fp);
                                
                                m_VolumeData[k + j * m_DimX + i * m_DimX * m_DimY] = VVoxel(density, VVector(gradient));
                        }
                }
                std::cout << "\rPreparing Data(" << (i*100)/(m_DimZ-1) << "%) ... ";
        }

        fread(reinterpret_cast<char*>(&m_Histogram[0]), sizeof(int), 4096,fp);

        m_maxdensity = 0.0f;
        for(int i = 256; i < 4096; ++i)
        {
                if (m_Histogram[i] > m_maxdensity) 
                        m_maxdensity = m_Histogram[i];
        }
        
        unsigned int histsizex;
        unsigned int histsizey;
        unsigned int numchannel;


        fread(reinterpret_cast<char*>(&histsizex), sizeof(unsigned int), 1,fp);
        fread(reinterpret_cast<char*>(&histsizey), sizeof(unsigned int), 1,fp);
        fread(reinterpret_cast<char*>(&numchannel), sizeof(unsigned int), 1,fp);

        m_histogram2d_texture.clear();
        m_histogram2d_texture.resize(histsizex * histsizey * numchannel);

        fread(reinterpret_cast<char*>(&m_histogram2d_texture[0]), sizeof(unsigned char),histsizex * histsizey * numchannel, fp);

        fclose(fp);
        std::cout << std::endl << "Loading Volume Data Finished" << std::endl;

        data[3] = m_maxdensity;

        return (this->bindVolumeInOpenGL());
}

void VVolume::clear()
{
        m_VolumeData.clear();
        m_Histogram.clear();
        if(m_GLVolumeHandle)
        {
                glDeleteTextures(1,&m_GLVolumeHandle);
                m_GLVolumeHandle = 0;
        }
}

void VVolume::flipVolumeX()
{
        if(m_VolumeData.size() == 0)
        {
                return;
        }
        std::vector<VVoxel> newVolume;
        newVolume.resize(m_VolumeData.size());

        for(int i = 0; i < m_DimZ; ++i)
        {
                for(int j = 0; j < m_DimY; ++j)
                {
                        for (int k = 0; k < m_DimX; ++k)
                        {
                                newVolume[k + j * m_DimX + i * m_DimX * m_DimY] = m_VolumeData[(m_DimX - k - 1) + j * m_DimX + i * m_DimX * m_DimY];
                                VVector gradient = newVolume[k + j * m_DimX + i * m_DimX * m_DimY].getGradient();
                                gradient.setX(-gradient.getX());
                                newVolume[k + j * m_DimX + i * m_DimX * m_DimY].setGradient(gradient);
                        }
                }
                std::cout << "\rPreparing Data(" << (i*100)/(m_DimZ-1) << "%) ... ";
        }

        m_VolumeData = newVolume;
        this->bindVolumeInOpenGL();
}

void VVolume::flipVolumeY()
{
        if(m_VolumeData.size() == 0)
        {
                return;
        }
        std::vector<VVoxel> newVolume;
        newVolume.resize(m_VolumeData.size());

        for(int i = 0; i < m_DimZ; ++i)
        {
                for(int j = 0; j < m_DimY; ++j)
                {
                        for (int k = 0; k < m_DimX; ++k)
                        {
                                newVolume[k + j * m_DimX + i * m_DimX * m_DimY] = m_VolumeData[k + (m_DimY - j - 1) * m_DimX + i * m_DimX * m_DimY];
                                VVector gradient = newVolume[k + j * m_DimX + i * m_DimX * m_DimY].getGradient();
                                gradient.setY(-gradient.getY());
                                newVolume[k + j * m_DimX + i * m_DimX * m_DimY].setGradient(gradient);
                        }
                }
                std::cout << "\rPreparing Data(" << (i*100)/(m_DimZ-1) << "%) ... ";
        }

        m_VolumeData = newVolume;
        this->bindVolumeInOpenGL();
}

void VVolume::flipVolumeZ()
{
        if(m_VolumeData.size() == 0)
        {
                return;
        }
        std::vector<VVoxel> newVolume;
        newVolume.resize(m_VolumeData.size());

        for(int i = 0; i < m_DimZ; ++i)
        {
                for(int j = 0; j < m_DimY; ++j)
                {
                        for (int k = 0; k < m_DimX; ++k)
                        {
                                newVolume[k + j * m_DimX + i * m_DimX * m_DimY] = m_VolumeData[k + j * m_DimX + (m_DimZ - i - 1) * m_DimX * m_DimY];
                                VVector gradient = newVolume[k + j * m_DimX + i * m_DimX * m_DimY].getGradient();
                                gradient.setZ(-gradient.getZ());
                                newVolume[k + j * m_DimX + i * m_DimX * m_DimY].setGradient(gradient);
                        }
                }
                std::cout << "\rPreparing Data(" << (i*100)/(m_DimZ-1) << "%) ... ";
        }

        m_VolumeData = newVolume;
        this->bindVolumeInOpenGL();
}

---