source: trunk/src/testing/app/volvis/vVolume.cpp @ 4

/********************************************************************************
 * Volatile - Volume Visualization Software for SAGE
 * Copyright (C) 2004 Electronic Visualization Laboratory,
 * University of Illinois at Chicago
 *
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 *  * Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *  * Redistributions in binary form must reproduce the above
 *    copyright notice, this list of conditions and the following disclaimer
 *    in the documentation and/or other materials provided with the distribution.
 *  * Neither the name of the University of Illinois at Chicago nor
 *    the names of its contributors may be used to endorse or promote
 *    products derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 * Direct questions, comments etc about Volatile to www.evl.uic.edu/cavern/forum
 *********************************************************************************/

//Class vVolume: Defines the 3D volume and the associated operations
//the inherited class should override the load/roam function
//This class only manages the data(doesnt do the rendering)
//Shalini Venkataraman, Luc Renambot
//Sep 7 2003
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "glUE.h"
#include "vVolume.h"
#include "VectorMath.h"
#include "global.h"

//constructor
vVolume::vVolume(int x, int y, int z) {
        fileY = y;
        fileX = x;
        fileZ = z;
        dimY = dimX = dimZ = maxDim = 128;
        offsetX  = offsetY = offsetZ = 0;
        spacingX  = spacingY = spacingZ = 1.0f;
        probeX = probeY = probeZ = 0;
        curVolume = numVolumes = 0;
        probeValue = 0;
        isoValue = 128;
}

//destructor
vVolume::~vVolume() {
        for (int i=0;i<cache.size();i++) {
                delete [] cache[i].voxelData;
                //delete [] cache[i].gradData;
                delete [] cache[i].hist;
        }
}

void vVolume::setLoadDims(int x, int y, int z) {
        //now get the power of 2
        dimY = makepow2_max(y);
        dimX = makepow2_max(x);
        dimZ = makepow2_max(z);
        maxDim = dimY;
        maxDim = MAX(dimY,dimX);
        maxDim = MAX(maxDim,dimZ);
        probeX = dimX/2;
        probeY = dimY/2;
        probeZ = dimZ/2;
}

void vVolume::probe(int dx, int dy, int dz) {
        //calculate new probe(cos the orig offset is unsigned..)
        int newProbeX = probeX + dx;
        int newProbeY = probeY + dy;
        int newProbeZ = probeZ + dz;
        if (newProbeX== dimX)
                newProbeX = dimX-1;
        if (newProbeY== dimY)
                newProbeY = dimY-1;
        if (newProbeZ== dimZ)
                newProbeZ = dimZ-1;

        if (newProbeX < 0)
                newProbeX = 0;
        if (newProbeY < 0)
                newProbeY = 0;
        if (newProbeZ < 0)
                newProbeZ = 0;
        //copy to the offset
        probeX = newProbeX;
        probeY = newProbeY;
        probeZ = newProbeZ;
        probeValue = getValue(probeZ, probeY, probeX);
}


int vVolume::hist2D(unsigned char *normHist)
{
        float *hist = new float[H2D_DIM];
        int i;
        for(i=0; i<H2D_DIM; ++i){
                hist[i] = 0;
        }

        for(i=0; i<dimZ; ++i){
                for(int j=0; j<dimY; ++j){
                        for(int k=0; k<dimX; ++k){
                                int vox = i*dimX*dimY + j*dimX + k;
                                hist[cache[curVolume].voxelData[vox] + cache[curVolume].gradData[vox]*256] += 1;
                        }
                }
        }

        float max = 0;
        for(i = 0; i< H2D_DIM; ++i){
                hist[i] = (float)log(hist[i]);
                max = MAX(hist[i], max);
        }
        for(i=0; i< H2D_DIM; ++i){
                normHist[i] = (unsigned char)(hist[i]/(float)max*255);
        }
        delete[] hist;
        return 1;
}

int vVolume::hist1D(unsigned char *normHist)
{
        float *hist = new float[H2D_DIM];
        int i;
        for(i=0; i<H2D_DIM; ++i){
                hist[i] = 0;
        }

        for(i=0; i<dimZ; ++i){
                for(int j=0; j<dimY; ++j){
                        for(int k=0; k<dimX; ++k){
                                int vox = i*dimX*dimY + j*dimX + k;
                                for (int row = 0;row<256;row++)
                                        hist[cache[curVolume].voxelData[vox]+row*256] += 1;
                        }
                }
        }

        float max = 0;
        for(i = 0; i< H2D_DIM; ++i){
        //      hist[i] = (float)log(hist[i]);
                max = MAX(hist[i], max);
        }
        for(i=0; i< H2D_DIM; ++i){
                normHist[i] = (unsigned char)(hist[i]/(float)max*255);
        }
        delete[] hist;
        return 1;
}

void vVolume::saveVolume(const char* prefix) {
        FILE* fp;
        char filename[256];
        sprintf(filename,"%s%dx%dx%d.raw",prefix,dimX,dimY,dimZ);
        if( (fp = fopen(filename, "wb" )) != NULL ) {
                int numwritten = fwrite(cache[curVolume].voxelData, sizeof(GLubyte), dimY*dimX*dimZ, fp );
                printf( "vVolume::saveVolume: Wrote %d bytes to file %s\n", numwritten, filename);
                fclose( fp );
        }
        else
                printf( "vVolume::saveVolume: Problem opening the file\n" );
}

void vVolume::saveGradient(const char* prefix) {
        FILE* fp;
        char filename[256];
        sprintf(filename,"%s%dx%dx%d.raw",prefix,dimX,dimY,dimZ);
        if( (fp = fopen(filename, "wb" )) != NULL ) {
                int numwritten = fwrite(cache[curVolume].gradData, sizeof(unsigned char), dimY*dimX*dimZ, fp );
                printf( "saveGradient: Wrote %d bytes to file %s\n", numwritten, filename);
                fclose( fp );
        }
        else
                printf( "saveGradient: Problem opening the file\n" );
}