mip.cpp

#include "lifevariables.h"
#include "CScanner.h"

static unsigned gVolumeInterpolation = 0x0601;

#define NEAREST 0x0600
#define TRILIN  0x0601

/*
 *  Generate MIP view
 *
 */

void CScanner::GenerateMIP()
{
    int i, j;   // loop counters
    sPoint3f    eye = _eye;
    sVector3f   ray = _ray;
    long        pixelIndex = 0;
    float       currentDensity = 0;
    bool        bNewRow = true;
    unsigned    xRes;
    sVector3f   imageScale( 1,1,0 );

    if ( !refresh ) 
        return;
    else
        refresh = false;
    stateBar->updateRenderInfo("Volume Rendering: Generating Max. Intensity Projection Image.");
    //
    //  Define begin and end coordinates to some out-of-bound value
    //
    sPoint3f    beginCoord(-1000,-1000,-1000), endCoord(-1000,-1000,-1000);
    _xRes = 0; _yRes = 0;

    for ( i = 0, _yRes = 0;
          i <   _scanRange;
          i++,  
          bNewRow = true, 
          xRes = 0,
          eye.x = _eye.x,
          eye.y = eye.y - imageScale.y)
    {
        for ( j = 0 ; 
              j <  _scanRange;
              j++, eye.x = eye.x + imageScale.x)
        {
            SetProjEye(eye);

            if ( GetIntersectionPoints(&beginCoord, &endCoord, _projEye, _ray) ) 
            {
                currentDensity = SampleMIPAlongRay(beginCoord, endCoord);                

                histogram->getVoxelColorByDensity(currentDensity, 
                    _aView[pixelIndex].r,
                    _aView[pixelIndex].g,
                    _aView[pixelIndex].b ); 
                              
                pixelIndex++; 

                /*
                 * Determine the actual resolution of the image
                 */
                if (bNewRow)
                {
                    _yRes++;
                    bNewRow = false;
                }

                if (!bNewRow)
                {
                    xRes++;
                    if ( xRes > _xRes )
                        _xRes = xRes; 
                }
   
            }
        }
    }
    stateBar->updateRenderInfo("Volume Rendering: Max. Intensity Projection Image Generated.");
}

float CScanner::SampleMIPAlongRay(sPoint3f beginCoord, sPoint3f endCoord)
{
    
    CVector3f samplingDirection( endCoord.x - beginCoord.x,
                                 endCoord.y - beginCoord.y,
                                 endCoord.z - beginCoord.z );    

    sVector3f vStep;
    sPoint3f  samplePoint, sampleCoordinates;
    float     sampleDensity = 0;
    float     maxDensity = GVolVoxels.GetMaxValue();
    sGrad     grad(0,0,0);
    sGrad     sampleGradient(0,0,0);
    unsigned  newDensity = 0;

    vStep       = samplingDirection.GetNormalized();
    samplePoint = beginCoord;

    float length = samplingDirection.GetMagnitude() - 1;

    for ( int i = 0; i < length; i++ )
    {
        samplePoint = samplePoint + vStep;
        sampleCoordinates = samplePoint;

        sampleCoordinates.x = _range.x + sampleCoordinates.x;
        sampleCoordinates.y = _range.y - sampleCoordinates.y;
        sampleCoordinates.z = _range.z + sampleCoordinates.z;
        
        switch ( optionPanel->volumeInterpolationMode )
        {
        case NEAREST_VOLUME:
            sampleDensity = GVolVoxels.GetVoxelValue(sampleCoordinates.x,sampleCoordinates.y,sampleCoordinates.z);
            GVolVoxels.GetGradient(sampleCoordinates.x, sampleCoordinates.y, sampleCoordinates.z, &grad);

            break;
        case TRILINEAR_VOLUME:
            sampleDensity = GVolVoxels.GetDensityTriLinear(sampleCoordinates);
            GVolVoxels.GetGradient(sampleCoordinates.x, sampleCoordinates.y, sampleCoordinates.z, &grad);
            break;

        default:
            break;
        }

        if ( newDensity < sampleDensity )
            newDensity = sampleDensity;
    }

    return newDensity;
}

---