itkAnalyzeObjectEntry.h

Go to the documentation of this file.

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

Program:   Insight Segmentation & Registration Toolkit
Module:    $RCSfile: itkIOCommon.cxx,v $
Language:  C++
Date:      $Date: 2007/08/22 14:18:08 $
Version:   $Revision: 1.0 $

Copyright (c) Insight Software Consortium. All rights reserved.
See ITKCopyright.txt or http://www.itk.org/HTML/Copyright.htm for details.

This software is distributed WITHOUT ANY WARRANTY; without even
the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
PURPOSE.  See the above copyright notices for more information.

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

#ifndef itkAnalyzeObjectEntry_h
#define itkAnalyzeObjectEntry_h

#include <string>
#include <stdio.h>
#include <iostream>
#include <fstream>

#include "itkObjectFactory.h"
#include "itkImage.h"
#include "itkByteSwapper.h"
#include "itksys/SystemTools.hxx"
#include "itkImageIOBase.h"

namespace itk
{

class AnalyzeObjectEntry : public Object
{
public:

  typedef AnalyzeObjectEntry       Self;
  typedef Object                   Superclass;
  typedef SmartPointer<Self>       Pointer;
  typedef SmartPointer<const Self> ConstPointer;
  typedef itk::RGBPixel<int>       intRGBPixel;
  typedef itk::Index<3>            Index;

  itkNewMacro(Self);

  itkTypeMacro(AnalyzeObjectEntry, Object);

  void Copy( AnalyzeObjectEntry::Pointer rhs );

  virtual std::string GetName( void ) const
  {
    itkDebugMacro("returning " << "Name of " << this->m_Name );
    return std::string(this->m_Name);
  }

  virtual void SetName(const std::string _arg)
  {
    char temp[32];

    strncpy(temp, _arg.c_str(), 31);
    temp[31] = '\0';
    itkDebugMacro("setting " << "Name" << " to " << temp);
    if( strcmp(this->m_Name, temp) != 0 )
      {
      strncpy(this->m_Name, temp, 32);
      this->Modified();
      }
  }

  itkGetConstMacro(DisplayFlag, int);
  itkSetMacro(DisplayFlag, int);

  itkGetConstMacro(CopyFlag, unsigned char);
  itkSetMacro(CopyFlag, unsigned char);

  itkGetConstMacro(MirrorFlag, unsigned char);
  itkSetMacro(MirrorFlag, unsigned char);

  itkGetConstMacro(StatusFlag, unsigned char);
  itkSetMacro(StatusFlag, unsigned char);

  itkGetConstMacro(NeighborsUsedFlag, unsigned char);
  itkSetMacro(NeighborsUsedFlag, unsigned char);

  itkGetConstMacro(Shades, int);
  itkSetMacro(Shades, int);

  itkGetConstMacro(StartRed, int);
  itkSetMacro(StartRed, int);

  itkGetConstMacro(StartGreen, int);
  itkSetMacro(StartGreen, int);

  itkGetConstMacro(StartBlue, int);
  itkSetMacro(StartBlue, int);

  itkGetConstMacro(EndRed, int);
  itkSetMacro(EndRed, int);

  itkGetConstMacro(EndGreen, int);
  itkSetMacro(EndGreen, int);

  itkGetConstMacro(EndBlue, int);
  itkSetMacro(EndBlue, int);

  itkGetConstMacro(XRotation, int);
  itkSetMacro(XRotation, int);

  itkGetConstMacro(XRotationIncrement, int);
  itkSetMacro(XRotationIncrement, int);

  itkGetConstMacro(YRotation, int);
  itkSetMacro(YRotation, int);

  itkGetConstMacro(YRotationIncrement, int);
  itkSetMacro(YRotationIncrement, int);

  itkGetConstMacro(ZRotation, int);
  itkSetMacro(ZRotation, int);

  itkGetConstMacro(ZRotationIncrement, int);
  itkSetMacro(ZRotationIncrement, int);

  itkGetConstMacro(XTranslation, int);
  itkSetMacro(XTranslation, int);

  itkGetConstMacro(XTranslationIncrement, int);
  itkSetMacro(XTranslationIncrement, int);

  itkGetConstMacro(YTranslation, int);
  itkSetMacro(YTranslation, int);

  itkGetConstMacro(YTranslationIncrement, int);
  itkSetMacro(YTranslationIncrement, int);

  itkGetConstMacro(ZTranslation, int);
  itkSetMacro(ZTranslation, int);

  itkGetConstMacro(ZTranslationIncrement, int);
  itkSetMacro(ZTranslationIncrement, int);

  itkGetConstMacro(XCenter, int);
  itkSetMacro(XCenter, int);

  itkGetConstMacro(YCenter, int);
  itkSetMacro(YCenter, int);

  itkGetConstMacro(ZCenter, int);
  itkSetMacro(ZCenter, int);

  itkGetConstMacro(MinimumXValue, short int);
  itkSetMacro(MinimumXValue, int);

  itkGetConstMacro(MinimumYValue, short int);
  itkSetMacro(MinimumYValue, int);

  itkGetConstMacro(MinimumZValue, short int);
  itkSetMacro(MinimumZValue, int);

  itkGetConstMacro(MaximumXValue, short int);
  itkSetMacro(MaximumXValue, int);

  itkGetConstMacro(MaximumYValue, short int);
  itkSetMacro(MaximumYValue, int);

  itkGetConstMacro(MaximumZValue, short int);
  itkSetMacro(MaximumZValue, int);

  itkGetConstMacro(Opacity, float);
  itkSetMacro(Opacity, float);

  itkGetConstMacro(OpacityThickness, int);
  itkSetMacro(OpacityThickness, int);

  itkGetConstMacro(BlendFactor, float);
  itkSetMacro(BlendFactor, float);

  // TODO: Need to use these at some point or maybe just delete them
#if 0

  itkSetMacro( StartColor, intRGBPixel);
  itkGetConstMacro(StartColor, intRGBPixel);

  itkSetMacro(EndColor, intRGBPixel);
  itkGetConstMacro(EndColor, intRGBPixel);

  itkSetMacro(Rotation, Index);
  itkGetConstMacro(Rotation, Index);

  itkSetMacro(Translation, Index);
  itkGetConstMacro(Translation, Index);

  itkSetMacro(Center, Index);
  itkGetConstMacro(Center, Index);

  itkSetMacro(RotationIncrement, Index);
  itkGetConstMacro(RotationIncrement, Index);

  itkSetMacro(TranslationIncrement, Index);
  itkGetConstMacro(TranslationIncrement, Index);

  itkSetMacro(MinimumCoordinateValue, Index);
  itkGetConstMacro(MinimumCoordinateValue, Index);

  itkSetMacro(MaximumCoordinateValue, Index);
  itkGetConstMacro(MaximumCoordinateValue, Index);
#endif


  void Print(std::ostream & myfile);

  void ReadFromFilePointer(std::ifstream & inputFileStream, const bool NeedByteSwap, const bool /* NeedBlendFactor */);

  void SwapObjectEndedness();

  void Write(std::ofstream & outputFileStream);
protected:

  AnalyzeObjectEntry( void );

  virtual ~AnalyzeObjectEntry( void );

  void PrintSelf(std::ostream& os, Indent indent) const ITK_OVERRIDE;

private:
  template <typename TValue>
  void ReadBytes(std::ifstream & inputFileStream,
                 TValue * dest,
                 const int Replications,
                 const bool NeedByteSwap);

  char          m_Name[33];              /*bytes   0-31*/
  int           m_DisplayFlag;           /*bytes  32-35*/
  unsigned char m_CopyFlag;              /*bytes  36-36*/
  unsigned char m_MirrorFlag;            /*bytes  37-37*/
  unsigned char m_StatusFlag;            /*bytes  38-38*/
  unsigned char m_NeighborsUsedFlag;     /*bytes  39-39*/
  int           m_Shades;                /*bytes  40-43*/
  int           m_StartRed;              /*bytes  44-47*/
  int           m_StartGreen;            /*bytes  48-51*/
  int           m_StartBlue;             /*bytes  52-55*/
  int           m_EndRed;                /*bytes  53-58*/
  int           m_EndGreen;              /*bytes  59-62*/
  int           m_EndBlue;               /*bytes  63-66*/
  int           m_XRotation;             /*bytes  67-70*/
  int           m_YRotation;             /*bytes  71-74*/
  int           m_ZRotation;             /*bytes  75-78*/
  int           m_XTranslation;          /*bytes  79-82*/
  int           m_YTranslation;          /*bytes  83-86*/
  int           m_ZTranslation;          /*bytes  87-90*/
  int           m_XCenter;               /*bytes  91-94*/
  int           m_YCenter;               /*bytes  95-98*/
  int           m_ZCenter;               /*bytes  99-102*/
  int           m_XRotationIncrement;    /*bytes  103-106*/
  int           m_YRotationIncrement;    /*bytes  107-110*/
  int           m_ZRotationIncrement;    /*bytes  111-114*/
  int           m_XTranslationIncrement; /*bytes  115-118*/
  int           m_YTranslationIncrement; /*bytes  119-121*/
  int           m_ZTranslationIncrement; /*bytes  122-125*/
  short int     m_MinimumXValue;         /*bytes  126-127*/
  short int     m_MinimumYValue;         /*bytes  128-129*/
  short int     m_MinimumZValue;         /*bytes  130-131*/
  short int     m_MaximumXValue;         /*bytes  132-133*/
  short int     m_MaximumYValue;         /*bytes  134-135*/
  short int     m_MaximumZValue;         /*bytes  136-137*/
  float         m_Opacity;               /*bytes  138-141*/
  int           m_OpacityThickness;      /*bytes  142-145*/
  float         m_BlendFactor;           /*bytes  146-149*/

  // TODO: Need to use these at some point or maybe just delete them
#if 0
  // Three seperate Start Colors (Red, Green, Blue) have been put together to use the set macro.
  intRGBPixel m_StartColor;
  // Three seperate End Colors (Red, Green, Blue) have been put together to use the set macro.
  intRGBPixel m_EndColor;
  // Three seperate Rotations (x, y, z) have been put together to use the set macro.
  Index m_Rotation;
  // Three seperate Translations (x, y, z) have been put together to use the set macro.
  Index m_Translation;
  // Three seperate Centers (x, y, z) have been put together to use the set macro.
  Index m_Center;
  // Three seperate Rotation Increments (x, y, z) have been put together to use the set macro.
  Index m_RotationIncrement;
  // Three seperate Translation Increments (x, y, z) have been put together to use the set macro.
  Index m_TranslationIncrement;
  // Three seperate Minimum Coordinate Values (x, y, z) have been put together to use the set macro.
  Index m_MinimumCoordinateValue;
  // Three seperate Maximum Coordiante Values (x, y, z) have been put together to use the set macro.
  Index m_MaximumCoordinateValue;
#endif
};
}
#endif                           // __OBJECTENTR_H__