vtkLightKit.h

Go to the documentation of this file.

/*=========================================================================
 
  Program:   Visualization Toolkit
  Module:    vtkLightKit.h
 
  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
  All rights reserved.
  See Copyright.txt or http://www.kitware.com/Copyright.htm 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 vtkLightKit_h
#define vtkLightKit_h
 
#include "vtkObject.h"
#include "vtkRenderingCoreModule.h" // For export macro
 
class vtkLight;
class vtkPiecewiseFunction;
class vtkRenderer;
 
class VTKRENDERINGCORE_EXPORT vtkLightKit : public vtkObject
{
public:
  static vtkLightKit* New();
  vtkTypeMacro(vtkLightKit, vtkObject);
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
  enum LightKitType
  {
    TKeyLight,
    TFillLight,
    TBackLight,
    THeadLight
  };
 
  enum LightKitSubType
  {
    Warmth,
    Intensity,
    Elevation,
    Azimuth,
    KFRatio,
    KBRatio,
    KHRatio
  };
 
 
  vtkSetMacro(KeyLightIntensity, double);
  vtkGetMacro(KeyLightIntensity, double);
 
 
  vtkSetClampMacro(KeyToFillRatio, double, 0.5, VTK_DOUBLE_MAX);
  vtkGetMacro(KeyToFillRatio, double);
 
 
  vtkSetClampMacro(KeyToHeadRatio, double, 0.5, VTK_DOUBLE_MAX);
  vtkGetMacro(KeyToHeadRatio, double);
 
 
  vtkSetClampMacro(KeyToBackRatio, double, 0.5, VTK_DOUBLE_MAX);
  vtkGetMacro(KeyToBackRatio, double);
 
 
  vtkSetMacro(KeyLightWarmth, double);
  vtkGetMacro(KeyLightWarmth, double);
 
  vtkSetMacro(FillLightWarmth, double);
  vtkGetMacro(FillLightWarmth, double);
 
  vtkSetMacro(HeadLightWarmth, double);
  vtkGetMacro(HeadLightWarmth, double);
 
  vtkSetMacro(BackLightWarmth, double);
  vtkGetMacro(BackLightWarmth, double);
 
 
  vtkGetVectorMacro(KeyLightColor, double, 3);
  vtkGetVectorMacro(FillLightColor, double, 3);
  vtkGetVectorMacro(HeadLightColor, double, 3);
  vtkGetVectorMacro(BackLightColor, double, 3);
 
 
  vtkBooleanMacro(MaintainLuminance, vtkTypeBool);
  vtkGetMacro(MaintainLuminance, vtkTypeBool);
  vtkSetMacro(MaintainLuminance, vtkTypeBool);
 
  void SetKeyLightAngle(double elevation, double azimuth);
  void SetKeyLightAngle(double angle[2]) { this->SetKeyLightAngle(angle[0], angle[1]); }
 
  void SetKeyLightElevation(double x) { this->SetKeyLightAngle(x, this->KeyLightAngle[1]); }
 
  void SetKeyLightAzimuth(double x) { this->SetKeyLightAngle(this->KeyLightAngle[0], x); }
 
  vtkGetVectorMacro(KeyLightAngle, double, 2);
  double GetKeyLightElevation()
  {
    double ang[2];
    this->GetKeyLightAngle(ang);
    return ang[0];
  }
 
  double GetKeyLightAzimuth()
  {
    double ang[2];
    this->GetKeyLightAngle(ang);
    return ang[1];
  }
 
  void SetFillLightAngle(double elevation, double azimuth);
  void SetFillLightAngle(double angle[2]) { this->SetFillLightAngle(angle[0], angle[1]); }
 
  void SetFillLightElevation(double x) { this->SetFillLightAngle(x, this->FillLightAngle[1]); }
 
  void SetFillLightAzimuth(double x) { this->SetFillLightAngle(this->FillLightAngle[0], x); }
 
  vtkGetVectorMacro(FillLightAngle, double, 2);
  double GetFillLightElevation()
  {
    double ang[2];
    this->GetFillLightAngle(ang);
    return ang[0];
  }
 
  double GetFillLightAzimuth()
  {
    double ang[2];
    this->GetFillLightAngle(ang);
    return ang[1];
  }
 
  void SetBackLightAngle(double elevation, double azimuth);
  void SetBackLightAngle(double angle[2]) { this->SetBackLightAngle(angle[0], angle[1]); }
 
  void SetBackLightElevation(double x) { this->SetBackLightAngle(x, this->BackLightAngle[1]); }
 
  void SetBackLightAzimuth(double x) { this->SetBackLightAngle(this->BackLightAngle[0], x); }
 
  vtkGetVectorMacro(BackLightAngle, double, 2);
  double GetBackLightElevation()
  {
    double ang[2];
    this->GetBackLightAngle(ang);
    return ang[0];
  }
 
  double GetBackLightAzimuth()
  {
    double ang[2];
    this->GetBackLightAngle(ang);
    return ang[1];
  }
 
 
  void AddLightsToRenderer(vtkRenderer* renderer);
  void RemoveLightsFromRenderer(vtkRenderer* renderer);
 
  void DeepCopy(vtkLightKit* kit);
 
  void Modified() override;
  void Update();
 
  static const char* GetStringFromType(int type);
 
  static const char* GetStringFromSubType(int type);
 
  static const char* GetShortStringFromSubType(int subtype);
 
  static LightKitSubType GetSubType(LightKitType type, int i);
 
protected:
  vtkLightKit();
  ~vtkLightKit() override;
 
  void WarmthToRGBI(double w, double rgb[3], double& i);
  void WarmthToRGB(double w, double rgb[3]);
  void InitializeWarmthFunctions();
  double WarmthToIntensity(double w);
 
  double KeyLightIntensity;
  double KeyToFillRatio;
  double KeyToHeadRatio;
  double KeyToBackRatio;
 
  vtkLight* KeyLight;
  double KeyLightWarmth;
  double KeyLightAngle[2];
  double KeyLightColor[3];
 
  vtkLight* FillLight;
  double FillLightWarmth;
  double FillLightAngle[2];
  double FillLightColor[3];
 
  double BackLightWarmth;
  double BackLightColor[3];
 
  vtkLight* BackLight0;
  vtkLight* BackLight1;
 
  double BackLightAngle[2];
 
  vtkLight* HeadLight;
  double HeadLightWarmth;
  double HeadLightColor[3];
 
  vtkTypeBool MaintainLuminance;
 
  vtkPiecewiseFunction* WarmthFunction[4]; // r, g, b, perceptual length
 
private:
  vtkLightKit(const vtkLightKit&) = delete;
  void operator=(const vtkLightKit&) = delete;
};
 
#endif