#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;

public:
  TStrokeOutline() {}
  ~TStrokeOutline() {}

  std::vector<TOutlinePoint> &getArray() { 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);

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

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

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 &param);
DVAPI void makeOutline(const TStroke &path, const TStroke &brush,
                       const TRectD &brushBox, TStrokeOutline &outline,
                       const OutlineParameter &param);

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