gdcmImageHelper.h

Go to the documentation of this file.

/*=========================================================================
 
  Program: GDCM (Grassroots DICOM). A DICOM library
 
  Copyright (c) 2006-2011 Mathieu Malaterre
  All rights reserved.
  See Copyright.txt or http://gdcm.sourceforge.net/Copyright.html 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 notice for more information.
 
=========================================================================*/
#ifndef GDCMIMAGEHELPER_H
#define GDCMIMAGEHELPER_H
 
#include "gdcmTypes.h"
#include "gdcmTag.h"
#include <vector>
#include "gdcmPixelFormat.h"
#include "gdcmPhotometricInterpretation.h"
#include "gdcmSmartPointer.h"
#include "gdcmLookupTable.h"
 
namespace gdcm
{
 
class MediaStorage;
class DataSet;
class File;
class Image;
class Pixmap;
class ByteValue;
 
// minimal struct:
struct RealWorldValueMappingContent {
  double RealWorldValueIntercept;
  double RealWorldValueSlope;
  // http://dicom.nema.org/MEDICAL/DICOM/2014c/output/chtml/part16/sect_CID_7181.html
  std::string CodeValue;
  std::string CodeMeaning;
};
 
class GDCM_EXPORT ImageHelper
{
public:
  static void SetForceRescaleInterceptSlope(bool);
  static bool GetForceRescaleInterceptSlope();
 
  static void SetPMSRescaleInterceptSlope(bool);
  static bool GetPMSRescaleInterceptSlope();
 
  static void SetForcePixelSpacing(bool);
  static bool GetForcePixelSpacing();
 
  static void SetSecondaryCaptureImagePlaneModule(bool);
  static bool GetSecondaryCaptureImagePlaneModule();
 
  static std::vector<unsigned int> GetDimensionsValue(const File& f);
  static void SetDimensionsValue(File& f, const Pixmap & img);
 
  static PixelFormat GetPixelFormatValue(const File& f);
 
  static std::vector<double> GetRescaleInterceptSlopeValue(File const & f);
  static void SetRescaleInterceptSlopeValue(File & f, const Image & img);
 
  // read only for now
  static bool GetRealWorldValueMappingContent(File const & f, RealWorldValueMappingContent & rwvmc);
 
  static std::vector<double> GetOriginValue(File const & f);
  static void SetOriginValue(DataSet & ds, const Image & img);
 
  static std::vector<double> GetDirectionCosinesValue(File const & f);
  // FIXME: There is a major issue for image with multiple IOP (eg. Enhanced * Image Storage).
  static void SetDirectionCosinesValue(DataSet & ds, const std::vector<double> & dircos);
 
  static std::vector<double> GetSpacingValue(File const & f);
  static void SetSpacingValue(DataSet & ds, const std::vector<double> & spacing);
 
  static bool ComputeSpacingFromImagePositionPatient(const std::vector<double> &imageposition, std::vector<double> & spacing);
 
  static bool GetDirectionCosinesFromDataSet(DataSet const & ds, std::vector<double> & dircos);
 
  //functions to get more information from a file
  //useful for the stream image reader, which fills in necessary image information
  //distinctly from the reader-style data input
  static PhotometricInterpretation GetPhotometricInterpretationValue(File const& f);
  //returns the configuration of colors in a plane, either RGB RGB RGB or RRR GGG BBB
  static unsigned int GetPlanarConfigurationValue(const File& f);
 
  static SmartPointer<LookupTable> GetLUT(File const& f);
 
  // Moved from PixampReader to here. Generally used for photometric interpretation.
  static const ByteValue* GetPointerFromElement(Tag const &tag, File const& f);
 
  static MediaStorage ComputeMediaStorageFromModality(const char *modality,
    unsigned int dimension = 2, PixelFormat const & pf = PixelFormat(),
    PhotometricInterpretation const & pi = PhotometricInterpretation(),
    double rescaleintercept = 0, double rescaleslope = 1 );
 
protected:
  static Tag GetSpacingTagFromMediaStorage(MediaStorage const &ms);
  static Tag GetZSpacingTagFromMediaStorage(MediaStorage const &ms);
 
private:
  static bool ForceRescaleInterceptSlope;
  static bool PMSRescaleInterceptSlope;
  static bool ForcePixelSpacing;
  static bool SecondaryCaptureImagePlaneModule;
};
 
} // end namespace gdcm
 
#endif // GDCMIMAGEHELPER_H