f3d.cpp

Go to the documentation of this file.

// $Id: f3d.cpp,v 1.2 2003/10/15 16:42:28 lmanju 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 <iostream>
#include <stdio.h>

#include "vltriple.h"
#include "vlvoldata.h"
#include "vlvolinfo.h"
#include "vlvoliterator.h"
#include "vlvoldatalayout.h"
#include "vlconstants.h"
#include "vlgenericfactory.h"

#include "f3d.h"

typedef vlGenericFactory<vlVolFiof3d> vlVolFiof3dFactory;
VL_EXPORT_COMPONENT_FACTORY( f3dfio, vlVolFiof3dFactory );

#define PGM 6
#define PPM 5

vlVolFiof3d::vlVolFiof3d()
{
  infoRef().setVersion(0, 1, 0);
  infoRef().setService("f3d", "OpenVL's f3d FileIO Filter");
  infoRef().setName("f3dFileIO");

  m_fileExtensions.push_back("f3d");
}


vlVolFiof3d::~vlVolFiof3d()
{

}


const std::vector<std::string> & vlVolFiof3d::getFileExtensions() const
{
  return (m_fileExtensions);
}


bool vlVolFiof3d::readInfo(vlVolInfo & info, FILE * const fp, const std::string & filename)
{
  char buffer[80];
  int pnmType;
  unsigned int nx, ny;
  char f3dParam[80], f3dValue[80];
  // units in x y and z used for storing px, py, pz values
  float px(1.0), py(1.0), pz(1.0);
  // store type of physical unit.
  vlUnit::UnitType unitType;

  // image dimensions
  unsigned int iconWidth, iconHeight;

  /* get the type of the PNM */
  fgets(buffer, 80, fp);
  if(feof(fp))
    return false;
    
  if(sscanf(buffer, "P%d", &pnmType) != 1){
    return false;
  }

  if (!(pnmType == PPM || pnmType == PGM)){
    return false;
  }

  // get icon dimensions.
  fgets(buffer, 80, fp);
  sscanf(buffer, "%d", &iconWidth);
  sscanf(buffer, "%d", &iconHeight);
  
  // Version of f3d format.
  fgets(buffer, 80, fp);  
  float fVersion(0.0);
  sscanf(buffer, "#!f3d %f", &fVersion);
  std::cout << " F3D Version : " << fVersion << std::endl;

  if(!feof(fp))
  {
    fgets(buffer, 80, fp);
  }
  
  while(buffer[0] == '#') {
    if(buffer[1] == '!') {
      sscanf(buffer, "%s", f3dParam);
     // std::cout << " f3dparam : " << f3dParam << std::endl;

      if(strcmp(f3dParam, "#!endian") == 0) {
         sscanf(buffer, "#!endian %s", f3dValue);
         std::cout << "Endian : " << f3dValue << std::endl;
      }
      // getting dimensions.
      else if(strcmp(f3dParam, "#!vdim") == 0) {
      unsigned int a, b, c;
      sscanf(buffer, "#!vdim %d %d %d", &a, &b, &c);
      vlDim dim((uint16)a,(uint16)b,(uint16)c);
      info.setDim(dim);
      std::cout << "Read dimensions : " << info.dim() << std::endl;
    }// end if(vdim);

    // getting vtype
    else if(strcmp(f3dParam, "#!vtype") == 0) {
      sscanf(buffer, "#!vtype %s", f3dValue);
    if(strcmp(f3dValue, "f3dCubic") != 0)
      std::cout << "Grid not supported" << std::endl;
    else
      std::cout << "Grid Type : " << f3dValue << std::endl;
    } // end if(vtype);

    // ctype
    else if(strcmp(f3dParam, "#!ctype") == 0) {
      sscanf(buffer, "#!ctype %s", f3dValue);
    }// end if(ctype);

    // Setting data type  in info.SetDataType()  ***TODO
    else if(strcmp(f3dParam, "#!dtype") == 0) {
      sscanf(buffer, "#!dtype %s", f3dValue);
      if(strcmp(f3dValue, "f3dUChar") == 0)
        info.setDataType(UnsignedInt8);
      else if (strcmp(f3dValue, "f3dChar") == 0)
        info.setDataType(SignedInt8);
      else if(strcmp(f3dValue, "f3dUInt16") == 0)
        info.setDataType(UnsignedInt16);
      else if (strcmp(f3dValue, "f3dInt16") == 0)
        info.setDataType(SignedInt16);
      else if(strcmp(f3dValue, "f3dUInt32") == 0)
        info.setDataType(UnsignedInt32);
      else if (strcmp(f3dValue, "f3dInt32") == 0)
        info.setDataType(SignedInt32);
      else if (strcmp(f3dValue, "f3dFloat") == 0)
        info.setDataType(Float);
      else
        info.setDataType(UnknownDataType);
    }// end if(dtype);

    else if(strcmp(f3dParam, "#!units") == 0) {
      sscanf(buffer, "#!units %s", f3dValue);
      if(strcmp(f3dValue, "f3dUum") == 0)
        unitType = vlUnit::MicroMeter;
      else if (strcmp(f3dValue, "f3dUmm") == 0)
        unitType = vlUnit::MilliMeter;
      else if (strcmp(f3dValue, "f3dUm") == 0)
        unitType = vlUnit::Meter;
      else unitType = vlUnit::NoUnitType;

      std::cout << " Unit Type : " << unitType << std::endl;
    }// end if(units);

    // voxel size in x, y and z direction for cubic, regular and rect grids.
    else if(strcmp(f3dParam, "#!px") == 0) {
       sscanf(buffer, "#!px %f", &px);
    }
    else if(strcmp(f3dParam, "#!py") == 0) {
       sscanf(buffer, "#!py %f", &py);
    }
    else if(strcmp(f3dParam, "#!pz") == 0) {
       sscanf(buffer, "#!pz %f", &pz);
    }
    else if ((strcmp(f3dParam, "#!rx") ==0) ||
             (strcmp(f3dParam, "#!ry") ==0) ||
             (strcmp(f3dParam, "#!rz") ==0) ||
             (strcmp(f3dParam, "#!absMax") ==0) ||
             (strcmp(f3dParam, "#!absMin") ==0) ||
             (strcmp(f3dParam, "#!defaultMax") ==0) ||
             (strcmp(f3dParam, "#!defaultMin") ==0) ||
             (strcmp(f3dParam, "#!commLines") ==0) ||
             (strcmp(f3dParam, "#!comment") ==0) ||
             (strcmp(f3dParam, "#!last") ==0)) {
      // Do nothing. Skip as of now.
    }

    else {
      std::cout << "NOT supported : " << f3dParam << std::endl;
      std::cout << " Unsuported parameter" << std::endl;
    }
   } // end if loop.
   fgets(buffer, 80, fp); //  do i need to check end of file here?
  } //  end while loop

  unsigned int maxDensityValue;
  sscanf(buffer, "%d", &maxDensityValue);

  uint32 headerSize=ftell(fp);
  // add icon size
  headerSize+=iconWidth*iconHeight*3;
  info.setHeaderSize(headerSize);
  
  // storing units.
  vlUnit units(px, py, pz, unitType);
  info.setUnits(units);
  std::cout << "Read units : " << info.units() << std::endl;
  
  return (true);
}

bool vlVolFiof3d::readData(vlVolInfo & info, vlVolData * const data, FILE * const fp, const std::string & filename)
{
  // error checking
  if(fp == 0) {
    std::cout << "Invalid file pointer." << std::endl;
    return (false);
  }

  if(!info.isValid()) {
    std::cout << "Cannot load a volume coz volume info is not complete." << std::endl;
    return (false);
  }

  if(data->dim() != info.dim()) {
    std::cout << "Invaid data storage given to readData() - wrong dimensions" << std::endl;
    return (false);
  }

  if(data->dataType() != info.dataType()) {
    std::cout << "Invaid data storage given to readData() - wrong datatype" << std::endl;
    return (false);
  }

  // skip the header bytes
  fseek(fp, info.headerSize(), SEEK_SET);
  
  bool retVal(false);
  //callFunctionOnDataType(data->dataType(), retVal, readDataT, info, data, fp, filename);
  return (retVal);
}

template <class T>
bool vlVolFiof3d::readDataT(T & dummy, vlVolInfo & info, vlVolData * const data,
                           FILE * const fp, const std::string & filename)
{
  // get an iterator over the volume
  vlVolIter<T> iter(data);

  T voxel;
  uint32 voxelCount = info.dim().x()*info.dim().y()*info.dim().z();

  while(1){
    // check if its EOF
    if(feof(fp)) {
      // EOF reached before reading all voxels..
      std::cout << "EOF reached before reading all data. File is not complete." << std::endl;
      std::cout << voxelCount << " voxels missing from the file." << std::endl;
      // fill with zeros
      std::cout << "Filling remainder with zeros." << std::endl;
      voxel = 0;
      do {
        iter.set(voxel);
      } while (iter.nextXYZ());
      // get out
      return(true);
    } else {
      // get a voxel from the file
      fread(&voxel, sizeof(T), 1, fp);

      // put the voxel into the volume
      iter.set(voxel);
      if(!iter.nextXYZ()) {
        break;
      }
      --voxelCount;

      // this case should never happen. iter should break out of the loop!
      if(!voxelCount)
        break;
    } // if-else(EOF)
  } // while

  // It has to be eof now.. if not, more data in file ..
  if (!feof(fp)) {
    // volume dimensions are incorrect.. more data in file
    std::cout << "Volume dimensions are incorrect. More data remaining in file." << std::endl;
    std::cout << "Skipping additional data." << std::endl;

    return (true);
  }

  // success :)
  return (true);
}


bool vlVolFiof3d::writeInfo(const vlVolInfo & info, FILE * const fp, const std::string & filename)
{
  // write header to file
  fprintf(fp, "P7\n%d %d %d\n", (int)info.dim().x(), (int)info.dim().y(), (int)info.dim().z());
  fprintf(fp, "%d\n", (int)(pow(2, info.bitsPerVoxel())-1));

  return (true);
}

bool vlVolFiof3d::writeData(const vlVolInfo & info, const vlVolData * data,
                            FILE * const fp, const std::string & filename)
{
  // Write the data in the file as RAW data

  bool retValue;
  callFunctionOnDataType(data->dataType(), retValue, writeDataT, info, data, fp, filename);

  return (retValue);

}

template <class T>
bool vlVolFiof3d::writeDataT(T & dummy, const vlVolInfo & info, const vlVolData * data,
                            FILE * const fp, const std::string & filename)
{
  // define an iterator over the volume data
  vlVolIterConst<T> iter(data);
  T voxel;

  // put the raw data directly into the file
  do {
    voxel = iter.get();
    fwrite(&voxel, sizeof(T), 1, fp);
  } while (iter.nextXYZ());

  // success :)
  return (true);
}

---