mitkSurfaceProperty.h

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

  Program:   3DMed
  Date:      $Date: 2014-02-25 18:30:00 +0800 $
  Version:   $Version: 4.6.0 $
  Copyright: MIPG, Institute of Automation, Chinese Academy of Sciences

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



#ifndef __mitkSurfaceProperty_h
#define __mitkSurfaceProperty_h

#include "mitkObject.h"
#include "mitkVisualizationIncludes.h"

#define mitkSetColorMacro(name, type) \
void Set##name(type red, type green, type blue, type alpha = 1.0f) \
{ \
    m_##name[0] = red; \
    m_##name[1] = green; \
    m_##name[2] = blue; \
    m_##name[3] = alpha; \
    m_Modified = true; \
} \
void Set##name(type const color[4]) \
{ this->Set##name(color[0], color[1], color[2], color[3]); }

#define mitkGetColorMacro(name, type) \
type const* Get##name() const { return this->m_##name; } \
void Get##name(type &red, type &green, type &blue, type &alpha) const \
{ \
    red   = m_##name[0]; \
    green = m_##name[1]; \
    blue  = m_##name[2]; \
    alpha = m_##name[3]; \
} \
void Get##name(type color[4]) const \
{ this->Get##name(color[0], color[1], color[2], color[3]); }


const int MITK_MESH_POINTS    = 0;
const int MITK_MESH_WIREFRAME = 1;
const int MITK_MESH_SURFACE   = 2;

const int MITK_SURFACE_FLAT    = 0;
const int MITK_SURFACE_GOURAUD = 1;
const int MITK_SURFACE_PHONG   = 2;

class MITK_VISUALIZATION_API mitkSurfaceProperty : public mitkObject
{
public:
    MITK_TYPE(mitkSurfaceProperty, mitkObject)

    virtual void PrintSelf(ostream &os);

    mitkSurfaceProperty();

    bool IsModified() const { return m_Modified; }

    void SetUnmodified() { m_Modified = false; }

    void SetInterpolationType(int intpType) { m_InterpolationType = intpType; m_Modified = true; }

    int  GetInterpolationType() const { return m_InterpolationType; }

    void SetInterpolationTypeToFlat() { this->SetInterpolationType(MITK_SURFACE_FLAT); }

    void SetInterpolationTypeToGouraud() { this->SetInterpolationType(MITK_SURFACE_GOURAUD); }

    void SetInterpolationTypeToPhong() { this->SetInterpolationType(MITK_SURFACE_PHONG); }
 
    inline const char* GetInterpolationTypeAsString() const;

    void SetRepresentationType(int repType) { m_RepresentationType = repType; m_Modified = true; }

    int  GetRepresentationType() const { return m_RepresentationType; }

    void SetRepresentationTypeToPoints() { this->SetRepresentationType(MITK_MESH_POINTS); }

    void SetRepresentationTypeToWireframe() { this->SetRepresentationType(MITK_MESH_WIREFRAME); }

    void SetRepresentationTypeToSurface() { this->SetRepresentationType(MITK_MESH_SURFACE); }

    inline const char* GetRepresentationTypeAsString() const;

    void SetAmbient(float value) { m_Ambient = value; m_Modified = true; }

    float GetAmbient() const { return m_Ambient; }

    void SetDiffuse(float value) { m_Diffuse = value; m_Modified = true; }

    float GetDiffuse() const { return m_Diffuse; }

    void SetSpecular(float value) { m_Specular = value; m_Modified = true; }

    float GetSpecular() const { return m_Specular; }
    
    void SetSpecularPower(float value) { m_SpecularPower = value; m_Modified = true; }

    float GetSpecularPower() const { return m_SpecularPower; }

    void SetOpacity(float value) { m_Opacity = m_DiffuseColor[3] = value; m_Modified = true; }

    float GetOpacity() const { return m_DiffuseColor[3]; }

    void SetLineWidth(float value) { m_LineWidth = value; m_Modified = true; }

    float GetLineWidth() const { return m_LineWidth; }

    void SetPointSize(float value) { m_PointSize = value; m_Modified = true; }

    float GetPointSize() const { return m_PointSize; }

    void SetLineStipplePattern(unsigned short value) { m_LineStipplePattern = value; m_Modified = true; }

    unsigned short GetLineStipplePattern() const { return m_LineStipplePattern; }

    void SetLineStippleRepeatFactor(int value) { m_LineStippleRepeatFactor = value; m_Modified = true; }

    int GetLineStippleRepeatFactor() const { return m_LineStippleRepeatFactor; }

    void SetColor(float red, float green, float blue, float alpha = 1.0f);

    void SetColor(float color[4]) { this->SetColor(color[0],color[1],color[2],color[4]); }

    float* GetColor();

    void GetColor(float color[4]);

    mitkSetColorMacro(AmbientColor,float);

    mitkGetColorMacro(AmbientColor,float);

    mitkSetColorMacro(DiffuseColor,float);

    mitkGetColorMacro(DiffuseColor,float);

    mitkSetColorMacro(SpecularColor,float);

    mitkGetColorMacro(SpecularColor,float);

    mitkSetColorMacro(EmissionColor,float);

    mitkGetColorMacro(EmissionColor,float);

    mitkSetColorMacro(EdgeColor,float);

    mitkGetColorMacro(EdgeColor,float);
    
protected:
    virtual ~mitkSurfaceProperty();

    float m_Color[4];
    float m_AmbientColor[4];
    float m_DiffuseColor[4];
    float m_SpecularColor[4];
    float m_EmissionColor[4];
    float m_EdgeColor[4];
    float m_Ambient;
    float m_Diffuse;
    float m_Specular;
    float m_Emission;
    float m_SpecularPower;
    float m_Opacity;
    float m_PointSize;
    float m_LineWidth;

    int m_RepresentationType;
    int m_InterpolationType;
    int m_LineStippleRepeatFactor;
    unsigned short m_LineStipplePattern;
    bool m_Modified;
    
private:
    mitkSurfaceProperty(const mitkSurfaceProperty&);
    void operator = (const mitkSurfaceProperty&);
};

inline const char* mitkSurfaceProperty::GetInterpolationTypeAsString() const
{
    switch (this->m_InterpolationType)
    {
    case MITK_SURFACE_FLAT:
        return "Flat";
        
    case MITK_SURFACE_GOURAUD:
        return "Gouraud";

    case MITK_SURFACE_PHONG:
        return "Phong";

    default:
        return "Unknown";
    }
}

inline const char* mitkSurfaceProperty::GetRepresentationTypeAsString() const
{
    switch (this->m_RepresentationType)
    {
    case MITK_MESH_POINTS:
        return "Points";

    case MITK_MESH_WIREFRAME:
        return "Wireframe";

    case MITK_MESH_SURFACE:
        return "Surface";

    default:
        return "Unknown";
    }
}

 
//#define DEFINED_mitkSurfaceProperty



#endif

---