//-----------------------------------------------------------------------------

//  tstrokeoutline.h:

//-----------------------------------------------------------------------------

#ifndef T_STROKE_OUTLINE_H

#define T_STROKE_OUTLINE_H

#include "tgeometry.h"

#undef DVAPI

#undef DVVAR

#ifdef TVECTORIMAGE_EXPORTS

#define DVAPI DV_EXPORT_API

#define DVVAR DV_EXPORT_VAR

#else

#define DVAPI DV_IMPORT_API

#define DVVAR DV_IMPORT_VAR

#endif

#ifdef WIN32

#pragma warning(disable : 4251)

#endif

//forward declaration

class TStroke;

class TRegion;

class TRegionOutline;

//-----------------------------------------------------------------------------

/*!

  FIXME

 */

struct TOutlinePoint {

	/*!

  VEDERE COMMENTI DI TStrokeOutline

  */

	double x, y; //  coordinate geometriche del punto sull'outline per il valore 't' del parametro

	double u, v; //  coordinate di texture del punto (v = "ascissa curvilinea", u = "parametro di ampiezza")

	//TPointD tangent;  //  vettore tangente alla centerline (nel punto che ha lo stesso parametro 't' (approssimazione...))

	//TPointD normal; //  vettore normale alla centerline (nel punto che ha lo stesso parametro 't' (approssimazione...))

	int stepCount; //  contatore incrementale per il campionamento di outline procedurali

	TOutlinePoint(double x_,

				  double y_,

				  //TPointD tangent_ = TPointD(),

				  //TPointD normal_ = TPointD(),

				  int stepCount_, // = 0,

				  double u_,	  // = 0,

				  double v_)	  // = 0)

		: x(x_),

		  y(y_),

		  u(u_),

		  v(v_),

		  //tangent(tangent_),

		  //normal(normal_),

		  stepCount(stepCount_)

	{

	}

	TOutlinePoint(const TPointD &p,

				  //const TPointD &tangent_ = TPointD(),

				  //const TPointD &normal = TPointD(),

				  int stepCount_,   // = 0,

				  const TPointD &t) // = TPointD())

		: x(p.x),

		  y(p.y),

		  u(t.x),

		  v(t.y),

		  //tangent(tangent_),

		  //normal(normal),

		  stepCount(stepCount_)

	{

	}

	TOutlinePoint(const TPointD &p, int stepCount_)

		: x(p.x),

		  y(p.y),

		  u(0),

		  v(0),

		  //tangent(tangent_),

		  //normal(normal),

		  stepCount(stepCount_)

	{

	}

	TOutlinePoint(const TPointD &p)

		: x(p.x),

		  y(p.y),

		  u(0),

		  v(0),

		  stepCount(0)

	{

	}

};

//-----------------------------------------------------------------------------

inline TPointD convert(const TOutlinePoint &p)

{

	return TPointD(p.x, p.y);

}

//-----------------------------------------------------------------------------

/*!

  FIXME

 */

class DVAPI TStrokeOutline

{

	/*!

  gli elementi (TOutlinePoint) di m_outline rappresentano punti situati alternativamente 

  sulle facce pari/dispari dell'outline (pari a destra/dispari a sinistra nel verso di 

  disegno della centerline). Il calcolo delle coordinate geometriche TPointD(x, y)

  di tali punti e' effettuato utilizzando la rappresentazione parametrica (di parametro 't' 

  in [0, 1]) della centerline e delle facce pari/dispari dell'outline: i punti 

  p(2k) = (TPointD)m_outline[2k], p(2k + 1) = (TPointD)m_outline[2k + 1] (che si ottengono 

  per lo stesso valore di 't' da 2 DIVERSE equazioni per le 2 facce pari/dispari dell'outline) 

  sono totalmente scorrelati. In particolare 0.5*(p(2k) + p(2k + 1)) non coincide con il punto 

  della centerline che si ottiene per lo stesso valore di 't' (stessa cosa dicasi per 

  tangenti/normali sulla centerline rispetto alla media di quelle sull'outline): l'ottima 

  approssimazione sperimentale induce pero' a considerarli praticamente uguali nelle stroke 

  procedurali (stessa cosa dicasi per tangenti/normali). Si ottengono cosi' le seguenti:

  m_outline[2k].tangent == m_outline[2k + 1].tangent

  m_outline[2k].normal == m_outline[2k + 1].normal

  m_outline[2k].stepCount == m_outline[2k + 1].stepCount

  I membri di ogni elemento (TOutlinePoint) di m_outline hanno la seguente interpretazione:

  TPointD(x, y) rappresenta la posizione geometrica del punto sull'outline;

  'u' ("parametro di ampiezza") e 'v' ("ascissa curvilinea") sono significativi solo per 

      stroke di tipo TTextureStyle e rappresentano i parametri di texture;

  tangent/normal (significativi solo per stroke procedurali) rappresentano i vettori 

      tangente/normale alla centerline nel punto (sulla centerline) che ha lo stesso 't' di 

      quello considerato di m_outline (approssimazione...);

  stepCount (significativo solo per stroke procedurali) indicizza in modo crescente le coppie 

      di punti m_outline[2k], m_outline[2k + 1] richieste (IN ECCESSO) dal passo procedurale:

      in pratica, nel caso di stroke procedurale, m_outline contiene tutti i punti richiesti dal 

      passo (m_lengthStep: contato sulla centerline) di generazione della stroke procedurale 

      (per questi TOutlinePoint, stepCount e' crescente sulle coppie: 

        1)  m_outline[0].stepCount == m_outline[1].stepCount == 1;

        2)  m_outline[2k].stepCount == m_outline[2k + 1].stepCount;

        3)  se m_outline[2k + 1] e' un punto richiesto dal passo procedurale (m_lengthStep) e 

            m_outline[2k + 2h] e' un il punto successivo richiesto dal passo (m_lengthStep), 

            allora

          3.1)  m_outline[2k + s].stepCount = 0  (s = 2, ... , 2h - 1);

          3.2)  m_outline[2k + 2h].stepCount = m_outline[2k + 1].stepCount + 1;)

          3.3)  m_outline[2k + 2h].stepCount = m_outline[2k + 2h + 1].stepCount;

       )

       ed inoltre tutti quelli che servono per "addolcire" la linearizzazione a tratti 

       dell'outline (per questi TOutlinePoint, stepCount e' 0 (facilita i controlli...)) 

  */

private:

	std::vector<toutlinepoint> m_outline;</toutlinepoint>

public:

	TStrokeOutline() {}

	~TStrokeOutline() {}

	std::vector<toutlinepoint> &getArray()</toutlinepoint>

	{

		return m_outline;

	}

	TStrokeOutline(const TStrokeOutline &);

	TStrokeOutline &operator=(const TStrokeOutline &);

	void addOutlinePoint(const TOutlinePoint &);

};

//-----------------------------------------------------------------------------

DVAPI TStrokeOutline getOutline(const TStroke &stroke);

//-----------------------------------------------------------------------------

class TQuadratic;

DVAPI std::vector<tquadratic> getOutlineWithQuadratic(const TStroke &stroke);</tquadratic>

DVAPI void computeOutlines(const TStroke *stroke, int startQuad, int endQuad, std::vector<tquadratic *=""> &quadArray, double error2);</tquadratic>

//---------------------------------------------------------------------------------------

namespace TOutlineUtil

{

class DVAPI OutlineParameter

{

public:

	double m_lengthStep; //  max lengthStep (sulla centerline) per la linearizzazione dell'outline

	OutlineParameter(double lengthStep = 0)

		: m_lengthStep(lengthStep)

	{

	}

};

//per adesso implementata in tellipticbrush.cpp (per motivi storici)

DVAPI void makeOutline(const TStroke &stroke, TStrokeOutline &outline, const OutlineParameter ¶m);

DVAPI void makeOutline(const TStroke &path, const TStroke &brush, const TRectD &brushBox,

					   TStrokeOutline &outline, const OutlineParameter ¶m);

DVAPI void makeOutline(const TStroke &path, const TRegion &brush, const TRectD &brushBox,

					   TRegionOutline &outline);

DVAPI TRectD computeBBox(const TStroke &stroke);

}

//---------------------------------------------------------------------------------------

#endif // T_STROKE_OUTLINE_H

//-----------------------------------------------------------------------------

// End Of File

//-----------------------------------------------------------------------------