source: trunk/src/testing/app/volvis/vVolume.h @ 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
 *********************************************************************************/

#ifndef _VVOLUME_H_
#define _VVOLUME_H_
#include "mmap.h"
#include "private.h"
#include "caDataManagerClient.h"
#include <vector>

#define H2D_DIM 256*256
//for one timestep volume
class vFrameData {
public:
        GLubyte* voxelData;
        unsigned char* gradData;
        unsigned char* hist;
        QUANTAts_mutex_c histMutex;

        vFrameData() {
                voxelData = gradData = hist = 0;
        }
};

//This class defines a volume
class vVolume {
public:
        //row, column and depth of volume thats loaded into gfx
        unsigned int dimX, dimY, dimZ;
        unsigned int maxDim; //maximum dimension
        //dimensions of the whole volume - on file
        unsigned int fileX, fileY, fileZ;
        //offset into the whole volume to read the subvolume
        unsigned int offsetX, offsetY, offsetZ;
        //spacing into the whole volume to read the subvolume
        float spacingX, spacingY, spacingZ;
        //current probe point
        unsigned int probeX, probeY, probeZ;
        vector<vFrameData> cache; //pointer to the time-series volume
        int curVolume, numVolumes; //no of volumes and the current volume index
        int probeValue, isoValue; //current value of the probe
        unsigned int texName; //name of 3D texture associated with this volume
//Member functions
        vVolume(int x, int y, int z); //size of the whole volume
        virtual ~vVolume();
        //here is where the volume is actually loaded
        //needs to be overloaded
        virtual void load(int loadx, int loady, int loadz) = 0;
        virtual void load() = 0;
        //roaming the volume - overload this
        virtual void roam(int roamx, int roamy, int roamz) = 0;
        virtual int hist2D(unsigned char *normHist);
        virtual int hist1D(unsigned char *normHist);
        virtual void saveVolume(const char* filename);
        virtual void saveGradient(const char* filename = "grad");
        virtual void probe(int probeX, int probeY, int probeZ);
        virtual void next() = 0;
        virtual void prev() = 0;
        //sets the vol dims/does power of 2 checking etc
        void setLoadDims(int x, int y, int z) ;
        virtual NetVertexBuffer* isoSurface() = 0;
        virtual NetPointBuffer* isoPoint() = 0;

        inline GLubyte getValue(int d, int r, int c) {
                return cache[curVolume].voxelData[d*dimY*dimX+r*dimX+c];
        }

        inline void setValue(int d, int r, int c, GLubyte value) {
                cache[curVolume].voxelData[d*dimY*dimX+r*dimX+c] = value;
        }

        inline GLubyte* getVoxelData() {
                return cache[curVolume].voxelData;
        }

        inline void getNormProbe(float& x, float& y, float& z) {
                x = (float)probeX/(float)(dimX-1);
                y = (float)probeY/(float)(dimY-1);
                z = (float)probeZ/(float)(dimZ-1);
        }

        inline void getNormOffset(float& x, float& y, float& z) {
                x = (float)offsetX/(float)(fileX-1);
                y = (float)offsetY/(float)(fileY-1);
                z = (float)offsetZ/(float)(fileZ-1);
        }

        inline void getNormDim(float& x, float& y, float& z) {
                x = (float)dimX/(float)(fileX);
                y = (float)dimY/(float)(fileY);
                z = (float)dimZ/(float)(fileZ);
        }

        inline void incIsoValue(int inc) {
                isoValue += inc;
                if (isoValue > 255)
                        isoValue = 255;
                if (isoValue < 0)
                        isoValue = 0;
                fprintf(stderr,"Isovalue now is %d\n",isoValue);
        }
        inline int getIsoValue() {
                return isoValue;
        }
        inline int setIsoValue(int i) {
                isoValue = i;
        }
};
#if 0
//class that handle volume access from a file
class vFileVolume: public vVolume {
public:
        //if the volume is smaller than the volume in file, we need to pad it equally
        unsigned int padX, padY, padZ;
        char filename[256]; //filename associated with this 3d texture
        char*   gradientFile; //gradient file associated with this 3d texture
        Mmap    mmap;
        unsigned char* fileBuffer;

//public member functions
        vFileVolume(const char* filename, int c, int r, int d);
        virtual ~vFileVolume();
        void load(int x, int y, int z);
        void load() {load(fileX,fileY,fileZ);};
        //void roam(int roamx, int roamy, int roamz);
private:
        void loadVolumeFromFile(const char* filename);
        void loadGradientFromFile(const char* filename); //load gradient info from file
        void padVolume();//if volsize > filesize, pad the volume with black
        void readASlice(GLubyte* plane, unsigned char* &curFilePtr) ; //read one plane from file
        //if the volume is bigger than the file size, this will pad the volume
        void calcGradient();
};
#endif
//class to handle volume access from a data server
class vOptiVolume: public vVolume {
public:
    cDataManagerClient* opClient; //pointer to the op client
        int* indexList;
        bool updateHist;
//public member functions
        vOptiVolume(const char*, const char*);
        virtual ~vOptiVolume();
        void load(int x, int y, int z);
        void load();
        void roam(int roamx, int roamy, int roamz);
        int hist2D(unsigned char *normHist);
        //get isosurface from opClient
        NetVertexBuffer* isoSurface();
        NetPointBuffer* isoPoint();
        //void hist1D(unsigned char *normHist);
        void setUpdateHist(bool flag) ;
        bool getUpdateHist() ;
        void next();
        void prev();
        void setCurVolume(int curVolume) ;
};
#endif