#pragma once

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

//  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 _MSC_VER

#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() { return m_outline; }</toutlinepoint>

  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

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