vlvolume.cpp

Go to the documentation of this file.

// $Id: vlvolume.cpp,v 1.39 2004/08/19 11:14:33 slfrank Exp $
//
// OpenVL - A Library for working with volumetric datasets.
//          http://openvl.sf.net
//
// Copyright (C) 2000-2002  Sarang Lakare <sarang#users.sf.net>
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Library General Public
// License as published by the Free Software Foundation; either
// version 2 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// Library General Public License for more details.
//
// You should have received a copy of the GNU Library General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
// USA.
//
// Please report all bugs and problems to openvl-devel@lists.sf.net or
// at the OpenVL website.
//

#include <stdio.h>
#include <string.h>
#include <queue>
#include <math.h>
#include "vlmacros.h"
#include "vlvolfiofilter.h"
#include "vlcolor.h"
#include "vltriple.h"
#include "vlvolinfo.h"
#include "vlvoliterator.h"
#include "vltrader.h"
#include "vlkernel.h"
#include "vlvoldata_linear.h"
#include "vlvolume.h"
#include "vlvoldatalayoutplugin.h"
#define DEBUG

vlVolume::vlVolume(const vlDim & dim, const vlDataType dataType, const vlUnit & units)
{
   m_pVolData = 0L;
   m_layoutPlugin = 0L;

   resizeData(dim, dataType, units, "Linear");

   std::string name("noname");
   std::string origFileName;
   vlDim origFileDim(1,1,1);
   m_extraInfo.add(name, "name", "A name for the volume", true);
   m_extraInfo.add(origFileName, "origFilename", "The file from which this volume was loaded");
   // m_extraInfo.add(origFileDim, "origFileDim", "The dimensions of file from which this volume was loaded");
}


vlVolume::vlVolume(const vlDim & dim, const std::string & layout, const vlDataType dataType,
     const vlUnit & units)
{
   m_pVolData = 0L;
   m_layoutPlugin = 0L;

   resizeData(dim, dataType, units, layout);

   std::string name("noname");
   std::string origFileName;
   vlDim origFileDim(1,1,1);
   m_extraInfo.add(name, "name", "A name for the volume", true);
   m_extraInfo.add(origFileName, "origFilename", "The file from which this volume was loaded");
   //m_extraInfo.add(origFileDim, "origFileDim", "The dimensions of file from which this volume was loaded");
}


vlVolume::~vlVolume()     
{
   // release data
   if(m_pVolData)
      delete m_pVolData;
   if(m_layoutPlugin)
      delete m_layoutPlugin;
}


bool vlVolume::readInfo(const std::string & filename, vlVolInfo & info, bool useFileExt)
{
   // pass an empty format string.
   std::string format;
   return(readInfo(filename, info, format, useFileExt));
}


bool vlVolume::readInfo(const std::string & filename, vlVolInfo & info, const std::string & fileFormat, bool useFileExt)
{
   // try to open the file
   FILE *fp = fopen(filename.c_str(), "r");
   if(!fp) {
#ifdef DEBUG
std::cout << "Unable to open file " << filename << " for reading." << std::endl;
#endif
      return(false);
   }

   // make sure vlKernel is initialized
   vlKernel::instance();

   // temp variable to store info
   vlVolInfo volInfo;

   // get all FileIO plugins

   //  kore::ServiceProvider **filters = kore::Kernel::instance()->serviceManager()->registeredProviders("OpenVL/FileIO");
   std::vector<vlPlugin*> plugins = vlKernel::trader()->getPluginsForGroup("FileIO");
   vlVolFioFilter *filter;
   vlPlugin *plugin;
   unsigned int i;
   std::vector<vlPlugin*>::iterator itr = plugins.begin();

   // loop over the filters to find the filter that provides IO capability for the given format
   for(; itr!=plugins.end(); ++itr) {
      plugin = *itr;

#ifdef DEBUG
 std::cout << "Trying filter [Name:" << plugin->info().name() << std::flush;
#endif
      filter = (vlVolFioFilter*) (plugin);
      // make sure the pointer is valid
      if(!filter) {
#ifdef DEBUG
std::cout << "FAILED" << std::endl;
#endif
         continue;
      }

#ifdef DEBUG
std::cout << ",Format:" << filter->info().service() << "] ... " << std::flush;
#endif

      // Check if file format is specified
      if(fileFormat.size()) {
         // if file format is specified, then only the plugins of that file format will
         // be used : no autodetection.

         // Check if the plugin supports the required format
         // else, continue to next plugin
         if(strcasecmp(filter->info().service().c_str(), fileFormat.c_str())) {
#ifdef DEBUG
std::cout << "FAILED" << std::endl;
#endif
            continue; // to next filter
         }
      } else if(useFileExt) { // check file extension
         // Compare the file extension to the supported extensions of the current plugin

         std::string fileExt = filename.substr(filename.rfind(".")+1);

         // make sure there is indeed an extension to the filename
         if(fileExt.size()) {
            bool matchFound(false);
#ifdef DEBUG
std::cout << "File Ext : " << fileExt << " .. Checking supported extensions .. " << std::flush;
#endif
            std::vector<std::string>::const_iterator iter = filter->getFileExtensions().begin();
            std::vector<std::string>::const_iterator iterEnd = filter->getFileExtensions().end();
            while(iter!=iterEnd) {
#ifdef DEBUG
   std::cout << "\"" << *iter << "\"" << std::flush;
   #endif
               if(*iter == fileExt) {
#ifdef DEBUG
std::cout << " MATCH!" << std::endl;
#endif
                  matchFound = true;
                  break; // get out of the while loop
               }
               ++iter;
            }
            if(!matchFound) {
#ifdef DEBUG
std::cout << "FAILED" << std::endl;
#endif
               continue; // to the next filter
            }
         } else {
#ifdef DEBUG
std::cout << "FAILED" << std::endl;
#endif
            continue; // to next filter
         }
      }

      // rewind file pointer
      rewind(fp);


      if(!filter->readInfo(volInfo, fp, filename)) {
#ifdef DEBUG
std::cout << "FAILED" << std::endl;
#endif
         continue; // to next filter
      }

#ifdef DEBUG
std::cout << "File Info : \nVolume dimensions : " << volInfo.dim() << std::endl;
#endif

      // close file
      fclose(fp);

      info = volInfo;

      if(!volInfo.extraInfo()->isDefined("name")) {
         // create a name from the filename
         std::string name = filename.substr(filename.rfind("/")+1);
         if(!name.size())
            name = filename;
         info.extraInfoRW()->add(name, "name", "Volume name", true);
      }

      // success
      return(true);

   } // end-for

   // failure
   return(false);
}


bool vlVolume::read(const std::string & filename, bool useFileExt)
{
   vlVolInfo info; // send an invalid info
   std::string format; // send an empty string

   // call actual read to read the file
   return(read(filename, info, format, useFileExt));
}


bool vlVolume::read(const std::string & filename, const std::string & fileFormat)
{
   if(!fileFormat.size()) {
#ifdef DEBUG
std::cout << "No file format specified." << std::endl;
#endif
      return(false);
   }

   vlVolInfo info; // send an invalid info

   // call actual read to read the file
   return(read(filename, info, fileFormat, false));
}


bool vlVolume::read(const std::string & filename, const vlVolInfo & info, bool useFileExt)
{
   // an empty std::string
   std::string format;

   // call actual read to read the file
   return(read(filename, info, format, useFileExt));
}



bool vlVolume::read(const std::string & filename, const vlVolInfo & info, const std::string & fileFormat, bool useFileExt)
{
   // try to open the file
   FILE *fp = fopen(filename.c_str(), "r");
   if(!fp) {
      // error ("unable to open file");
#ifdef DEBUG
std::cout << "Unable to open file " << filename << " for reading." << std::endl;
#endif
      return(false);
   }

   // make sure vlKernel is initialized
   vlKernel::instance();

   // temp variable to store info
   vlVolInfo volInfo;

   // get all FileIO plugins
   std::vector<vlPlugin*> plugins = vlKernel::trader()->getPluginsForGroup("FileIO");
   vlVolFioFilter *filter;
   std::vector<vlPlugin*>::iterator itr = plugins.begin();

   // loop over the filters to find the filter that provides IO capability for the given format
   for(; itr!=plugins.end(); ++itr) {
#ifdef DEBUG
std::cout << "Trying filter [Name:" << (*itr)->info().name() << std::flush;
#endif

      filter = (vlVolFioFilter*) (*itr);
      // make sure the pointer is valid
      if(!filter) {
#ifdef DEBUG
std::cout << "FAILED" << std::endl;
#endif
         continue;
      }

#ifdef DEBUG
std::cout << ",Format:" << filter->info().service() << "] ... " << std::flush;
#endif

      // Check if file format is specified
      if(fileFormat.size()) {
         // if file format is specified, then only the plugins of that file format will be used : no
         // autodetection.

         // Check if the plugin supports the required format
         // else, continue to next plugin
         if(filter->info().service() != fileFormat) {
#ifdef DEBUG
std::cout << "FAILED" << std::endl;
#endif
            continue; // to next filter
         }
      } else if(useFileExt) { // check file extension
         // Compare the file extension to the supported extensions of the current plugin

         std::string fileExt = filename.substr(filename.rfind(".")+1);

         // make sure there is indeed an extension to the filename
         if(fileExt.size()) {
            bool matchFound(false);
#ifdef DEBUG
std::cout << "File Ext : " << fileExt << " .. Checking supported extensions .. " << std::flush;
#endif
            std::vector<std::string>::const_iterator iter = filter->getFileExtensions().begin();
            std::vector<std::string>::const_iterator iterEnd = filter->getFileExtensions().end();
            while(iter!=iterEnd) {
#ifdef DEBUG
std::cout << "\"" << *iter << "\"" << std::flush;
#endif
               if(*iter == fileExt) {
#ifdef DEBUG
std::cout << " MATCH!" << std::endl;
#endif
                  matchFound = true;
                  break; // get out of the while loop
               }
               ++iter;
            }
            if(!matchFound) {
#ifdef DEBUG
std::cout << "FAILED" << std::endl;
#endif
               continue; // to the next filter
            }
         } else {
#ifdef DEBUG
std::cout << "FAILED" << std::endl;
#endif
            continue; // to next filter
         }
      } //useFileExt

      // rewind file pointer
      rewind(fp);

      // Check if given volume information is to be used to open the volume
      if(info.isValid()) {
#ifdef DEBUG
std::cout << "[II] Using given info to read the file." << std::endl;
#endif
         // use this information to read the file
         volInfo = info;
#ifdef DEBUG
std::cout <<filename<<std::endl;
#endif
      } else { // read the information from the file using the current plugin
         if(!filter->readInfo(volInfo, fp, filename)) {
#ifdef DEBUG
std::cout << "FAILED" << std::endl;
#endif
            continue; // to next filter
         }
      }

      // allocate memory according to the info read
      resizeData(volInfo.dim(), volInfo.dataType(), volInfo.units(), dataLayoutName());

      // try to read data using volInfo
      if(!filter->readData(volInfo, m_pVolData, fp, filename)) {
#ifdef DEBUG
std::cout << "FAILED" << std::endl;
#endif
         continue; // to next filter
      } else {
#ifdef DEBUG
std::cout << "OK" << std::endl;
#endif
      }
#ifdef DEBUG
std::cout << "File Info : \nVolume dimensions : " << volInfo.dim() << std::endl;
#endif

      // close file
      fclose(fp);

      // copy extra info over
      ((vlVarList*)(&m_extraInfo))->clear();
      *((vlVarList*)(&m_extraInfo)) = *(volInfo.extraInfo());

      if(volInfo.extraInfo()->isDefined("name")) {
         // copy the name over
         std::string tempName;
         volInfo.extraInfo()->get("name", tempName);
         m_extraInfo.set("name", tempName);
      } else {
         // create a name from the filename
         std::string name = filename.substr(filename.rfind("/")+1);
         if(!name.size())
            name = filename;
         m_extraInfo.set("name", name);
      }

      m_extraInfo.set("origFilename", filename);

      // success
      return(true);

   } // end-for

   // failure
   return(false);
}


template <class DataType>
bool vlVolume::copyDataT(DataType & dummy, vlVolData *fromData, vlVolData *toData, vlPoint3ui fromPos, vlPoint3ui toPos)
{
   // copy data same data type from fromData at fromPos to toData at toPos
   vlVolIter<DataType> *toItr=new vlVolIter<DataType>(toData);
   vlVolIter<DataType> *fromItr = new vlVolIter<DataType>(fromData);
   int nx=min((int)fromData->dim().x(),toData->dim().x()-toPos.x());
   int ny=min((int)fromData->dim().y(),toData->dim().y()-toPos.y());
   int nz=min((int)fromData->dim().z(),toData->dim().z()-toPos.z());

   if(nx<=0||ny<=0||nz<=0) return(false);
   for(int slice=0;slice<nz;slice++) {
      vlPoint3ui from(fromPos.x(),fromPos.y(),slice+fromPos.z());
      vlPoint3ui to(toPos.x(),toPos.y(),slice+toPos.z());

      //#ifdef DEBUG std::cout<<" "<<(int) to.z()<<std::flush;

      vlPoint3ui idx(0,0,0);
      for(idx.y(0); idx.y()<ny; idx.y(idx.y()+1)) {
         idx.x(0);
         fromItr->moveTo(from + idx);
         toItr->moveTo(to + idx);
         for(; idx.x()<nx; idx.x(idx.x()+1)) {

            toItr->set(fromItr->get());
      //if (fromItr->get()>50) std::cout<<fromItr->get()<<std::flush;else 
//std::cout<<"+"<<std::flush;
            toItr->nextXYZ();
            fromItr->nextXYZ();
         }
      }
   }
   return(true);
}

template <class DataType>
bool vlVolume::cropSliceT(DataType & dummy, vlPoint3ui subVolPos, vlPoint3ui volPos)
{
   // copy one slice of same data type from x,y position subVolPos to volPos
   vlVolIter<DataType> *iter=new vlVolIter<DataType>(m_pVolData);
   vlVolIter<DataType> *slcItr = new vlVolIter<DataType>(m_pSliceData);
   vlPoint3ui idx(0,0,0);
   for(idx.y(0); idx.y()<dim().y(); idx.y(idx.y()+1)) {
      idx.x(0);
      slcItr->moveTo(subVolPos + idx);
      iter->moveTo(volPos + idx);
      for(; idx.x()<dim().x(); idx.x(idx.x()+1)) {
         iter->set(slcItr->get());
//if (slcItr->get()>50) std::cout<<slcItr->get()<<std::flush;
//else 
//std::cout<<"/"<<std::flush;
         iter->nextXYZ();
         slcItr->nextXYZ();
      }
   }

   return(true);
}

bool vlVolume::cropREDtoRGBA(vlPoint3ui subVolPos, vlPoint3ui volPos, uint8 threshold)
{
   bool RTN_VAL(false);
   // copy one slice from x,y position subVolPos to volPos
   vlVolIter<vlColorRGBAub> *iter=new vlVolIter<vlColorRGBAub>(m_pVolData);
   vlVolIter<vlColorRGBub> *slcItr = new vlVolIter<vlColorRGBub>(m_pSliceData);

   vlPoint3ui idx(0,0,0);
   for(idx.y(0); idx.y()<dim().y(); idx.y(idx.y()+1)) {
      idx.x(0);
      slcItr->moveTo(subVolPos + idx);
      iter->moveTo(volPos + idx);
      for(; idx.x()<dim().x(); idx.x(idx.x()+1)) {
         vlColorRGBAub voxelColor(vlColorRGBAub(slcItr->get().r(),slcItr->get().b(),slcItr->get().b()));
         uint8 red=slcItr->get().r();
         uint8 green=slcItr->get().g();
         uint8 blue=slcItr->get().b();
         if(red>=threshold) RTN_VAL=true;
         iter->set(voxelColor);
         iter->nextXYZ();
         slcItr->nextXYZ();
      }
   }
   return(RTN_VAL);
}


bool vlVolume::cropRGBtoRGBA(vlPoint3ui subVolPos, vlPoint3ui volPos, uint8 threshold)
{
   bool RTN_VAL(false);
   // copy one slice from x,y position subVolPos to volPos
   vlVolIter<vlColorRGBAub> *iter=new vlVolIter<vlColorRGBAub>(m_pVolData);
   vlVolIter<vlColorRGBub> *slcItr = new vlVolIter<vlColorRGBub>(m_pSliceData);
//std::cout<<" ***cropRGBtoRGBA**" <<threshold<<std::flush;
   vlPoint3ui idx(0,0,0);
   for(idx.y(0); idx.y()<dim().y(); idx.y(idx.y()+1)) {
      idx.x(0);
      slcItr->moveTo(subVolPos + idx);
      iter->moveTo(volPos + idx);
      for(; idx.x()<dim().x(); idx.x(idx.x()+1)) {
      uint8 red=slcItr->get().r();
      uint8 green=slcItr->get().g();
            uint8 blue=slcItr->get().b();
         vlColorRGBAub voxelColor(red,green,blue);

         if(red>=threshold) RTN_VAL=true;
         iter->set(voxelColor);
         iter->nextXYZ();
         slcItr->nextXYZ();
      }
   }
   return(RTN_VAL);
}


bool vlVolume::cropRGBtoRed(vlPoint3ui subVolPos, vlPoint3ui volPos, uint8 threshold) {
   // copy one slice from x,y position subVolPos to volPos
   vlVolIter<uint8> *iter=new vlVolIter<uint8>(m_pVolData);
   vlVolIter<vlColorRGBub> *slcItr = new vlVolIter<vlColorRGBub>(m_pSliceData);
//#ifdef DEBUG std::cout<<" ***cropRGBtoRED***" <<threshold<<std::flush;
   vlPoint3ui idx(0,0,0);
   bool RTN_VAL;
   RTN_VAL=false;
   for(idx.y(0); idx.y()<dim().y(); idx.y(idx.y()+1)) {
      idx.x(0);
      slcItr->moveTo(subVolPos + idx);
      iter->moveTo(volPos + idx);
      for(; idx.x()<dim().x(); idx.x(idx.x()+1)) {
         uint8 red=slcItr->get().r();
         if(!RTN_VAL&&red>=threshold) {//#ifdef DEBUG std::cout<<iter->pos()<<" "<<std::flush;
   RTN_VAL=true;}
         iter->set(red);//if (red>50)#ifdef DEBUG std::cout<<(int)red<<" "<<std::flush;
         iter->nextXYZ();
         slcItr->nextXYZ();
      }
   }
   return(RTN_VAL);
}

bool vlVolume::readSubvolumes(const std::string & imgfilepath, const std::string & imgfilelist, const vlVolInfo & imgInfo, const vlVolInfo & info, const unsigned int nsubVols, const unsigned int subVolStart)
{
   int readsubvols=0;

   std::string imgname;
   int subvol;
   subvol=0;
   //Get the image file names from disk
   FILE *lfp = fopen(imgfilelist.c_str(), "r");
   if(!lfp) {
      // error ("unable to open file");
#ifdef DEBUG
std::cout << "Unable to open imgfilelist " <<imgfilelist << " for reading." << std::endl;
#endif
      return(false);
   }
#ifdef DEBUG
std::cout << "OPENED " <<imgfilelist<< std::endl;
#endif
   std::vector< std::string > imglist;
   char imageFile[100],str[100];
   while(1) {

      // read information from the file
      fgets(str,100,lfp);
      sscanf(str,"%s",imageFile);
      imgname=imageFile;
      if(subvol>=subVolStart&&subvol<subVolStart+nsubVols) {
         imglist.push_back(imgname);readsubvols++;
      }
      subvol++;
      //check if its EOF
      if(feof(lfp)) {//subvol>=subVolStart+subvols||

#ifdef DEBUG
std::cout << "Actual subvols read " << readsubvols << std::endl;
#endif
         break;
      }

   }

   fclose(lfp);
   if(imglist.empty()) return(false);

   else return(readSubvolumes(imgfilepath,imglist,imgInfo,info,readsubvols,subVolStart));

}

bool vlVolume::readSubvolumes(const std::string & imgfilepath, std::vector< std::string > imglist, const vlVolInfo & info, const unsigned int nsubVols, const unsigned int subVolStart) {
   vlVolInfo imgInfo;

   return(readSubvolumes(imgfilepath,imglist,imgInfo,info,nsubVols,subVolStart));

}


bool vlVolume::readSubvolumes(const std::string & imgfilepath, std::vector< std::string > imglist, const vlVolInfo & imgInfo, const vlVolInfo & info, const unsigned int nsubVols, const unsigned int subVolStart) {
   // temp variables to store info
   vlVolInfo volInfo;
   vlVolInfo subVolInfo;
   int subvols;
   int readsubvols;
   int slices=0;
   bool consecutiveSubVols=true;
   vlDim dim;
   FILE *fp;
   vlPoint3ui subVolPos(0,0,0);
   vlPoint3ui volPos;
   std::string filename;
   std::vector< std::string >::const_iterator sitr(imglist.begin());

   if(nsubVols>0) subvols=nsubVols;
   else subvols=imglist.size();

   filename=*sitr;

   //make sure vlKernel is initialized
   vlKernel::instance();
   std::vector<vlPlugin*> plugins = vlKernel::trader()->getPluginsForGroup("FileIO");
   vlVolFioFilter *filter;
   std::vector<vlPlugin*>::iterator itr = plugins.begin();
   std::string fileExt = filename.substr(filename.rfind(".")+1);

   // loop over the filters to find the filter that provides IO capability for the given format
   for(; itr!=plugins.end(); ++itr) {
#ifdef DEBUG
std::cout << "Trying filter [Name:" << (*itr)->info().name() << std::flush;
#endif

      filter = (vlVolFioFilter*) (*itr);
      // make sure the pointer is valid
      if(!filter) {
#ifdef DEBUG
std::cout << "FAILED" << std::endl;
#endif
         continue;
      }

#ifdef DEBUG
std::cout << ",Format:" << filter->info().service() << "] ... " << std::flush;
#endif


      // make sure there is indeed an extension to the filename
      if(fileExt.size()) {
         bool matchFound(false);
#ifdef DEBUG
std::cout << "File Ext : " << fileExt << " .. Checking supported extensions .. " << std::flush;
#endif
         std::vector<std::string>::const_iterator iter = filter->getFileExtensions().begin();
         std::vector<std::string>::const_iterator iterEnd = filter->getFileExtensions().end();
         while(iter!=iterEnd) {
#ifdef DEBUG
std::cout << "\"" << *iter << "\"" << std::flush;
#endif
            if(*iter == fileExt) {
#ifdef DEBUG
std::cout << " MATCH!" << std::endl;
#endif
               matchFound = true;
               break; // get out of the while loop
            }
            ++iter;
         }
         if(!matchFound) {
#ifdef DEBUG
std::cout << "FAILED" << std::endl;
#endif
            continue; // to the next filter
         }
      } else {
#ifdef DEBUG
std::cout << "FAILED" << std::endl;
#endif
         continue; // to next filter
      }

      // Check if given volume information is to be used to open the volume
      if(info.isValid()) {
         volInfo = info;
         //m_origFilePos=info.origFilePos();
      }
      //Called to crop all subvolumes at info.origFilePos
      if(imgInfo.isValid()) {
#ifdef DEBUG
std::cout << "Equal Dimension SubVolumes "  << std::flush;
#endif
         subVolPos=vlPoint3ui(imgInfo.origFilePos().x(),imgInfo.origFilePos().y(),0);
         slices=subvols*imgInfo.dim().z();
         if(!info.isValid()) volInfo = imgInfo;
         m_origFilePos=imgInfo.origFilePos();
         dim=vlDim(volInfo.dim().x(),volInfo.dim().y(),slices);
         subVolInfo=imgInfo;
      } else {
         //Determine dimensions and origFilePos of new volume to fit subvolumes
         int minx,miny,minz;
         int maxx=0;
         int maxy=0;
         int maxz=0;
         readsubvols=0;
//#ifdef DEBUG
std::cout<<"Using subvolume files for info ... "<< std::endl;
//#endif
         for(; sitr!=imglist.end(); ++sitr) {
            filename = *sitr;
            if(readsubvols>=subVolStart+subvols&&subvols>0) break;
            if(readsubvols>=subVolStart) {
               filename=imgfilepath+filename;
#ifdef DEBUG
         std::cout<<filename<<"  "<< std::endl;
#endif
               fp = fopen(filename.c_str(), "r");

               if(!filter->readInfo(subVolInfo, fp, filename)) {
#ifdef DEBUG
std::cout << "FAILED" << std::endl;
#endif
                  return(false);
               }
               if(readsubvols==subVolStart) {
                  minx=subVolInfo.origFilePos().x();
                  miny=subVolInfo.origFilePos().y();
                  minz=subVolInfo.origFilePos().z();
                  // #ifdef DEBUG std::cout<<"minx "<<minx<<" miny "<<miny<<" minz "<<minz<<std::endl; #endif

               }
               int ux=subVolInfo.origFilePos().x()+subVolInfo.dim().x();
               int uy=subVolInfo.origFilePos().y()+subVolInfo.dim().y();
               int uz=subVolInfo.origFilePos().z()+subVolInfo.dim().z();
std::cout<<filename<<subVolInfo.dim()<<"  x:"<<subVolInfo.origFilePos().x()<<"-"<<ux<<"  y:"<<subVolInfo.origFilePos().y()<<"-"<<uy<<"  z:"<<subVolInfo.origFilePos().z()<<"-"<<uz<<std::endl;
               if(ux>maxx) maxx=ux;
               if(uy>maxy) maxy=uy;
               if(uz>maxz) maxz=uz;
               if(subVolInfo.origFilePos().x()<minx) minx=subVolInfo.origFilePos().x();
               if(subVolInfo.origFilePos().y()<miny) miny=subVolInfo.origFilePos().y();
               if(subVolInfo.origFilePos().z()<minz) minz=subVolInfo.origFilePos().z();
               if(subVolInfo.origFilePos().z()>0) consecutiveSubVols=false;
               slices+=subVolInfo.dim().z();
            }
            readsubvols++;
         }
         m_origFilePos=vlPoint3ui(minx,miny,minz);
         if(consecutiveSubVols) dim=vlDim(maxx-minx,maxy-miny,slices);
         else
            dim=vlDim(maxx-minx,maxy-miny,maxz-minz);
//#ifdef DEBUG
   std::cout<<"maxy-miny "<<maxy<<"-"<<miny <<" dim "<<dim<<" m_origFilePos  "<<m_origFilePos<<std::endl;
//#endif
      }// Subvolume info not given
      vlDim odim(volInfo.origFileDim());
      m_origFileDim=odim;
      resizeData(dim, volInfo.dataType(), volInfo.units(), dataLayoutName());
      int px=0;
      int py=0;
      int pz=0;
      readsubvols=0;
      //std::vector< std::string >::const_iterator svitr(imglist.begin());
      sitr=imglist.begin();
      for(; sitr!=imglist.end(); ++sitr) {
         filename = *sitr;
         //#ifdef DEBUG std::cout<<filename<<"  "<< std::endl; #endif
         if(readsubvols>=subVolStart+subvols) break;
         if(readsubvols>=subVolStart) {
            filename=imgfilepath+filename;

            if(imgInfo.isValid()) {
               fp = fopen(filename.c_str(), "r");
               if(!fp) {
#ifdef DEBUG
std::cout << "Unable to open file " << filename << " for reading." << std::endl;
#endif
                  return(false);
               }
               // All subvolume positions are equal so place at start of volume
               volPos=vlPoint3ui(0, 0, pz);
               pz+=subVolInfo.dim().z();
            } else {
               if(!filter->readInfo(subVolInfo, fp, filename)) {
#ifdef DEBUG
std::cout << "FAILED" << std::endl;
#endif
                  return(false);
               }
               subVolInfo.setDataType(volInfo.dataType());
               //Shift precropped subvolumes to correct relative postion in volume
               px=subVolInfo.origFilePos().x()-m_origFilePos.x();
               py=subVolInfo.origFilePos().y()-m_origFilePos.y();
               if(consecutiveSubVols) {
                  volPos=vlPoint3ui(px,py,pz);
                  pz+=subVolInfo.dim().z()-1;
               } else {
                  pz=subVolInfo.origFilePos().z()-m_origFilePos.z();
                  volPos=vlPoint3ui(px,py,pz);
               }
               if(px<0||py<0||pz<0) return(false); //Shouldn't happen
            }
//#ifdef DEBUG std::cout << "px, py, pz "<<px<< "  " <<py<< "  " <<pz<< std::flush; #endif

            m_pSliceData = createData(subVolInfo.dim(), volInfo.dataType(), volInfo.units(), dataLayoutName());
            fp = fopen(filename.c_str(), "r");
            if(!filter->readData(subVolInfo, m_pSliceData, fp, filename)) {
#ifdef DEBUG
std::cout << "FAILED" << std::endl;
#endif
               return(false);
            }
            bool retValue(false);
#ifdef DEBUG
std::cout<<" copyDataT From: "<<subVolPos<<" to: "<<volPos<< std::endl;
#endif
            callFunctionOnDataType(m_pVolData->dataType(), retValue, copyDataT, m_pSliceData, m_pVolData, subVolPos, volPos);

            // close file
            fclose(fp);
            delete m_pSliceData;
         }// Subvolumes being used
         readsubvols++;
      } // Subvolume list loop
      // success
      return(true);
   } // end-for  // failure
   return(false);
}


std::queue< std::string >  vlVolume::readImages(const std::string & imgfilepath, const std::string & imgfilelist, const vlVolInfo & info, const unsigned int start) {
   vlVolInfo imgInfo;
   return(readImages(imgfilepath,imgfilelist,imgInfo,info,start));
}



std::queue< std::string >  vlVolume::readImages(const std::string & imgfilepath, const std::string & imgfilelist,
     const vlVolInfo & imgInfo, const vlVolInfo & info, const unsigned int start)
{
   std::queue< std::string > verifiedImages;
   // temp variables to store info
   int slices;
   int readslices=0;
   //vlDim dim(info.dim());
   slices=info.dim().z();

   std::string imgname;
   int slice;
   slice=0;
   //Get the image file names from disk
   FILE *lfp = fopen(imgfilelist.c_str(), "r");
   if(!lfp) {
      // error ("unable to open file");
#ifdef DEBUG
std::cout << "Unable to open imgfilelist " <<imgfilelist << " for reading." << std::endl;
#endif
      return(verifiedImages);
   }

   std::queue<std::string> imglist;
   char imageFile[100],str[100];
   while(1) {

      // read information from the file
      fgets(str,100,lfp);
      sscanf(str,"%s",imageFile);
      imgname=imageFile;
      if(slice>=start&&slice<start+slices) {
         imglist.push(imgname);
   readslices++;
      }
      slice++;
      //check if its EOF
      if(feof(lfp)) {
         //#ifdef DEBUG std::cout << "Actual slices read " << readslices << std::endl; #endif
         break;
      }
//dim.z(readslices);
      info.dim().z(readslices);
   }

   fclose(lfp);
   if(imglist.empty()) return(verifiedImages);
   else return(readImages(imgfilepath,imglist,imgInfo,info,start));
}

std::queue< std::string > vlVolume::readImages(const std::string & imgfilepath, std::queue< std::string > imglist, const vlVolInfo & imgInfo, const vlVolInfo & info, const unsigned int start=0){
   std::queue<std::string> verifiedImages;
uint8 threshold=50;

   std::string filename;
   vlVolInfo volInfo;
   vlVolInfo slcInfo;
   // Check if given volume information is to be used to open the volume
   if(info.isValid()) {
      volInfo = info;
   } else {
      return(verifiedImages);
   }
   int slices;
   slices=info.dim().z();//imglist.size();
   //std::cout<< imglist.size()<<"imglist READIMAGES info "<<info.dim().z()<<std::endl;
//info.dim().z();
   std::string imgname;
   int slice;
   slice=0;

   filename=imgfilepath+imglist.front();//imgname;
   // make sure vlKernel is initialized
   vlKernel::instance();
   std::vector<vlPlugin*> plugins = vlKernel::trader()->getPluginsForGroup("FileIO");
   vlVolFioFilter *filter;
   std::vector<vlPlugin*>::iterator itr = plugins.begin();
   std::string fileExt = filename.substr(filename.rfind(".")+1);//Use last filename read from imgfilelist

   // loop over the filters to find the filter that provides IO capability for the given format
   for(; itr!=plugins.end(); ++itr) {
#ifdef DEBUG
std::cout << "Trying filter [Name:" << (*itr)->info().name() << std::flush;
#endif

      filter = (vlVolFioFilter*) (*itr);
      // make sure the pointer is valid
      if(!filter) {
#ifdef DEBUG
std::cout << "FAILED" << std::endl;
#endif
         continue;
      }

#ifdef DEBUG
std::cout << ",Format:" << filter->info().service() << "] ... " << std::flush;
#endif


      // make sure there is indeed an extension to the filename
      if(fileExt.size()) {
         bool matchFound(false);
#ifdef DEBUG
std::cout << "File Ext : " << fileExt << " .. Checking supported extensions .. " << std::flush;
#endif
         std::vector<std::string>::const_iterator iter = filter->getFileExtensions().begin();
         std::vector<std::string>::const_iterator iterEnd = filter->getFileExtensions().end();
         while(iter!=iterEnd) {
#ifdef DEBUG
std::cout << "\"" << *iter << "\"" << std::flush;
#endif
            if(*iter == fileExt) {
#ifdef DEBUG
std::cout << " MATCH!" << std::endl;
#endif
               matchFound = true;
               break; // get out of the while loop
            }
            ++iter;
         }
         if(!matchFound) {
#ifdef DEBUG
std::cout << "FAILED" << std::endl;
#endif
            continue; // to the next filter
         }
      } else {
#ifdef DEBUG
std::cout << "FAILED" << std::endl;
#endif
         continue; // to next filter
      }
      // try to open the file
      FILE *fp = fopen(filename.c_str(), "r");//.c_str()
      if(!fp) {
         // error ("unable to open file");
#ifdef DEBUG
std::cout << "Unable to open file " << filename << " for reading." << std::endl;
#endif
         return(verifiedImages);
      }
      // Slice files may have a different data type and bytes per voxel than the volume we're
      // creating. Read info if it's not given.
      // Check if given volume information is to be used to open the volume
      if(imgInfo.isValid()) {
         // use this information to read the file
         slcInfo = imgInfo;
#ifdef DEBUG
std::cout << "[II] Using given info to read the image files. "  <<filename<< std::endl;
#endif
      } else { // read the information from the file using the current plugin
#ifdef DEBUG
std::cout<<" USING "<<filename<<" for image info "<< std::endl;
#endif

         if(!filter->readInfo(slcInfo, fp, filename)) {
#ifdef DEBUG
std::cout << "FAILED" << std::endl;
#endif
            return(verifiedImages);
         }
      }

      vlDim dim(volInfo.dim().x(),volInfo.dim().y(),slices);
      // allocate memory according to the info read
      resizeData(dim, volInfo.dataType(), volInfo.units(), dataLayoutName());
      //#ifdef DEBUG std::cout << "dim"<<dim.x()<<", "<<dim.y()<<", "<<dim.z()<<std::endl; #endif
m_origFilePos=volInfo.origFilePos();
#ifdef CDEBUG
     std::cout <<"SET m_origFilePos "<<m_origFilePos<<std::endl;
#endif


      int validSlices=0;
      for(slice=0;slice<slices;slice++) {

         // try to open the file
         imgname=imglist.front();

         filename = imgfilepath+imgname;//imglist.front();
#ifdef CDEBUG
std::cout << filename << " " << std::flush;
#endif
imglist.pop();
         fp = fopen(filename.c_str(), "r");
         if(!fp) {
#ifdef DEBUG
std::cout << "Unable to open file " << filename << " for reading." << std::endl;
#endif
            //return(verifiedImages);
         }else {

         m_pSliceData = createData(slcInfo.dim(), slcInfo.dataType(), slcInfo.units(), dataLayoutName());
         if(!filter->readData(slcInfo, m_pSliceData, fp, filename)) {
#ifdef DEBUG
std::cout << "FAILED" << std::endl;
#endif
            continue; // to next filter
         }
         fclose(fp);
         bool valid(false);
         vlPoint3ui subVolPos(m_origFilePos.x(), m_origFilePos.y(), 0);
         vlPoint3ui volPos(0, 0, validSlices);
         if(volInfo.dataType()==slcInfo.dataType()) {

            callFunctionOnDataType(slcInfo.dataType(), valid, cropSliceT, subVolPos, volPos);
            if(valid) {
               verifiedImages.push(imgname);
               validSlices++;
        // #ifdef DEBUG std::cout << "  " << imgname << std::flush; #endif
            }else {
#ifdef DEBUG
std::cout << imgname<< " EMPTY " << std::endl;
#endif
      }
         } else {
           if(volInfo.bytesPerVoxel()==4&&slcInfo.bytesPerVoxel()==1) {
               valid=cropREDtoRGBA(subVolPos, volPos, threshold);
               if(valid) {
                 verifiedImages.push(imgname);
                 validSlices++;
           //#ifdef DEBUG std::cout << "  " << imgname << std::flush; #endif
               } else {
#ifdef DEBUG
std::cout << imgname<< " EMPTY " << std::endl;
#endif
}
         }else {
         if(volInfo.bytesPerVoxel()==4&&slcInfo.bytesPerVoxel()==3) {
               valid=cropRGBtoRGBA(subVolPos, volPos, threshold);
               if(valid) {
                 verifiedImages.push(imgname);
                 validSlices++;
           //#ifdef DEBUG std::cout << "  " << imgname << std::flush; #endif
               }else {
#ifdef DEBUG
std::cout << imgname<< " EMPTY " << std::endl;
#endif
         }
            } else {
               if(volInfo.bytesPerVoxel()==1&&slcInfo.bytesPerVoxel()==3) {
                  valid=cropRGBtoRed(subVolPos, volPos, threshold);
                  if(valid) {
                     verifiedImages.push(imgname);
                     validSlices++;
         //#ifdef DEBUG std::cout << "  " << imgname << std::flush; #endif
                  }else {
#ifdef DEBUG
std::cout << imgname<< " EMPTY " << std::endl;
#endif
         }
               }
            }
      }//Not RED to RGBA
         }//Different data types
         delete m_pSliceData;
}
      } //slices loop
      const vlPoint3ui cropStart(m_origFilePos);
      vlDim newDim(dim.x(),dim.y(),validSlices);
//#ifdef DEBUG std::cout << "FOUND " <<validSlices<< " valid slices" <<std::endl; #endif

if(validSlices<slices) {
      //#ifdef DEBUG std::cout << "FOUND BAD SLICE: " <<validSlices<< " valid slices" <<std::endl; #endif

         resize(newDim, true, cropStart);
      }
      // success
      return(verifiedImages);

   } // end-for  // failure
   std::cout <<"READIMAGES m_origFilePos "<<m_origFilePos<<std::endl;

   return(verifiedImages);

}


bool vlVolume::write(const std::string & filename) const
{
   // pass an empty string for format
   std::string format;
   return(write(filename, format, false));
}


bool vlVolume::write(const std::string & filename, const std::string & fileFormat,
     const bool appendExtension) const
{
   if(!isValid()) {
#ifdef DEBUG
std::cout << "The current volume is not valid. Cannot proceed with write." << std::endl;
#endif
      return(false);
   }
   // get all FileIO plugins
   std::vector<vlPlugin*> plugins = vlKernel::trader()->getPluginsForGroup("FileIO");
   vlVolFioFilter *filter;
   unsigned int i;
   std::vector<vlPlugin*>::iterator itr = plugins.begin();
   FILE *fp;
   std::string finalFileName(filename);

   // loop over the filters to find the filter that provides IO capability for the given format
   for(; itr!=plugins.end(); ++itr) {
#ifdef DEBUG
std::cout << "Trying filter [Name:" << (*itr)->info().name() << std::flush;
#endif

      filter = (vlVolFioFilter*) (*itr);
      // make sure the pointer is valid
      if(!filter) {
#ifdef DEBUG
std::cout << "FAILED" << std::endl;
#endif
         continue;
      }

#ifdef DEBUG
std::cout << ",Format:" << filter->info().service() << "] ... " << std::flush;
#endif

      // Check if file format is specified
      if(fileFormat.size()) {
         // if file format is specified, then only that plugins of that file format will be used : no
         // autodetection.

         // Check if the plugin supports the required format
         // else, continue to next plugin
         if(strcasecmp(filter->info().service().c_str(), fileFormat.c_str())) {
#ifdef DEBUG
std::cout << "FAILED" << std::endl;
#endif
            continue; // to next filter
         }
      } else { // try to guess file format from file extension

         std::string fileExt = filename.substr(filename.rfind(".")+1);

         // make sure there is indeed an extension to the filename
         if(fileExt.size()) {
            bool matchFound(false);
#ifdef DEBUG
std::cout << "File Ext : " << fileExt << " .. Checking supported extensions .. " << std::flush;
#endif
            std::vector<std::string>::const_iterator iter = filter->getFileExtensions().begin();
            std::vector<std::string>::const_iterator iterEnd = filter->getFileExtensions().end();
            while(iter!=iterEnd) {
#ifdef DEBUG
std::cout << "\"" << *iter << "\"" << std::flush;
#endif
               if(*iter == fileExt) {
#ifdef DEBUG
std::cout << " MATCH!" << std::endl;
#endif
                  matchFound = true;
                  break; // get out of the while loop
               }
               ++iter;
            }
            if(!matchFound) {
#ifdef DEBUG
std::cout << "FAILED" << std::endl;
#endif
               continue; // to the next filter
            }
         } else {
#ifdef DEBUG
std::cout << "FAILED" << std::endl;
#endif
            continue; // to next filter
         }
      }

      // got the filter.. now get out!
#ifdef DEBUG
std::cout << "OK" << std::endl;
#endif
#ifdef DEBUG
std::cout << "Trying to write using this plugin ... " << std::flush;
#endif

      // Append extension if needed
      if(appendExtension) {
         std::string extension;
         // make sure there is a default extension
         if(filter->getFileExtensions().size()) {
            extension = filter->getFileExtensions().front();
            // make sure the default extension is not null
            if(extension.size()) {
               // make sure the current filename doesn't have the same extension already
               if(filename.substr(filename.rfind(".")+1) != extension) {
                  finalFileName=filename+"."+extension;
               }
            }
         }
      }

      // try to open the file
      fp = fopen(finalFileName.c_str(), "w");
      if(!fp) {
#ifdef DEBUG
std::cout << "\nUnable to open file " << finalFileName << " for writing." << std::endl;
#endif
         return(false);
      }

      // Now try to write using the plugin
      // If this plugin is not successful, delete the file and try next plugin.

      vlVolInfo *volInfo = getVolInfo();
      vlPoint3ui filePos=volInfo->origFilePos();
      // create a name from the filename
      // Write the header
      if(!filter->writeInfo(*volInfo, fp, finalFileName)) {
#ifdef DEBUG
std::cout << "FAILED" << "\nERROR writing header. Checking for another plugin." << std::endl;
#endif

         fclose(fp);
         continue;
      }

      // Write the data
      if(!filter->writeData(*volInfo, m_pVolData, fp, finalFileName)) {
#ifdef DEBUG
std::cout << "FAILED" << "\nERROR writing data. Checking for another plugin." << std::endl;
#endif
         fclose(fp);
         continue;
      }

      // success :)
      fclose(fp);
#ifdef DEBUG
std::cout << "\nWrote file : " << finalFileName << std::endl;
#endif
      return(true);
   }

   // failure
   return(false);
}

bool vlVolume::resize(vlDim const & newDim, const bool keep, const vlPoint3ui cropStart)
{
   if(!m_pVolData)
      return(false);
   else

      if(keep) {
      bool retValue;
      m_pSliceData =  createData(newDim, m_pVolData->dataType(), m_pVolData->units(), dataLayoutName());
      callFunctionOnDataType(m_pVolData->dataType(), retValue, copyDataT, m_pVolData, m_pSliceData,cropStart);
      resizeData(newDim, m_pVolData->dataType(), m_pVolData->units(), dataLayoutName());
      callFunctionOnDataType(m_pVolData->dataType(), retValue, copyDataT, m_pSliceData, m_pVolData);
      delete m_pSliceData;
      m_origFilePos=cropStart;
   } else

      return(resizeData(newDim, m_pVolData->dataType(), m_pVolData->units(), dataLayoutName()));

}

bool vlVolume::resizeData(const vlDim & newDim, const vlDataType dataType,
     const vlUnit & units, const std::string & layout)
{
   // delete any old data that exists
   if(m_pVolData)
      delete m_pVolData;
   if(m_layoutPlugin) {
      if(m_layoutPlugin->info().service() == layout) {
         vlVolData *data = m_layoutPlugin->getLayout(dataType, newDim, units);

         if(!data) {
#ifdef DEBUG
std::cout << "ERROR : vlVolume() - Plugin returns null for layout. [" << layout << "]" << std::endl;
#endif
            return(false);
         }

         m_pVolData = data;
         return(true);
      } else {
         // layout has changed
         delete m_layoutPlugin;
      }
   }

   vlVolDataLayoutPlugin *plugin =
        dynamic_cast<vlVolDataLayoutPlugin *> (vlKernel::trader()->getPlugin("VolDataLayout", layout));

   if(!plugin) {
#ifdef DEBUG
std::cout << "ERROR : vlVolume() - No plugin found for requested layout [" << layout << "]" << std::endl;
#endif
      return(false);
   }

   vlVolData *data = plugin->getLayout(dataType, newDim, units);

   if(!data) {
#ifdef DEBUG
std::cout << "ERROR : vlVolume() - Plugin returns null for layout. [" << layout << "]" << std::endl;
#endif
      return(false);
   }

   m_pVolData = data;

   // store the plugin pointer for quick access
   m_layoutPlugin = plugin;
//#ifdef DEBUG std::cout << "newDim "<<newDim<<" dataType "<<dataType<< std::endl; #endif

   return(true);
}


vlVolData* vlVolume::createData(const vlDim & newDim, const vlDataType dataType,
     const vlUnit & units, const std::string & layout)
{
   vlVolData *data;

   if(m_layoutPlugin) {
      if(m_layoutPlugin->info().service() == layout) {
         data = m_layoutPlugin->getLayout(dataType, newDim, units);

         if(!data) {
#ifdef DEBUG
std::cout << "ERROR : vlVolume() - Plugin returns null for layout. [" << layout << "]" << std::endl;
#endif
            return(false);
         }

         return(data);
      } else {
         // layout has changed
         delete m_layoutPlugin;
      }
   }

   vlVolDataLayoutPlugin *plugin =
        dynamic_cast<vlVolDataLayoutPlugin *> (vlKernel::trader()->getPlugin("VolDataLayout", layout));

   if(!plugin) {
#ifdef DEBUG
std::cout << "ERROR : vlVolume() - No plugin found for requested layout [" << layout << "]" << std::endl;
#endif
      return(false);
   }

   data = plugin->getLayout(dataType, newDim, units);

   if(!data) {
#ifdef DEBUG
std::cout << "ERROR : vlVolume() - Plugin returns null for layout. [" << layout << "]" << std::endl;
#endif
      return(0L);
   }

   // store the plugin pointer for quick access
   //m_layoutPlugin = plugin;

   return(data);
}

bool vlVolume::clear(const uint8 data)
{
   if(m_pVolData)
      return(m_pVolData->clear(data));
   else
      return(false);
}


vlDim vlVolume::dim() const
{
   if(m_pVolData)
      return(m_pVolData->dim());
   else
      return(vlDim(0,0,0));
}


vlStep vlVolume::stepping() const
{
   if(m_pVolData)
      return(m_pVolData->stepping());
   else
      return(vlStep(0,0,0));
}


vlUnit vlVolume::units() const
{
   if(m_pVolData)
      return(m_pVolData->units());
   else
      return(vlUnit(0,0,0));
}


uint16 vlVolume::bitsPerVoxel() const
{
   if(m_pVolData)
      return(m_pVolData->bitsPerVoxel());
   else
      return(0);
}


uint16 vlVolume::bytesPerVoxel() const
{
   if(m_pVolData)
      return(m_pVolData->bytesPerVoxel());
   else
      return(0);
}


uint64 vlVolume::voxelCount() const
{
   if(m_pVolData)
      return(m_pVolData->voxelCount());
   else
      return(0);
}


vlDataType vlVolume::dataType() const
{
   if(m_pVolData)
      return(m_pVolData->dataType());
   else
      return(UnknownDataType);
}

const char * vlVolume::typeInfo() const
{
   if(m_pVolData)
      return(m_pVolData->typeInfo());
   else
      return(0L);
}


vlLayoutType vlVolume::dataLayout() const
{
   if(m_pVolData)
      return(m_pVolData->layout());
   else
      return(vlLayout::Linear);
};


std::string vlVolume::dataLayoutName() const
{
   if(m_layoutPlugin)
      return(m_layoutPlugin->info().service());
   else
      return("Unknown");
}


bool vlVolume::isValid() const
{
   if(m_pVolData) {
      if(!m_pVolData->isValid())
         return(false);
      else
         return(true);
   } else
      return(false);
}

bool vlVolume::isDirty() const
{
   if(m_pVolData)
      return m_pVolData->isDirty();
   else
      return(false);
}

void vlVolume::setDirty(bool dirty)
{
   if(m_pVolData)
      m_pVolData->setDirty(dirty);
}


const vlVarList * vlVolume::extraInfo() const
{
   return(&m_extraInfo);
}

vlVarList * vlVolume::extraInfoRW()
{
   return(&m_extraInfo);
}


void * vlVolume::getVoxelVoidPtr(const vlPoint3ui & position) const
{
   if(m_pVolData)
      return(m_pVolData->getVoxelVoidPtr(position));
   else
      return 0L;
}


vlVolInfo * vlVolume::getVolInfo() const
{
   vlVolInfo *info = new vlVolInfo();

   info->setDim(dim());
   info->setStepping(stepping());
   info->setDataType(dataType());
   info->setUnits(units());
   info->setBitsPerVoxel(bitsPerVoxel());
   info->setBytesPerVoxel(bytesPerVoxel());
   info->setOrigFilePos(m_origFilePos);
   info->setOrigFileDim(m_origFileDim);
   info->setExtraInfo(&m_extraInfo);

   return(info);
}

vlVolDataLayoutPlugin * vlVolume::dataLayoutPlugin() const
{
   return(m_layoutPlugin);
}

---