dox/IO/vtkPhilipsPAR.h

Go to the documentation of this file.

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

  Program:   vtkCNMRRLibrary
  Module:    $RCSfile: vtkPhilipsPAR.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 _vtkPhilipsPAR_h
#define _vtkPhilipsPAR_h

#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <vector>
#include "vtkObject.h"
#include "vtkCNMRRIOWin32Header.h"

#define RESEARCH_IMAGE_EXPORT_TOOL_V3       30
#define RESEARCH_IMAGE_EXPORT_TOOL_V4       40
#define RESEARCH_IMAGE_EXPORT_TOOL_V4_1     41
#define RESEARCH_IMAGE_EXPORT_TOOL_V4_2     42
#define RESEARCH_IMAGE_EXPORT_TOOL_UNKNOWN  -1

#define PAR_DEFAULT_STRING_LENGTH           32
#define PAR_DEFAULT_TRIGGER_TIMES_SIZE      128
#define PAR_DEFAULT_ECHO_TIMES_SIZE         128
#define PAR_DEFAULT_REP_TIMES_SIZE          128
#define PAR_DEFAULT_IMAGE_TYPES_SIZE        8
#define PAR_DEFAULT_SCAN_SEQUENCE_SIZE      8
#define PAR_RESCALE_VALUES_SIZE             3
#define PAR_DIFFUSION_VALUES_SIZE           3

#define PAR_SLICE_ORIENTATION_TRANSVERSAL   1
#define PAR_SLICE_ORIENTATION_SAGITTAL      2
#define PAR_SLICE_ORIENTATION_CORONAL       3

struct par_parameter  //par_parameter
{
  int problemreading; // Marked 1 if problem occurred reading in PAR file
  int ResToolsVersion; // V3, V4, V4.1, or V4.2 PAR/REC version
  char patient_name[PAR_DEFAULT_STRING_LENGTH]; // Patient name
  char exam_name[PAR_DEFAULT_STRING_LENGTH]; // Examination name
  char protocol_name[PAR_DEFAULT_STRING_LENGTH]; // Protocol name
  char exam_date[PAR_DEFAULT_STRING_LENGTH]; // Examination date/time
  char exam_time[PAR_DEFAULT_STRING_LENGTH]; // Examination date/time
  char series_type[PAR_DEFAULT_STRING_LENGTH]; // Series Type
  int scno; // Acquisition nr
  int recno; // Reconstruction nr
  int scan_duration; // Scan Duration [sec]
  int cardiac_phases; // Max. number of cardiac phases
  float trigger_times[PAR_DEFAULT_TRIGGER_TIMES_SIZE]; // trigger_time (float)
  int echoes; // Max. number of echoes
  float echo_times[PAR_DEFAULT_ECHO_TIMES_SIZE]; // Echo times read from PAR file
  int slice; // Max. number of slices/locations
  int dyn; // Max. number of dynamics
  int mixes; // Max. number of mixes
  char patient_position[PAR_DEFAULT_STRING_LENGTH]; // Patient position
  char prep_direction[PAR_DEFAULT_STRING_LENGTH]; // Preparation direction
  short int bit; // Image pixel size [8 or 16 bits]
  char technique[PAR_DEFAULT_STRING_LENGTH]; // Technique
  char scan_mode[PAR_DEFAULT_STRING_LENGTH]; // Scan mode
  int num_averages; // Number of averages
  int scan_resolution[2]; // Scan resolution  (x, y)
  int scan_percent; // Scan percentage
  int dim[3]; // Recon resolution (x, y) + slices (z)
  float repetition_time[PAR_DEFAULT_REP_TIMES_SIZE]; // Repetition time [msec]
  int sliceorient; // slice orientation ( TRA/SAG/COR ) (integer)
  float slth; // Slice thickness [mm]
  float gap; // Slice gap [mm]
  float fov[3]; // FOV (ap,fh,rl) [mm]
  float water_fat_shift; // Water Fat shift [pixels]
  float angAP; // Angulation midslice(ap,fh,rl)[degr]
  float angFH; // Angulation midslice(ap,fh,rl)[degr]
  float angRL; // Angulation midslice(ap,fh,rl)[degr]
  float offAP; // Off Centre midslice(ap,fh,rl) [mm]
  float offFH; // Off Centre midslice(ap,fh,rl) [mm]
  float offRL; // Off Centre midslice(ap,fh,rl) [mm]
  int flow_comp; // Flow compensation <0=no 1=yes> ?
  int presaturation; // Presaturation     <0=no 1=yes> ?
  int cardiac_freq; // Cardiac frequency
  int min_rr_int; // Min. RR interval
  int max_rr_int; // Max. RR interval
  float phase_encode_vel[3]; // Phase encoding velocity [cm/sec]
  int mtc; // MTC               <0=no 1=yes> ?
  int spir; // SPIR              <0=no 1=yes> ?
  int epi; // EPI factor        <0,1=no EPI>
  int turbo; // TURBO factor      <0=no turbo>
  int dynamic_scan; // Dynamic scan      <0=no 1=yes> ?
  int diffusion; // Diffusion         <0=no 1=yes> ?
  float diff_echo; // Diffusion echo time [msec]
  float inversion_delay; // Inversion delay [msec]
  int max_num_diff_vals; // Max. number of diffusion values
  int max_num_grad_orient; // Max. number of gradient orients
  int num_label_types; // Number of label types   <0=no ASL>
  float vox[3]; // pixel spacing (x,y) (in mm)
  int slicessorted; // 1-slices sorted, 0-slices not sorted
  int image_blocks; // The total number of image blocks stored in the REC file
  int num_image_types; // The number of image types in the REC file
  int image_types[PAR_DEFAULT_IMAGE_TYPES_SIZE]; // The different image types 
                                                 // detected in the REC
  int num_scanning_sequences; // The number of scanning sequences in the REC file
  int scanning_sequences[PAR_DEFAULT_SCAN_SEQUENCE_SIZE]; // The different 
                                                          // scanning sequences 
                                                          // detected in the REC
  int num_slice_repetitions; // If num_scanning_sequences > 1 then 
                  // num_image_types may not equal the total number of slice 
                  // repetitions for a single acquisition.  This value is the 
                  // total number of slice repetitions for a single acquisition 
                  // and is valid only when slicessorted == 0.

};

// .NAME vtkPhilipsPAR - read Philips PAR/REC image files
// .SECTION Description
// Class for reading parameters from a Philips PAR file.
//
// .SECTION See Also
// vtkPhilipsRECReader

class VTK_CNMRR_IO_EXPORT vtkPhilipsPAR : public vtkObject
{
public:
  static vtkPhilipsPAR *New();

  vtkTypeRevisionMacro(vtkPhilipsPAR,vtkObject);
  void PrintSelf(ostream& os, vtkIndent indent);


  // Reads the PAR file parameters in "parFile" and stores the PAR parameters in 
  // pPar.
  // Returns false if an error is encountered during reading, otherwise true is 
  // returned.
  bool ReadPAR(std::string parFile, struct par_parameter* pPar);

  // Returns a vector of paired values, the first contains the slice index and the 
  // second is the image type for the PAR file "parFile".
  std::vector< std::pair< int, int > > GetRECSliceIndexImageTypes(
    std::string parFile);

  // Returns a vector of paired values, the first contains the slice index and the 
  // second is the scan sequence for the PAR file "parFile".
  std::vector< std::pair< int, int > > GetRECSliceIndexScanningSequence(
    std::string parFile);

  // Returns a vector of paired values, the first contains the image type and the 
  // second is the scan sequence for that image type for the PAR file "parFile".
  std::vector< std::pair< int, int > > GetImageTypesScanningSequence(
    std::string parFile);

  // Stores rescale values in the VectorContainer "rescaleValues" for each image 
  // type of the specified scan sequence number "scan_sequence" (from 
  // scanning_sequences) for the PAR file "parFile".
  // Returns false if an error is encountered during reading, otherwise true is 
  // returned.
  bool GetRECRescaleValues(std::string parFile,
    std::vector< std::vector< float > > *rescaleValues, int scan_sequence);

  // Stores the diffusion gradient values in the VectorContainer "gradientValues" 
  // and the diffusion b values in the VectorContainer "bValues" for each gradient 
  // direction in the PAR file "parFile".  This function is applicable only for PAR
  // versions > 4.1
  // Returns false if an error is encountered during reading, otherwise true is 
  // returned.
  bool GetDiffusionGradientOrientationAndBValues(std::string parFile,
    std::vector< std::vector< float > > *gradientValues,
   std::vector< float > *bValues);

  // Returns a vector of ASL label types for the PAR file "parFile".
  std::vector< int > GetLabelTypesASL(std::string parFile);

  // Read a line number within the PAR file.
  std::string GetLineNumber(std::string file, int lineNum);

protected:
  vtkPhilipsPAR();
  ~vtkPhilipsPAR();

private:
  vtkPhilipsPAR(const vtkPhilipsPAR&); //purposely not implemented
  void operator=(const vtkPhilipsPAR&); //purposely not implemented

  int GetPARVersion(std::string parFile);

  std::string GetGeneralInfoString(std::string file, int lineNum);

  std::string FileName;

  std::vector<std::string> PARFileLines;

};

#endif                           /*_PhilipsPAR_h*/

---