h o m e

d o c u m e n t a t i o n

c l a s s h i e r a r c h y

---

BasicStrokeShaders.h

//
//  Filename         : BasicStrokeShaders.h
//  Author           : Stephane Grabli
//  Purpose          : Class gathering basic stroke shaders
//  Date of creation : 17/12/2002
//


//
//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
//   with this source distribution. 
//
//  This program is free software; you can redistribute it and/or
//  modify it under the terms of the GNU General Public License
//  as published by the Free Software Foundation; either version 2
//  of the License, or (at your option) any later version.
//
//  This program is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//  GNU General Public License for more details.
//
//  You should have received a copy of the GNU General Public License
//  along with this program; if not, write to the Free Software
//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
//

#ifndef  BASIC_STROKE_SHADERS_H
# define BASIC_STROKE_SHADERS_H

# include "Stroke.h"
# include "../geometry/Geom.h"
# include "../geometry/Bezier.h"
# include "StrokeShader.h"
# include <fstream>

using namespace std;
using namespace Geometry;

namespace StrokeShaders {

  //
  //  Thickness modifiers
  //

  class LIB_STROKE_EXPORT ConstantThicknessShader : public StrokeShader
  {
  public:
    ConstantThicknessShader(float thickness) : StrokeShader() {
      _thickness = thickness;
    }
    virtual ~ConstantThicknessShader() {}
    virtual string getName() const {
      return "ConstantThicknessShader";
    }
    virtual void shade(Stroke& stroke) const;

  private:
    float _thickness;
  };

  /* [ Thickness Shader ].
   *  Assigns an absolute constant external thickness to every
   *  vertices of the Stroke. The external thickness of a point
   *  is its thickness from the point to the strip border
   *  in the direction pointing outside the object the
   *  Stroke delimitates.
   */
  class LIB_STROKE_EXPORT ConstantExternThicknessShader : public StrokeShader
  {
  public:

    ConstantExternThicknessShader(float thickness) : StrokeShader() {
      _thickness = thickness;
    }

    virtual ~ConstantExternThicknessShader() {}

    virtual string getName() const {
      return "ConstantExternThicknessShader";
    }

    virtual void shade(Stroke& stroke) const;

  private:

    float _thickness;
  };

  class LIB_STROKE_EXPORT IncreasingThicknessShader : public StrokeShader
  {
  public:
    IncreasingThicknessShader(float iThicknessMin, float iThicknessMax)
      : StrokeShader()
    {
      _ThicknessMin = iThicknessMin;
      _ThicknessMax = iThicknessMax;
    }
    virtual ~IncreasingThicknessShader() {}
    virtual void shade(Stroke& stroke) const;

  private:

    float _ThicknessMin;
    float _ThicknessMax;
  };

  class LIB_STROKE_EXPORT ConstrainedIncreasingThicknessShader : public StrokeShader
  {
  private:
    float _ThicknessMin;
    float _ThicknessMax;
    float _ratio;
  public:
    ConstrainedIncreasingThicknessShader(float iThicknessMin, float iThicknessMax, float iRatio)
      : StrokeShader()
    {
      _ThicknessMin = iThicknessMin;
      _ThicknessMax = iThicknessMax;
      _ratio = iRatio;
    }
    virtual ~ConstrainedIncreasingThicknessShader() {}
    virtual void shade(Stroke& stroke) const;
  };

  /*  [ Thickness Shader ].
   *  Modifys the thickness in a relative way
   *  depending on its length.
   */
  class LIB_STROKE_EXPORT LengthDependingThicknessShader : public StrokeShader
  {
  private:
    float _minThickness;
    float _maxThickness;
    // We divide the strokes in 4 categories:
    // l > 300
    // 100 < l < 300
    // 50 < l < 100
    // l < 50
  public:
    LengthDependingThicknessShader(float iMinThickness, float iMaxThickness)
      : StrokeShader()
    {
      _minThickness = iMinThickness;
      _maxThickness = iMaxThickness;
    }
    virtual ~LengthDependingThicknessShader() {}

    virtual void shade(Stroke& stroke) const;
  };

  class LIB_STROKE_EXPORT ThicknessVariationPatternShader : public StrokeShader
  {
  public:

    ThicknessVariationPatternShader(const string pattern_name,
                                    float iMinThickness = 1.f,
                                    float iMaxThickness = 5.f,
                                    bool stretch = true);
    virtual ~ThicknessVariationPatternShader()
    {
      if(0 != _aThickness)
        {
          delete [] _aThickness;
          _aThickness = 0;
        }
    }
    virtual void shade(Stroke& stroke) const;

  private:

    float*      _aThickness; // array of thickness values, in % of the max (i.e comprised between 0 and 1)
    unsigned    _size;
    float       _minThickness;
    float       _maxThickness;
    bool        _stretch;
  };

  class LIB_STROKE_EXPORT ThicknessNoiseShader : public StrokeShader
  {
  private:
    float _amplitude;
    float _scale;
  public:
    ThicknessNoiseShader();
    ThicknessNoiseShader(float iAmplitude, float iPeriod);
    virtual void shade(Stroke& stroke) const;
  };


  //
  //  Color shaders
  //

  class LIB_STROKE_EXPORT ConstantColorShader : public StrokeShader
  {
  public:
    ConstantColorShader(float iR, float iG, float iB, float iAlpha=1.f)
      : StrokeShader()
    {
      _color[0] = iR;
      _color[1] = iG;
      _color[2] = iB;
      _color[3] = iAlpha;
    }

    virtual string getName() const {
      return "ConstantColorShader";
    }
    virtual void shade(Stroke& stroke) const;

  private:

    float _color[4];
  };

  class LIB_STROKE_EXPORT IncreasingColorShader : public StrokeShader
  {
  private:
    float _colorMin[4];
    float _colorMax[4];
  public:
    IncreasingColorShader(float iRm, float iGm, float iBm, float iAlpham, 
                                float iRM, float iGM, float iBM, float iAlphaM)
      : StrokeShader() 
    {
      _colorMin[0] = iRm;
      _colorMin[1] = iGm;
      _colorMin[2] = iBm;
      _colorMin[3] = iAlpham;

      _colorMax[0] = iRM;
      _colorMax[1] = iGM;
      _colorMax[2] = iBM;
      _colorMax[3] = iAlphaM;
    }
    virtual void shade(Stroke& stroke) const;
  };

  class LIB_STROKE_EXPORT ColorVariationPatternShader : public StrokeShader
  {
  public:
    ColorVariationPatternShader(const string pattern_name, bool stretch = true);
    virtual ~ColorVariationPatternShader()
    {
      if(0 != _aVariation)
        {
          delete [] _aVariation;
          _aVariation = 0;
        }
    }
    virtual void shade(Stroke& stroke) const;

  private:

    float*      _aVariation; // array of coef values, in % of the max (i.e comprised between 0 and 1)
    unsigned    _size;
    bool        _stretch;
  };

  /* [ Color Shader ].
   *  Assigns a color to the stroke depending
   *  on the material of the shape to which ot belongs
   *  to. (Disney shader)
   */
  class LIB_STROKE_EXPORT MaterialColorShader : public StrokeShader
  {
  private:
    float _coefficient;
  public:
    MaterialColorShader(float coeff=1.f)
      : StrokeShader()
    {_coefficient=coeff;}

    virtual void shade(Stroke& stroke) const;
  };

  class LIB_STROKE_EXPORT CalligraphicColorShader : public StrokeShader
  {
  private:
    int _textureId;
    Vec2d _orientation;
  public:
    CalligraphicColorShader(
                            const Vec2d &iOrientation)
      : StrokeShader()
    { 
      _orientation=iOrientation;
      _orientation.normalize();
    } 
    virtual void shade(Stroke& stroke) const;

  };

  class LIB_STROKE_EXPORT ColorNoiseShader : public StrokeShader
  {
  private:
    float _amplitude; 
    float _scale;     

  public:
    ColorNoiseShader();
    ColorNoiseShader(float iAmplitude, float iPeriod);
    virtual void shade(Stroke& stroke) const;
  };

  //
  //  Texture Shaders
  //

  class LIB_STROKE_EXPORT TextureAssignerShader : public StrokeShader // FIXME
  {
  private:
    int _textureId;
  public:
    TextureAssignerShader(int id)
      : StrokeShader()
    {
      _textureId = id;
    }
    virtual void shade(Stroke& stroke) const;
  
  };
  class LIB_STROKE_EXPORT StrokeTextureShader : public StrokeShader
  {
  private:
    string _texturePath;
    Stroke::MediumType _mediumType;
    bool _tips; // 0 or 1
    
  public:
    StrokeTextureShader(const string textureFile, Stroke::MediumType mediumType = Stroke::OPAQUE_MEDIUM, bool iTips = false)
      : StrokeShader()
    {
      _texturePath = textureFile;
      _mediumType = mediumType;
      _tips = iTips;
    }
    virtual void shade(Stroke& stroke) const;
  
  };


  //
  //  Geometry Shaders
  //

  class LIB_STROKE_EXPORT BackboneStretcherShader : public StrokeShader
  {
  private:
    float _amount; 
  public:
    BackboneStretcherShader(float iAmount=2.f)
      : StrokeShader()
    {
      _amount = iAmount;
    }
    virtual void shade(Stroke& stroke) const;
  };

  class LIB_STROKE_EXPORT SamplingShader: public StrokeShader
  {
  private:
    float _sampling;
  public:
    SamplingShader(float  sampling)
      : StrokeShader()
    {
      _sampling = sampling;
    }
    virtual void shade(Stroke& stroke) const;
  };


  class LIB_STROKE_EXPORT ExternalContourStretcherShader : public StrokeShader
  {
  private:
    float _amount; 
  public:
    ExternalContourStretcherShader(float iAmount=2.f)
      : StrokeShader()
    {
      _amount = iAmount;
    }

    virtual void shade(Stroke& stroke) const;
  };

  // B-Spline stroke shader
  class LIB_STROKE_EXPORT BSplineShader: public StrokeShader
  { 
  public:
    BSplineShader()
      : StrokeShader()
    {}

    virtual void shade(Stroke& stroke) const;
  };


  // Bezier curve stroke shader
  class LIB_STROKE_EXPORT BezierCurveShader : public StrokeShader
  { 
  private:
    float _error;
  public:
    BezierCurveShader(float error = 4.0)
      : StrokeShader()
    {_error=error;}

    virtual void shade(Stroke& stroke) const;
  };

  /* Shader to inflate the curves. It keeps the extreme
   *  points positions and moves the other ones along 
   *  the 2D normal. The displacement value is proportional
   *  to the 2d curvature at the considered point (the higher 
   *  the curvature, the smaller the displacement) and to a value 
   *  specified by the user.
   */
  class LIB_STROKE_EXPORT InflateShader : public StrokeShader
  {
  private:
    float _amount; 
    float _curvatureThreshold;
  public:
    InflateShader(float iAmount,float iThreshold)
      : StrokeShader()
    {
      _amount = iAmount;
      _curvatureThreshold = iThreshold;
    }
    virtual void shade(Stroke& stroke) const;
  };

  class LIB_STROKE_EXPORT PolygonalizationShader : public StrokeShader
  {
  private:
    float _error;
  public:
    PolygonalizationShader(float iError) : StrokeShader() 
    {_error = iError;}
    virtual void shade(Stroke& stroke) const;
  };


  class LIB_STROKE_EXPORT GuidingLinesShader : public StrokeShader
  {
  private:
    float _offset;
  public:
    GuidingLinesShader(float iOffset) : StrokeShader()
    {_offset = iOffset;}
    virtual void shade(Stroke& stroke) const;
  };

  class LIB_STROKE_EXPORT TipRemoverShader : public StrokeShader 
  {
  public:
    TipRemoverShader (real tipLength);
    virtual ~TipRemoverShader () {}
    virtual void shade(Stroke &stroke) const;

  protected:

    real _tipLength; 
  };

  class LIB_STROKE_EXPORT streamShader : public StrokeShader
  {
  public:
    virtual ~streamShader() {}
    virtual string getName() const {
      return "streamShader";
    }
    virtual void shade(Stroke& stroke) const;
  };

  class LIB_STROKE_EXPORT fstreamShader : public StrokeShader
  {
  protected:
    mutable ofstream _stream;
  public:
    fstreamShader(const char *iFileName) : StrokeShader(){
      _stream .open(iFileName);
      if(!_stream.is_open()){
        cout << "couldn't open file " << iFileName << endl;
      }
    }
    virtual ~fstreamShader() {_stream.close();}
    virtual string getName() const {
      return "fstreamShader";
    }
    virtual void shade(Stroke& stroke) const;
  };
} // end of namespace StrokeShaders

#endif // BASIC_STROKE_SHADERS_H

---

Last modified 3 Mar 2008

© Stephane Grabli