mitkMaterial.h

Go to the documentation of this file.

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

The Medical Imaging Interaction Toolkit (MITK)

Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.

This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.

See LICENSE.txt or http://www.mitk.org for details.

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

#ifndef _MITK_MATERIAL_H_
#define _MITK_MATERIAL_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);

    /* Sets the materials color in RGB space. The rgb components have to be
    * in the range [0..1]
    * @param color the new color of the material
    */
    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