composite.cpp

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


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

    if ( !refresh ) 
        return;
    else
        refresh = false;

    //
    //  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) ) 
            {
                SampleAlongRay(beginCoord, endCoord, &rgba);                

                _aView[pixelIndex].r = rgba.r;
                _aView[pixelIndex].g = rgba.g;
                _aView[pixelIndex].b = rgba.b;                
               
                pixelIndex++; 

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

                if (!bNewRow)
                {
                    xRes++;
                    if ( xRes > _xRes )
                        _xRes = xRes; 
                }

            }
        }
    }
}

void CScanner::SampleAlongRay(sPoint3f beginCoord, sPoint3f endCoord, sRGBA *pRGBA)
{

    CVector3f samplingDirection( endCoord.x - beginCoord.x,
                                 endCoord.y - beginCoord.y,
                                 endCoord.z - beginCoord.z );    
    sVector3f vStep;
    sPoint3f  samplePoint, sampleCoordinates;
    float     sampleDensity = 0;
    float     diffuseValue = 0;
    float     maxDensity = GVolVoxels.GetMaxValue();

    // store the start value
    sRGBA *tempRGBA = pRGBA;
    

    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);
            break;
           /*
            *  Get interpolated density and gradient-based diffuse value at this sample point
            */
        case TRILINEAR_VOLUME:
           sampleDensity = GVolVoxels.GetDensityTriLinear(sampleCoordinates);
           break;

        default:
            break;
        }

       diffuseValue = GetDiffuseValue(sampleCoordinates);
       
       // get the color per density
       histogram->getVoxelColorByDensity(sampleDensity,
                                         tempRGBA->r,
                                         tempRGBA->g,
                                         tempRGBA->b);

       
       // calculate the shading for the surface
       tempRGBA->r *= diffuseValue;
       tempRGBA->g *= diffuseValue;
       tempRGBA->b *= diffuseValue;

       // accumulte the colors
       *pRGBA += *tempRGBA;
    }

    return;
}

---