dox/IO/vtkBrukerFIDReader.h

Go to the documentation of this file.

/*=========================================================================

  Program:   vtkCNMRRLibrary
  Module:    $RCSfile: vtkBrukerFIDReader.h,v $

  Copyright  2005  The Pennsylvania State University
  
          Notice
 
  The contents of this file are subject to The Pennsylvania State University 
  Open Source License (the "License"); you may not use this file except in 
  compliance with the License. You may obtain a copy of the License at H066 
  Radiology, NMR Building, 500 University Drive, Hershey, PA, 
  tel. (717) 531-6069 or via email at dcb210@psu.edu.
 
  Software distributed under the License is distributed on an "AS IS" basis, 
  WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License 
  for the specific language governing rights and limitations under the 
  License.
 
  The Original Code is listed under Exhibit A of the license.
 
  The Initial Developer of the Original Code is Don Bigler.
 
  Contributor(s):
  
=========================================================================*/
#ifndef __vtkBrukerFIDReader_h
#define __vtkBrukerFIDReader_h

// Values used to determine type of phase encoding.
typedef enum
{ 
   Read, 
   Linear, 
   Centred, 
   Rare, 
   User_Defined_Encoding
} ACQphaseEncodingMode;

// Values used to determine ACQ seperation mode.
typedef enum
{
   Equidistant=1,
   Contiguous,
   Var_Parallel,
   Var_Angle,
   Packages,
   Unknown
} ACQSliceSepnMode;
      
#include "vtkMedicalImageReader2.h"
#include "vtkCNMRRIOWin32Header.h"

class VTK_CNMRR_IO_EXPORT vtkBrukerFIDReader : public vtkMedicalImageReader2
{
   public:
      static vtkBrukerFIDReader *New();
      vtkTypeRevisionMacro(vtkBrukerFIDReader,vtkMedicalImageReader2);
      virtual void PrintSelf(ostream& os, vtkIndent indent);

      virtual int CanReadFile(const char* fname);

      virtual void SeekFile(int x, int echo, int slice, int y, int z, int nr);


      virtual const char* GetDescriptiveName()
      {
         return "Bruker fid";
      }


      vtkGetVectorMacro(RealDataExtent,int,12);
      

      vtkGetVectorMacro(RealModifiedDataExtent,int,12);


      vtkGetVectorMacro(RealDataIncrements,int,7);
      

      vtkGetVectorMacro(RealModifiedDataIncrements,int,7);


      vtkGetMacro(ACQ_dim, int);


      vtkGetVector3Macro(ACQ_size, int);


      vtkGetVector3Macro(ACQ_fov, double);


      vtkGetMacro(NumSlices, int);


      vtkGetMacro(Nechoes, int);
      

      vtkGetMacro(ACQ_n_echo_images, int);


      vtkGetMacro(NumRepetitions, int);


      vtkGetMacro(ACQ_echo_timeArraySize, int);

      double *GetACQ_echo_time() {return this->ACQ_echo_time;};
      

      vtkGetMacro(ACQ_repetition_timeArraySize, int);

      double *GetACQ_repetition_time() {return this->ACQ_repetition_time;};


      vtkGetMacro(ACQ_slice_thick, double);
      

      vtkGetMacro(ACQ_phase_factor, int);


      vtkGetVector3Macro(EchoPosition, int);


      vtkGetVectorMacro(Nucleus,char,9);
      

      vtkGetMacro(BaseFrequency, double);
      

      vtkGetVector3Macro(ACQ_grad_matrixArraySize, int);
      
      double *GetACQ_grad_matrix() {return this->ACQ_grad_matrix;};


      vtkGetMacro(SliceOrderArraySize, int);
      
      double *GetACQ_read_offset() {return this->ACQ_read_offset;};


      vtkGetMacro(ACQ_read_offsetArraySize, int);
      
      double *GetACQ_phase1_offset() {return this->ACQ_phase1_offset;};


      vtkGetMacro(ACQ_phase1_offsetArraySize, int);
      
      double *GetACQ_phase2_offset() {return this->ACQ_phase2_offset;};


      vtkGetMacro(ACQ_phase2_offsetArraySize, int);
      
      int *GetSliceOrder() {return this->SliceOrder;};
      

      vtkSetMacro(SortSlices, int);
      vtkGetMacro(SortSlices, int);
      vtkBooleanMacro(SortSlices, int);


      vtkGetMacro(YOrderArraySize, int);
      
      int *GetYOrder() {return this->YOrder;};
      

      vtkSetMacro(SortYAxis, int);
      vtkGetMacro(SortYAxis, int);
      vtkBooleanMacro(SortYAxis, int);


      vtkGetMacro(ZOrderArraySize, int);
      
      int *GetZOrder() {return this->ZOrder;};
      

      vtkSetMacro(SortZAxis, int);
      vtkGetMacro(SortZAxis, int);
      vtkBooleanMacro(SortZAxis, int);
      

      vtkSetMacro(ReverseAlternateRows, int);
      vtkGetMacro(ReverseAlternateRows, int);
      vtkBooleanMacro(ReverseAlternateRows, int);
      

      vtkSetMacro(ReverseAlternateColumns, int);
      vtkGetMacro(ReverseAlternateColumns, int);
      vtkBooleanMacro(ReverseAlternateColumns, int);

   protected:
      vtkBrukerFIDReader();
      ~vtkBrukerFIDReader();

      virtual void ExecuteInformation();
      virtual void ExecuteData(vtkDataObject *out);
      virtual void ComputeDataIncrements();

      // Sort variables.
      int SortSlices;
      int SortYAxis;
      int SortZAxis;
      int ReverseAlternateRows;
      int ReverseAlternateColumns;
      int StandardKblockFormat;

      // Create YOrder & ZOrder Arrays.
      int CreateOrderArrays();
   
      // The real data extents for a Bruker fid file
      // are actually 6 dimensional.
      int RealDataExtent[12];
   
      // The real extents need to modified for fid's
      // where ACQ_phase_factor > 1.
      int RealModifiedDataExtent[12];

      // Data increments are calculated differently
      // for an fid file.
      int RealDataIncrements[7];
      int RealModifiedDataIncrements[7];

      // Important variables used for image
      // reconstruction and therefore exposed
      // publically.
      int ACQ_dim;
      int ACQ_size[3];
      int NumSlices;
      int Nechoes;
      int ACQ_n_echo_images;
      int NumRepetitions;
      int EchoPosition[3];
      char Nucleus[9];
      double BaseFrequency;

      // Other variables.
      int ACQ_grad_matrixArraySize[3];
      double *ACQ_grad_matrix;
      int ACQ_obj_orderArraySize;
      int *ACQ_obj_order;
      int ACQ_fovSize;
      double *ACQ_echo_time;
      int ACQ_echo_timeArraySize;
      double *ACQ_repetition_time;
      int ACQ_repetition_timeArraySize;
      double ACQ_fov[3];
      double *ACQ_slice_sepn;
      int ACQ_slice_sepnArraySize;
      double ACQ_slice_thick;
      int ACQ_phase_factor;
      int ACQ_rare_factor;
      int ACQ_phase_encoding_size;
      ACQphaseEncodingMode *ACQ_phase_encoding_mode;
      ACQSliceSepnMode ACQ_slice_sepn_mode;
      int ACQ_phase_enc_start;
      double *ACQ_phase_enc_start_array;
      int ACQ_spatial_size1;
      double *ACQ_spatial_phase1;
      int ACQ_spatial_size2;
      double *ACQ_spatial_phase2;
      double *ACQ_read_offset;
      int ACQ_read_offsetArraySize;
      double *ACQ_phase1_offset;
      int ACQ_phase1_offsetArraySize;
      double *ACQ_phase2_offset;
      int ACQ_phase2_offsetArraySize;     
      int *SliceOrder;
      int   SliceOrderArraySize;
      int *YOrder;
      int   YOrderArraySize;
      int *ZOrder;
      int   ZOrderArraySize;
      
   private:
      vtkBrukerFIDReader(const vtkBrukerFIDReader&);  // Not implemented.
      void operator=(const vtkBrukerFIDReader&);  // Not implemented.
};

#endif

---