CTex.cpp

#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <glut.h>
#include <windows.h>
#include <gl/glu.h>
#include "lifeVariables.h"

//
// CTexture
//
void CTex::Init(unsigned short dimX, unsigned short dimY)
{
        _dimX = dimX; 
        _dimY = dimY;
        _size = _dimX * _dimY * _cColourChannels; 
                
        if ( _pTex && dimX )
        {
            delete[] _pTex;
            _pTex = 0;
        }

        _pTex = new GLfloat[_size];
        if ( !_pTex )
            throw;

        for ( int i = 0; i < _size; i++ )
        {
            _pTex[i] = 0;
        }
}

void CTex::GenTexture()
{
        unsigned short  * pD     = GDensities.GetDensitiesPtr();
    unsigned short  uMaxValue= 0;

        GLfloat         * texPtr = 0; 
    int i,j;

    texPtr = _pTex;

   /*
    * For each of the densitiy values, create a corresponding RGBA value
        *
        */


    // uMaxValue = GDensities.GetMaxValue();

    uMaxValue = GVolVoxels.GetMaxValue();

    if (!uMaxValue )
        uMaxValue = 1;

   for( i=0;i< _dimY; i++)
   {
     for( j=0;j< _dimX; j++, texPtr += _cColourChannels)
     {
                histogram->getColorByDensity(*pD, (*texPtr), 
                                                  (*(texPtr+1)),
                                                  (*(texPtr+2)),
                                                  (*(texPtr+3)));
                 pD++;

     }
   }
}

void CTex::DisplaySliceAlong_Z_Axis(unsigned iSliceNum)
{
    unsigned uWidth, uHeight;

    uWidth  = GVolVoxels.GetDimX();
    uHeight = GVolVoxels.GetDimY();

    GDensities.Init(uWidth,uHeight);

        GDensities.InitDensities_XY_plain_by_Slice(iSliceNum);
    
    Init(uWidth, uHeight);

    GenTexture();
}

void CTex::DisplaySliceAlong_X_Axis(unsigned iSliceNum)
{ 
    unsigned uWidth, uHeight;

    uWidth  = GVolVoxels.GetDimY();
    uHeight = GVolVoxels.GetDimZ();

    GDensities.Init(uWidth,uHeight);

        GDensities.InitDensities_YZ_plain_by_Slice(iSliceNum);
    
    Init(uWidth, uHeight);

    GenTexture();

  }

void CTex::DisplaySliceAlong_Y_Axis(unsigned iSliceNum)
{
    unsigned uWidth, uHeight;

    uWidth  = GVolVoxels.GetDimX();
    uHeight = GVolVoxels.GetDimZ();

    GDensities.Init(uWidth,uHeight);

        GDensities.InitDensities_XZ_plain_by_Slice(iSliceNum);
    
    Init(uWidth, uHeight);

    GenTexture();

}

void CTex::GenerateBackgroundGeometry()
{
    int x = 1;  // scale factor

    glBegin(GL_QUADS);

    glTexCoord2f(1.0, 0.0); glVertex3f(-1.0*x, -1.0*x, 0.0);
    glTexCoord2f(0.0, 0.0); glVertex3f( 1.0*x, -1.0*x, 0.0);
    glTexCoord2f(0.0, 1.0); glVertex3f( 1.0*x,  1.0*x, 0.0);
    glTexCoord2f(1.0, 1.0); glVertex3f(-1.0*x,  1.0*x, 0.0);

    glEnd();
}

void CTex::LetThereBeBackground(unsigned uWidth, unsigned uHeight)
{
    GenerateBackgroundGeometry();

    /*
     * scale up to size that's power of two
     */
    if ( uWidth <= 64 )
        _uBGTexWidth = 64;
    else if ( uWidth <= 128 )
        _uBGTexWidth = 128;
    else if ( uWidth <= 256)
        _uBGTexWidth = 256;
    else if ( uWidth <= 512 )
        _uBGTexWidth = 512;
    else 
    {
//        cout "Error:  uTexSize Not Supported  " << uTexWidth << endl;
    }

    if ( uHeight <= 64 )
        _uBGTexHeight = 64;
    else if ( uHeight <= 128 )
        _uBGTexHeight = 128;
    else if ( uHeight <= 256)
        _uBGTexHeight = 256;
    else if ( uHeight <= 512 )
        _uBGTexHeight = 512;
    else 
    {
  //      cout "Error:  uTexSize Not Supported  " << uTexHeight << endl;
    }
    
    unsigned uBGSize = _uBGTexWidth * _uBGTexHeight * _cColourChannels;

    if ( _pBGTex && _uBGTexWidth )
    {
        delete[] _pBGTex;
        _pBGTex = 0;
    }

    _pBGTex = new GLfloat[uBGSize];
    if ( !_pBGTex )
         throw;

    for ( int i = 0; i < uBGSize; i++ )
    {
            _pBGTex[i] = 10;
    }
 
    if ( _texName )
    {
       glDeleteTextures(1,&_texName);
       glGenTextures(1, &_texName);
       glBindTexture(GL_TEXTURE_2D, _texName);
    }

    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);

    glTexImage2D(GL_TEXTURE_2D,0,3, _uBGTexWidth, _uBGTexHeight,0,GL_RGBA,GL_FLOAT, _pBGTex);
}

void CTex::RenderSubTexture()
{
    int iAlongAxis = optionPanel->selectedPlane;
    int iSliceNum = optionPanel->selectedSlice;
    int interpolationMode_2D = optionPanel->interpolationMode;

    unsigned TexWidth = 0;
    unsigned TexHeight= 0;

    if ( true ) 
    {
        switch (iAlongAxis)
        {
            case 0: if ( iSliceNum < GVolVoxels.GetDimZ() )
                    {
                        TexWidth = GVolVoxels.GetDimX();
                        TexHeight= GVolVoxels.GetDimY();

                        DisplaySliceAlong_Z_Axis(iSliceNum);
                    }
                    break;

            case 1: if ( iSliceNum < GVolVoxels.GetDimX() )
                    {
                        TexWidth = GVolVoxels.GetDimY();
                        TexHeight= GVolVoxels.GetDimZ();

                        DisplaySliceAlong_X_Axis(iSliceNum);
                    }
                    break;

            case 2: if ( iSliceNum < GVolVoxels.GetDimY() )
                    {
                        TexWidth = GVolVoxels.GetDimX();
                        TexHeight= GVolVoxels.GetDimZ();

                        DisplaySliceAlong_Y_Axis(iSliceNum);
                    }
                    break;

            default:
                    cout << "Slice Error: Unexpected Axis Selection" << iSliceNum << endl;
                    break;
        }

        //cout << "Info: Displaying slice num: " << iSliceNum << endl;

        LetThereBeBackground(TexWidth,TexHeight);

        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);

        //cout << "interpolatoin method  " << interpolationMode_2D << endl ;
        switch( interpolationMode_2D )
        {
        case 0:  

            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);

            break;

        case 1:
            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);

            break;

        default:

            break;
        }

    }

    glBindTexture(GL_TEXTURE_2D, _texName);

    glTexSubImage2D(GL_TEXTURE_2D,0, (_uBGTexWidth-TexWidth)/2 , (_uBGTexHeight-TexHeight)/2,  TexWidth, TexHeight, GL_RGBA, GL_FLOAT, _pTex);
}

void CTex::RenderVolumeSubTexture()
{
    int iAlongAxis = optionPanel->selectedPlane;
    int iSliceNum = optionPanel->selectedSlice;

    unsigned TexWidth = GScanner.GetTexWidth();
    unsigned TexHeight= GScanner.GetTexHeight();

    LetThereBeBackground(TexWidth,TexHeight);

    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);

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

    glBindTexture(GL_TEXTURE_2D, _texName);

    glTexSubImage2D(GL_TEXTURE_2D,0, (_uBGTexWidth-TexWidth)/2 , (_uBGTexHeight-TexHeight)/2,  TexWidth, TexHeight, GL_RGBA, GL_FLOAT,  GScanner.GetView() );
}

---