VolumeSeries.h

/*  VolumeSeries.h

    Mark Woolrich, FMRIB Image Analysis Group

    Copyright (C) 1999-2000 University of Oxford  */

/*  CCOPYRIGHT  */

#include <iostream>
#include <fstream>
#define WANT_STREAM
#define WANT_MATH

#include "newmatap.h"
#include "newmatio.h"

#include <string>

using namespace NEWMAT;

namespace FILM {
  
#if !defined(__VolumeSeries_h)
#define __VolumeSeries_h

  // Rows are volumes
  // Columns are (time) series
  // num Rows is size of (time) series
  // num Cols is size of volumes
  class VolumeSeries : public Matrix
    {
    public:

      struct Dims
      {
	// Volume dimensions (no. of voxels):
	int x;
	int y;
	int z;
	int v;
	
	// Voxel dimensions (mm)
	float vx;
	float vy;
	float vz;
	float tr;
      };

      VolumeSeries() : Matrix() {}
      
      VolumeSeries(const Dims& pdims, const ColumnVector& in) : 
	Matrix(),
	dims(pdims),
	preThresholdPositions(in)
	{}

      VolumeSeries(int pnumVols, int pnumSeries) : 
	Matrix(pnumVols, pnumSeries), 
	means(pnumSeries){}
      
      VolumeSeries(int pnumVols, int pnumSeries, const Dims& pdims, const ColumnVector& in) : 
	Matrix(pnumVols, pnumSeries), 
	dims(pdims),
	preThresholdPositions(in),
	means(pnumSeries){}

      VolumeSeries& operator=(const VolumeSeries& vol) { 
	Matrix::operator=(vol); 
	preThresholdPositions = vol.preThresholdPositions;
	dims = vol.dims;
	means = vol.means;
	return *this;
      }
      VolumeSeries& operator=(const Matrix& mat) {
	Matrix::operator=(mat);
	return *this;
      }

      VolumeSeries& operator=(float pin) { 
	Matrix::operator=(pin); 
	return *this;
      }
      VolumeSeries(const VolumeSeries& vol){operator=(vol);}
      VolumeSeries(const Matrix& pmat) : Matrix(pmat) {}
      
      void thresholdSeries(float thresh, bool removeMean);
      void thresholdSeries();
      void unthresholdSeries();
      void unthresholdSeries(const Dims& pdims,const ColumnVector& in);
      void removeSeriesMeans();

      const ColumnVector& getPreThresholdPositions() const { return preThresholdPositions; } 
      void setPreThresholdPositions(const ColumnVector& in) { preThresholdPositions = in; }

      int getNumVolumes() const { return Nrows(); }
      int getNumSeries() const { return Ncols(); }

      const GetSubMatrix& getSeries(int i) const { return Column(i); }
      GetSubMatrix& getSeries(int i) { return Column(i); }
      const GetSubMatrix& getVolume(int i) const { return Row(i); }
      GetSubMatrix& getVolume(int i) { return Row(i); }
    
      void read(const string& fname);
      void writeAsInt(const string& fname);
      void writeAsFloat(const string& fname);
      
      void replaceMeans();

      const Dims& getDims() const { return dims; }
      void setDims(const Dims& pdims) { dims = pdims; }

      int getUnthresholdNumSeries() const { return dims.x*dims.y*dims.z; }
      
    protected:
      Dims dims;
      ColumnVector preThresholdPositions; 
      ColumnVector means;
    };

#endif

}