mitkLookupTable.h

Go to the documentation of this file.

/*============================================================================
 
The Medical Imaging Interaction Toolkit (MITK)
 
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
 
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
 
============================================================================*/
#ifndef mitkLookupTable_h
#define mitkLookupTable_h
 
#include <mitkCommon.h>
#include <MitkCoreExports.h>
 
#include <itkDataObject.h>
#include <itkObjectFactory.h>
 
#include <vtkLookupTable.h>
#include <vtkSmartPointer.h>
 
class vtkColorTransferFunction;
class vtkPiecewiseFunction;
 
namespace mitk
{
  class MITKCORE_EXPORT LookupTable : public itk::DataObject
  {
  public:
    typedef unsigned char RawLookupTableType;
 
    mitkClassMacroItkParent(LookupTable, itk::DataObject);
 
    itkFactorylessNewMacro(Self);
 
    itkCloneMacro(Self);
 
    virtual vtkSmartPointer<vtkLookupTable> GetVtkLookupTable() const;
 
    virtual RawLookupTableType *GetRawLookupTable() const;
 
    virtual void SetVtkLookupTable(vtkSmartPointer<vtkLookupTable> lut);
 
    virtual void ChangeOpacityForAll(float opacity);
 
    virtual void ChangeOpacity(int index, float opacity);
 
    virtual void GetColor(double value, double rgb[3]);
 
    static int GetMultiLabelColorCount();
 
    static void GetMultiLabelColor(int index, double rgb[3]);
 
    virtual void GetTableValue(int index, double rgba[4]);
 
    virtual void SetTableValue(int index, double rgba[4]);
 
    itkSetMacro(Window, float);
    itkSetMacro(Level, float);
    itkSetMacro(Opacity, float);
 
    virtual bool operator==(const mitk::LookupTable &LookupTable) const;
 
    virtual bool operator!=(const LookupTable &LookupTable) const;
 
    virtual LookupTable &operator=(const LookupTable &LookupTable);
 
    void UpdateOutputInformation() override;
 
    void SetRequestedRegionToLargestPossibleRegion() override;
 
    bool RequestedRegionIsOutsideOfTheBufferedRegion() override;
 
    bool VerifyRequestedRegion() override;
 
    void SetRequestedRegion(const itk::DataObject *data) override;
 
    LookupTable();
    ~LookupTable() override;
 
    vtkSmartPointer<vtkColorTransferFunction> CreateColorTransferFunction();
 
    vtkSmartPointer<vtkPiecewiseFunction> CreateOpacityTransferFunction();
 
    vtkSmartPointer<vtkPiecewiseFunction> CreateGradientTransferFunction();
 
    enum LookupTableType
    {
      GRAYSCALE,
      INVERSE_GRAYSCALE,
      HOT_IRON,
      JET,
      JET_TRANSPARENT,
      PLASMA,
            INFERNO,
            VIRIDIS,
      MAGMA,
      LEGACY_BINARY,
      LEGACY_RAINBOW_COLOR,
      MULTILABEL,
      PET_COLOR,
      PET_20,
      PET_BLACK_WHITE,
      TURBO
    };
 
    static std::vector<std::string> typenameList;
 
    virtual void SetType(const LookupTableType type);
 
    virtual void SetType(const std::string &typeName);
 
    virtual LookupTableType GetActiveType() const;
 
    virtual std::string GetActiveTypeAsString() const;
 
  protected:
    void PrintSelf(std::ostream &os, itk::Indent indent) const override;
 
    LookupTable(const Self &other);
 
    mitkCloneMacro(Self);
 
    virtual void BuildGrayScaleLookupTable();
    virtual void BuildLegacyBinaryLookupTable();
    virtual void BuildLegacyRainbowColorLookupTable();
    virtual void BuildInverseGrayScaleLookupTable();
    virtual void BuildHotIronLookupTable();
    virtual void BuildPlasmaLookupTable();
    virtual void BuildInfernoLookupTable();
    virtual void BuildViridisLookupTable();
    virtual void BuildMagmaLookupTable();
    virtual void BuildJetLookupTable(bool transparent = false);
    virtual void BuildPETColorLookupTable();
    virtual void BuildPET20LookupTable();
    virtual void BuildPETBWLookupTable();
    virtual void BuildMultiLabelLookupTable();
    virtual void BuildTurboLookupTable();
 
    vtkSmartPointer<vtkLookupTable> m_LookupTable;
 
    float m_Window;
    float m_Level;
    float m_Opacity;
 
    LookupTableType m_Type;
 
  };
} // namespace mitk
 
#endif