/*
* 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
#ifndef __FREESTYLE_ADVANCED_STROKE_SHADERS_H__
#define __FREESTYLE_ADVANCED_STROKE_SHADERS_H__
/** \file
* \ingroup freestyle
* \brief Fredo's stroke shaders
*/
#include "BasicStrokeShaders.h"
namespace Freestyle {
/*! [ Thickness Shader ].
* Assigns thicknesses to the stroke vertices so that the stroke looks like made with a
* calligraphic tool. i.e. The stroke will be the thickest in a main direction, the thinnest in the
* direction perpendicular to this one, and an interpolation in between.
*/
class CalligraphicShader : public StrokeShader {
public:
/*! Builds the shader.
* \param iMinThickness:
* The minimum thickness in the direction perpendicular to the main direction.
* \param iMaxThickness:
* The maximum thickness in the main direction.
* \param iOrientation:
* The 2D vector giving the main direction.
* \param clamp:
* Tells ???
*/
CalligraphicShader(real iMinThickness,
real iMaxThickness,
const Vec2f &iOrientation,
bool clamp);
/*! Destructor. */
virtual ~CalligraphicShader()
{
}
/*! The shading method */
virtual int shade(Stroke &ioStroke) const;
protected:
real _maxThickness;
real _minThickness;
Vec2f _orientation;
bool _clamp;
};
/*! [ Geometry Shader ].
* Spatial Noise stroke shader.
* Moves the vertices to make the stroke more noisy.
* \see \htmlonly noise/noise.html \endhtmlonly
*/
class SpatialNoiseShader : public StrokeShader {
public:
/*! Builds the shader.
* \param iAmount:
* The amplitude of the noise.
* \param ixScale:
* The noise frequency
* \param nbOctave:
* The number of octaves
* \param smooth:
* If you want the noise to be smooth
* \param pureRandom:
* If you don't want any coherence
*/
SpatialNoiseShader(float iAmount, float ixScale, int nbOctave, bool smooth, bool pureRandom);
/*! Destructor. */
virtual ~SpatialNoiseShader()
{
}
/*! The shading method. */
virtual int shade(Stroke &ioStroke) const;
protected:
float _amount;
float _xScale;
int _nbOctave;
bool _smooth;
bool _pureRandom;
};
/*! [ Geometry Shader ].
* Smooths the stroke.
* (Moves the vertices to make the stroke smoother).
* Uses curvature flow to converge towards a curve of constant curvature. The diffusion method we
* use is anisotropic to prevent the diffusion across corners. \see \htmlonly smoothing/smoothing.html \endhtmlonly
*/
class SmoothingShader : public StrokeShader {
public:
/*! Builds the shader.
* \param iNbIteration:
* The number of iterations. (400)
* \param iFactorPoint:
* 0
* \param ifactorCurvature:
* 0
* \param iFactorCurvatureDifference:
* 0.2
* \param iAnisoPoint:
* 0
* \param iAnisNormal:
* 0
* \param iAnisoCurvature:
* 0
* \param icarricatureFactor:
* 1
*/
SmoothingShader(int iNbIteration,
real iFactorPoint,
real ifactorCurvature,
real iFactorCurvatureDifference,
real iAnisoPoint,
real iAnisoNormal,
real iAnisoCurvature,
real icarricatureFactor);
/*! Destructor. */
virtual ~SmoothingShader()
{
}
/*! The shading method. */
virtual int shade(Stroke &ioStroke) const;
protected:
int _nbIterations;
real _factorPoint;
real _factorCurvature;
real _factorCurvatureDifference;
real _anisoPoint;
real _anisoNormal;
real _anisoCurvature;
real _carricatureFactor;
};
class Smoother {
public:
Smoother(Stroke &ioStroke);
virtual ~Smoother();
void smooth(int nbIterations,
real iFactorPoint,
real ifactorCurvature,
real iFactorCurvatureDifference,
real iAnisoPoint,
real iAnisoNormal,
real iAnisoCurvature,
real icarricatureFactor);
void computeCurvature();
protected:
real _factorPoint;
real _factorCurvature;
real _factorCurvatureDifference;
real _anisoPoint;
real _anisoNormal;
real _anisoCurvature;
real _carricatureFactor;
void iteration();
void copyVertices();
Stroke *_stroke;
int _nbVertices;
Vec2r *_vertex;
Vec2r *_normal;
real *_curvature;
bool *_isFixedVertex;
bool _isClosedCurve;
bool _safeTest;
};
class Omitter : public Smoother {
public:
Omitter(Stroke &ioStroke);
virtual ~Omitter()
{
}
void omit(real sizeWindow, real thrVari, real thrFlat, real lFlat);
protected:
real *_u;
real _sizeWindow;
real _thresholdVariation;
real _thresholdFlat;
real _lengthFlat;
};
/*! Omission shader */
class OmissionShader : public StrokeShader {
public:
OmissionShader(real sizeWindow, real thrVari, real thrFlat, real lFlat);
virtual ~OmissionShader()
{
}
virtual int shade(Stroke &ioStroke) const;
protected:
real _sizeWindow;
real _thresholdVariation;
real _thresholdFlat;
real _lengthFlat;
};
} /* namespace Freestyle */
#endif // __FREESTYLE_ADVANCED_STROKE_SHADERS_H__