mitkMaterial.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 mitkMaterial_h
#define mitkMaterial_h
 
#include <MitkCoreExports.h>
#include <itkObject.h>
#include <itkRGBPixel.h>
#include <itkVectorContainer.h>
#include <mitkCommon.h>
#include <string>
#include <vtkSystemIncludes.h>
 
namespace mitk
{
  class MITKCORE_EXPORT Material : public itk::Object
  {
  public:
    mitkClassMacroItkParent(Material, itk::Object);
 
    typedef itk::RGBPixel<double> Color;
 
    enum InterpolationType
    {
      Flat,
      Gouraud,
      Phong
    };
 
    enum RepresentationType
    {
      Points,
      Wireframe,
      Surface
    };
 
    static Pointer New()
    {
      Pointer smartPtr = new Material();
      smartPtr->UnRegister();
      return smartPtr;
    }
 
    static Pointer New(Color color, double opacity = 1.0f)
    {
      Pointer smartPtr = new Material(color, opacity);
      smartPtr->UnRegister();
      return smartPtr;
    }
 
    static Pointer New(double red, double green, double blue, double opacity = 1.0f)
    {
      Pointer smartPtr = new Material(red, green, blue, opacity);
      smartPtr->UnRegister();
      return smartPtr;
    }
 
    static Pointer New(double red,
                       double green,
                       double blue,
                       double colorCoefficient,
                       double specularCoefficient,
                       double specularPower,
                       double opacity)
    {
      Pointer smartPtr = new Material(red, green, blue, colorCoefficient, specularCoefficient, specularPower, opacity);
      smartPtr->UnRegister();
      return smartPtr;
    }
 
    static Pointer New(
      Color color, double colorCoefficient, double specularCoefficient, double specularPower, double opacity)
    {
      Pointer smartPtr = new Material(color, colorCoefficient, specularCoefficient, specularPower, opacity);
      smartPtr->UnRegister();
      return smartPtr;
    }
 
    mitkNewMacro1Param(Material, const Material &);
 
    static Pointer New(
      const Material &property, double red, double green, double blue, double opacity = 1.0, std::string name = "")
    {
      Pointer smartPtr = new Material(property, red, green, blue, opacity, name);
      smartPtr->UnRegister();
      return smartPtr;
    }
 
    virtual bool Assignable(const Material &other) const;
 
    virtual Material &operator=(const Material &other);
 
    virtual void SetColor(Color color);
 
    virtual void SetColor(double red, double green, double blue);
 
    virtual void SetColorCoefficient(double coefficient);
 
    virtual void SetSpecularColor(Color color);
 
    virtual void SetSpecularColor(double red, double green, double blue);
 
    virtual void SetSpecularCoefficient(double specularCoefficient);
 
    virtual void SetSpecularPower(double specularPower);
 
    virtual void SetOpacity(double opacity);
 
    virtual void SetInterpolation(InterpolationType interpolation);
 
    virtual void SetRepresentation(RepresentationType representation);
 
    virtual void SetLineWidth(float lineWidth);
 
    virtual Color GetColor() const;
 
    virtual double GetColorCoefficient() const;
 
    virtual Color GetSpecularColor() const;
 
    virtual double GetSpecularCoefficient() const;
 
    virtual double GetSpecularPower() const;
 
    virtual double GetOpacity() const;
 
    virtual InterpolationType GetInterpolation() const;
 
    virtual RepresentationType GetRepresentation() const;
 
    virtual int GetVtkInterpolation() const;
 
    virtual int GetVtkRepresentation() const;
 
    virtual float GetLineWidth() const;
 
    virtual void Initialize(const Material &property);
 
    virtual bool operator==(const Material &property) const;
 
    void PrintSelf(std::ostream &os, itk::Indent) const override;
 
    itkSetMacro(Name, std::string);
 
    itkGetConstMacro(Name, std::string);
 
  protected:
    Material();
 
    Material(Color color, double opacity = 1.0f);
 
    Material(double red, double green, double blue, double opacity = 1.0f);
 
    Material(double red,
             double green,
             double blue,
             double colorCoefficient,
             double specularCoefficient,
             double specularPower,
             double opacity);
 
    Material(Color color, double colorCoefficient, double specularCoefficient, double specularPower, double opacity);
 
    Material(const Material &property);
 
    Material(
      const Material &property, double red, double green, double blue, double opacity = 1.0, std::string name = "");
 
    virtual void InitializeStandardValues();
 
    virtual void Update();
 
    std::string m_Name;
 
    Color m_Color;
 
    Color m_SpecularColor;
 
    double m_ColorCoefficient;
 
    double m_SpecularCoefficient;
 
    double m_SpecularPower;
 
    double m_Opacity;
 
    float m_LineWidth;
 
    InterpolationType m_Interpolation;
 
    RepresentationType m_Representation;
  };
 
  typedef itk::VectorContainer<unsigned int, Material::Pointer> MaterialVectorContainer;
}
 
#endif