// TnzCore includes

#include "tcolorfunctions.h"

#include "trandom.h"

#include "tcurves.h"

#include "tvectorrenderdata.h"

#include "tmathutil.h"

#include "colorfxutils.h"

#include "tpixelutils.h"

#include "tconvert.h"

// tcg includes

#include "tcg/tcg_misc.h"

// Qt includes

#include <qcoreapplication></qcoreapplication>

#include <qstringlist></qstringlist>

#include "strokestyles.h"

using namespace std;

#define MINTHICK 1.0

//=============================================================================

namespace {

template <class t=""></class>

class TOptimizedStrokePropT final : public TStrokeProp {

protected:

  double m_pixelSize;

  TOptimizedStrokeStyleT<t> *m_colorStyle;</t>

  T m_data;

public:

  TOptimizedStrokePropT(const TStroke *stroke,

                        TOptimizedStrokeStyleT<t> *style);</t>

  ~TOptimizedStrokePropT() { m_colorStyle->release(); }

  const TColorStyle *getColorStyle() const override;

  TStrokeProp *clone(const TStroke *stroke) const override;

  void draw(const TVectorRenderData &rd) override;

};

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

template <class t=""></class>

TOptimizedStrokePropT<t>::TOptimizedStrokePropT(</t>

    const TStroke *stroke, TOptimizedStrokeStyleT<t> *style)</t>

    : TStrokeProp(stroke), m_colorStyle(style), m_pixelSize(0) {

  m_styleVersionNumber = style->getVersionNumber();

  m_colorStyle->addRef();

}

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

template <class t=""></class>

const TColorStyle *TOptimizedStrokePropT<t>::getColorStyle() const {</t>

  return m_colorStyle;

}

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

template <class t=""></class>

TStrokeProp *TOptimizedStrokePropT<t>::clone(const TStroke *stroke) const {</t>

  TOptimizedStrokePropT<t> *prop =</t>

      new TOptimizedStrokePropT<t>(stroke, m_colorStyle);</t>

  prop->m_strokeChanged = m_strokeChanged;

  prop->m_data          = m_data;

  return prop;

}

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

template <class t=""></class>

void TOptimizedStrokePropT<t>::draw(</t>

    const TVectorRenderData

        &rd) /*assenza di const non e' una dimenticanza! Alcune sottoclassi

                devono ridefinire questo metodo e serbve che non sia const*/

{

  if (rd.m_clippingRect != TRect() && !rd.m_is3dView &&

      !convert(rd.m_aff * m_stroke->getBBox()).overlaps(rd.m_clippingRect))

    return;

  glPushMatrix();

  tglMultMatrix(rd.m_aff);

  double pixelSize = sqrt(tglGetPixelSize2());

  if (m_strokeChanged ||

      m_styleVersionNumber != m_colorStyle->getVersionNumber() ||

      !isAlmostZero(pixelSize - m_pixelSize, 1e-5)) {

    m_strokeChanged      = false;

    m_pixelSize          = pixelSize;

    m_styleVersionNumber = m_colorStyle->getVersionNumber();

    m_colorStyle->computeData(m_data, m_stroke, rd.m_cf);

  }

  m_colorStyle->drawStroke(rd.m_cf, m_data, m_stroke);

  glPopMatrix();

}

}

//=============================================================================

template <class t=""></class>

TStrokeProp *TOptimizedStrokeStyleT<t>::makeStrokeProp(const TStroke *stroke) {</t>

  return new TOptimizedStrokePropT<t>(stroke, this);</t>

}

//=============================================================================

inline void tglNormal(const T3DPointD &p) { glNormal3d(p.x, p.y, p.z); }

inline void tglVertex(const T3DPointD &p) { glVertex3d(p.x, p.y, p.z); }

//=============================================================================

TFurStrokeStyle::TFurStrokeStyle()

    : m_color(TPixel32::Black)

    , m_angle(120.0)

    , m_length(1.0)

    , m_cs(0.0)

    , m_sn(0.0) {

  double rad = m_angle * M_PI_180;

  m_cs       = cos(rad);

  m_sn       = sin(rad);

}

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

TColorStyle *TFurStrokeStyle::clone() const {

  return new TFurStrokeStyle(*this);

}

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

int TFurStrokeStyle::getParamCount() const { return 2; }

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

TColorStyle::ParamType TFurStrokeStyle::getParamType(int index) const {

  assert(0 <= index && index < getParamCount());

  return TColorStyle::DOUBLE;

}

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

QString TFurStrokeStyle::getParamNames(int index) const {

  assert(0 <= index && index < getParamCount());

  return index == 0 ? QCoreApplication::translate("TFurStrokeStyle", "Angle")

                    : QCoreApplication::translate("TFurStrokeStyle", "Size");

}

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

void TFurStrokeStyle::getParamRange(int index, double &min, double &max) const {

  assert(0 <= index && index < getParamCount());

  if (index == 0) {

    min = 0.0;

    max = 180.0;

  } else {

    min = 0.0;

    max = 1.0;

  }

}

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

double TFurStrokeStyle::getParamValue(TColorStyle::double_tag,

                                      int index) const {

  assert(0 <= index && index < getParamCount());

  return index == 0 ? m_angle : m_length;

}

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

void TFurStrokeStyle::setParamValue(int index, double value) {

  assert(0 <= index && index < getParamCount());

  if (index == 0) {

    m_angle    = value;

    double rad = m_angle * M_PI_180;

    m_cs       = cos(rad);

    m_sn       = sin(rad);

  } else

    m_length = value;

  updateVersionNumber();

}

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

void TFurStrokeStyle::computeData(Points &positions, const TStroke *stroke,

                                  const TColorFunction *cf) const {

  double length = stroke->getLength();

  double s  = 0.0;

  double ds = 4;

  double vs = 1;

  TRandom rnd;

  positions.clear();

  positions.reserve(tceil(length / ds) + 1);

  while (s <= length) {

    double w        = stroke->getParameterAtLength(s);

    TThickPoint pos = stroke->getThickPoint(w);

    TPointD u       = stroke->getSpeed(w);

    if (norm2(u) == 0.0) {

      s += 0.5;

      continue;

    }

    u         = normalize(u);

    TPointD v = rotate90(u);

    double length = 0;

    if (pos.thick)

      length = m_length * pos.thick;

    else

      length = 1.0;

    vs = -vs;

    positions.push_back(pos);

    double q = 0.01 * (rnd.getFloat() * 2 - 1);

    positions.push_back(pos + length * ((m_cs + q) * u + (vs * m_sn) * v));

    s += ds;

  }

}

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

void TFurStrokeStyle::drawStroke(const TColorFunction *cf, Points &positions,

                                 const TStroke *stroke) const {

  TPixel32 color;

  if (cf)

    color = (*(cf))(m_color);

  else

    color = m_color;

  tglColor(color);

  for (UINT i = 0; i < positions.size(); i += 2) {

    glBegin(GL_LINE_STRIP);

    tglColor(color);

    tglVertex(positions[i]);

    glColor4d(1, 1, 1, 0.0);

    tglVertex(positions[i + 1]);

    glEnd();

  }

}

//=============================================================================

TChainStrokeStyle::TChainStrokeStyle(const TPixel32 &color) : m_color(color) {}

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

TChainStrokeStyle::TChainStrokeStyle() : m_color(TPixel32(20, 10, 0)) {}

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

TColorStyle *TChainStrokeStyle::clone() const {

  return new TChainStrokeStyle(*this);

}

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

void TChainStrokeStyle::computeData(Points &data, const TStroke *stroke,

                                    const TColorFunction *cf) const {

  // TStroke *stroke = getStroke();

  double length = stroke->getLength();

  // spessore della catena = spessore "medio" dello stroke

  double thickness =

      0.25 *

      (stroke->getThickPoint(0).thick + stroke->getThickPoint(1.0 / 3.0).thick +

       stroke->getThickPoint(2.0 / 3.0).thick + stroke->getThickPoint(1).thick);

  if (thickness == 0) thickness = 0.1;

  double ringHeight             = thickness;

  double ringWidth              = 1.5 * ringHeight;

  // distanza fra i centri degli anelli

  double ringDistance = 2 * 1.2 * ringWidth;

  // distanza fra il centro dell'anello e il punto di attacco dell'anello

  // trasversale

  // double joinPos = 0.45 * ringWidth;

  TPointD oldPos;

  // bool firstRing = true;

  double s = 0;

  data.clear();

  data.reserve(tceil(length / ringDistance) * 2 + 2);

  while (s <= length) {

    double w = stroke->getParameterAtLength(s);

    // if(w<0) {s+=0.1; continue;} // per tamponare il baco della

    // getParameterAtLength()

    TThickPoint pos = stroke->getThickPoint(w);

    TPointD u       = stroke->getSpeed(w);

    if (norm2(u) == 0) {

      s += 0.1;

      continue;

    }  // non dovrebbe succedere mai, ma per prudenza....

    u = normalize(u);

    data.push_back(pos);

    data.push_back(u);

    // se e' il caso unisco la catena alla precedente

    s += ringDistance;

  }

}

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

void TChainStrokeStyle::drawStroke(const TColorFunction *cf, Points &data,

                                   const TStroke *stroke) const {

  // TStroke *stroke = getStroke();

  // double length = stroke->getLength();

  // spessore della catena = spessore "medio" dello stroke

  double thickness =

      0.25 *

      (stroke->getThickPoint(0).thick + stroke->getThickPoint(1.0 / 3.0).thick +

       stroke->getThickPoint(2.0 / 3.0).thick + stroke->getThickPoint(1).thick);

  if (thickness * thickness < 4 * tglGetPixelSize2()) {

    TCenterLineStrokeStyle *appStyle =

        new TCenterLineStrokeStyle(m_color, 0x0, thickness);

    appStyle->drawStroke(cf, stroke);

    delete appStyle;

    return;

  }

  assert(thickness);

  double ringHeight = thickness;

  double ringWidth  = 1.5 * ringHeight;

  // distanza fra i centri degli anelli

  // double ringDistance = 2 * 1.2 * ringWidth;

  // distanza fra il centro dell'anello e il punto di attacco dell'anello

  // trasversale

  double joinPos = 0.45 * ringWidth;

  // definisco la forma dell'anello della catena

  GLuint ringId;

  ringId   = glGenLists(1);

  double a = .6, b = .6;

  glNewList(ringId, GL_COMPILE);

  glPushMatrix();

  glScaled(ringWidth, ringHeight, 1);

  glBegin(GL_LINE_STRIP);

  glVertex2d(1, b);

  glVertex2d(a, 1);

  glVertex2d(-a, 1);

  glVertex2d(-1, b);

  glVertex2d(-1, -b);

  glVertex2d(-a, -1);

  glVertex2d(a, -1);

  glVertex2d(1, -b);

  glVertex2d(1, b);

  glEnd();

  glPopMatrix();

  glEndList();

  // disegno la catena

  if (cf)

    tglColor((*cf)(m_color));

  else

    tglColor(m_color);

  TPointD oldPos;

  // bool firstRing = true;

  // double s = 0;

  for (UINT i = 0; i < data.size(); i += 2) {

    TPointD pos = data[i];

    TPointD u   = data[i + 1];

    TPointD v   = rotate90(u);

    // disegno un anello della catena

    glPushMatrix();

    TAffine aff(u.x, v.x, pos.x, u.y, v.y, pos.y);

    tglMultMatrix(aff);

    glCallList(ringId);

    glPopMatrix();

    // se e' il caso unisco la catena alla precedente

    if (i != 0) {

      TPointD q = pos - u * joinPos;

      tglDrawSegment(oldPos, q);

    }

    oldPos = pos + u * joinPos;

  }

  glDeleteLists(ringId, 1);

}

//=============================================================================

TSprayStrokeStyle::TSprayStrokeStyle()

    : m_color(TPixel32::Blue), m_blend(0.5), m_intensity(10.0), m_radius(0.3) {}

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

TColorStyle *TSprayStrokeStyle::clone() const {

  return new TSprayStrokeStyle(*this);

}

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

int TSprayStrokeStyle::getParamCount() const { return 3; }

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

TColorStyle::ParamType TSprayStrokeStyle::getParamType(int index) const {

  assert(0 <= index && index < getParamCount());

  return TColorStyle::DOUBLE;

}

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

QString TSprayStrokeStyle::getParamNames(int index) const {

  assert(0 <= index && index < 3);

  QString value;

  switch (index) {

  case 0:

    value = QCoreApplication::translate("TSprayStrokeStyle", "Border Fade");

    break;

  case 1:

    value = QCoreApplication::translate("TSprayStrokeStyle", "Density");

    break;

  case 2:

    value = QCoreApplication::translate("TSprayStrokeStyle", "Size");

    break;

  }

  return value;

}

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

void TSprayStrokeStyle::getParamRange(int index, double &min,

                                      double &max) const {

  assert(0 <= index && index < 3);

  switch (index) {

  case 0:

    min = 0.0;

    max = 1.0;

    break;

  case 1:

    min = 0.0;

    max = 100.0;

    break;

  case 2:

    min = 0.0;

    max = 1.0;

    break;

  }

}

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

double TSprayStrokeStyle::getParamValue(TColorStyle::double_tag,

                                        int index) const {

  assert(0 <= index && index < 3);

  double value = 0;

  switch (index) {

  case 0:

    value = m_blend;

    break;

  case 1:

    value = m_intensity;

    break;

  case 2:

    value = m_radius;

    break;

  }

  return value;

}

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

void TSprayStrokeStyle::setParamValue(int index, double value) {

  assert(0 <= index && index < 3);

  switch (index) {

  case 0:

    m_blend = value;

    break;

  case 1:

    m_intensity = value;

    break;

  case 2:

    m_radius = value;

    break;

  }

  updateVersionNumber();

}

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

void TSprayStrokeStyle::drawStroke(const TColorFunction *cf,

                                   const TStroke *stroke) const {

  //  TStroke *stroke = getStroke();

  double length = stroke->getLength();

  double step   = 4;

  double blend = m_blend;          // distanza che controlla da dove il gessetto

                                   // comincia il fade out  (0, 1)

  double intensity = m_intensity;  // quanti punti vengono disegnati ad ogni

                                   // step

  double radius = m_radius;

  double decay  = 1 - blend;

  bool fill     = 0;

  TPointD pos1;

  TRandom rnd;

  TPixelD dcolor;

  TPixel32 color;

  if (cf)

    color = (*(cf))(m_color);

  else

    color             = m_color;

  dcolor              = toPixelD(color);

  double s            = 0;

  double minthickness = MINTHICK * sqrt(tglGetPixelSize2());

  double thickness    = 0;

  while (s <= length) {

    double w = stroke->getParameterAtLength(s);

    // if(w<0) {s+=0.1; continue;} // per tamponare il baco della

    // getParameterAtLength()

    TThickPoint pos = stroke->getThickPoint(w);

    TPointD u       = stroke->getSpeed(w);

    double normu    = norm2(u);

    if (normu == 0) {

      s += 0.1;

      continue;

    }  // non dovrebbe succedere mai, ma per prudenza....

    u         = normalize(u);

    TPointD v = rotate90(u);

    TPointD shift;

    if (pos.thick < MINTHICK)

      thickness = minthickness;

    else

      thickness = pos.thick;

    for (int i = 0; i < intensity; i++) {

      double vrandnorm = (0.5 - rnd.getFloat()) * 2;

      double randomv   = vrandnorm * pos.thick;

      double randomu   = (0.5 - rnd.getFloat()) * step;

      shift            = u * randomu + v * randomv;

      pos1             = pos + shift;

      double mod       = fabs(vrandnorm);

      if (mod < decay)

        glColor4d(dcolor.r, dcolor.g, dcolor.b, rnd.getFloat() * dcolor.m);

      else

        glColor4d(dcolor.r, dcolor.g, dcolor.b,

                  rnd.getFloat() * (1 - mod) * dcolor.m);

      if (fill)

        tglDrawDisk(pos1, radius * thickness * rnd.getFloat());

      else

        tglDrawCircle(pos1, radius * thickness * rnd.getFloat());

    }

    s += step;

  }

}

//=============================================================================

TGraphicPenStrokeStyle::TGraphicPenStrokeStyle()

    : m_color(TPixel32::Black), m_intensity(10.0) {}

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

TColorStyle *TGraphicPenStrokeStyle::clone() const {

  return new TGraphicPenStrokeStyle(*this);

}

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

int TGraphicPenStrokeStyle::getParamCount() const { return 1; }

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

TColorStyle::ParamType TGraphicPenStrokeStyle::getParamType(int index) const {

  assert(0 <= index && index < getParamCount());

  return TColorStyle::DOUBLE;

}

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

QString TGraphicPenStrokeStyle::getParamNames(int index) const {

  assert(0 <= index && index < 1);

  return QCoreApplication::translate("TGraphicPenStrokeStyle", "Density");

}

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

void TGraphicPenStrokeStyle::getParamRange(int index, double &min,

                                           double &max) const {

  assert(0 <= index && index < 1);

  min = 0.0;

  max = 10.0;

}

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

double TGraphicPenStrokeStyle::getParamValue(TColorStyle::double_tag,

                                             int index) const {

  assert(0 <= index && index < 1);

  return m_intensity;

}

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

void TGraphicPenStrokeStyle::setParamValue(int index, double value) {

  assert(0 <= index && index < 1);

  m_intensity = value;

  updateVersionNumber();

}

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

void TGraphicPenStrokeStyle::computeData(DrawmodePointsMatrix &data,

                                         const TStroke *stroke,

                                         const TColorFunction *cf) const {

  data.clear();

  double length = stroke->getLength();

  double step   = 10;

  TPointD pos1, pos2;

  TRandom rnd;

  double intensity = m_intensity;

  data.reserve(tceil(length / 10.0));

  double s = 0;

  while (s <= length) {

    double w = stroke->getParameterAtLength(s);

    // if(w<0) {s+=0.1; continue;} // per tamponare il baco della

    // getParameterAtLength()

    TThickPoint pos = stroke->getThickPoint(w);

    TPointD u       = stroke->getSpeed(w);

    double normu    = norm2(u);

    if (normu == 0) {

      s += 0.1;

      continue;

    }  // non dovrebbe succedere mai, ma per prudenza....

    u         = normalize(u);

    TPointD v = rotate90(u);

    TPointD shift;

    Points tmpPoints;

    tmpPoints.clear();

    GLenum drawMode;

    for (int i = 0; i < intensity; i++) {

      if (pos.thick) {

        drawMode = GL_LINES;

        tmpPoints.reserve((int)(intensity * 2 + 1));

        double randomv = (0.5 - rnd.getFloat()) * pos.thick;

        double randomu = (0.5 - rnd.getFloat()) * step;

        shift          = randomu * u + randomv * v;

        pos1           = pos + shift + v * (pos.thick);

        pos2           = pos + shift - v * (pos.thick);

        tmpPoints.push_back(pos1);

        tmpPoints.push_back(pos2);

      } else {

        drawMode = GL_POINTS;

        tmpPoints.reserve((int)(intensity + 1));

        tmpPoints.push_back((TPointD)pos);

      }

    }

    if (!tmpPoints.empty()) {

      assert(drawMode == GL_POINTS || drawMode == GL_LINES);

      data.push_back(make_pair(drawMode, tmpPoints));

    }

    s += step;

  }

}

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

void TGraphicPenStrokeStyle::drawStroke(const TColorFunction *cf,

                                        DrawmodePointsMatrix &data,

                                        const TStroke *stroke) const {

  TPixel32 color;

  if (cf)

    color = (*(cf))(m_color);

  else

    color = m_color;

  tglColor(color);

  DrawmodePointsMatrix::iterator it1 = data.begin();

  for (; it1 != data.end(); ++it1) {

    if (it1->first == GL_LINES) {

      Points::iterator it2 = it1->second.begin();

      glBegin(GL_LINES);

      for (; it2 != it1->second.end(); ++it2) tglVertex(*it2);

      glEnd();

    } else {

      assert(it1->first == GL_POINTS);

      Points::iterator it2 = it1->second.begin();

      glBegin(GL_POINTS);

      for (; it2 != it1->second.end(); ++it2) tglVertex(*it2);

      glEnd();

    }

  }

}

//=============================================================================

namespace {

double inline get_line_slope(double meter, double inmax, double linemax,

                             double outmax) {

  if (meter <= inmax)

    return meter / inmax;

  else if (meter <= inmax + linemax)

    return 1;

  else if (meter <= inmax + linemax + outmax)

    return (inmax + linemax - meter) / outmax + 1;

  else

    return 0;

}

}

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

TDottedLineStrokeStyle::TDottedLineStrokeStyle()

    : m_color(TPixel32::Black)

    , m_in(10.0)

    , m_line(50.0)

    , m_out(10.0)

    , m_blank(10.0) {}

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

TColorStyle *TDottedLineStrokeStyle::clone() const {

  return new TDottedLineStrokeStyle(*this);

}

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

int TDottedLineStrokeStyle::getParamCount() const { return 4; }

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

TColorStyle::ParamType TDottedLineStrokeStyle::getParamType(int index) const {

  assert(0 <= index && index < getParamCount());

  return TColorStyle::DOUBLE;

}

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

QString TDottedLineStrokeStyle::getParamNames(int index) const {

  assert(0 <= index && index < 4);

  QString value;

  switch (index) {

  case 0:

    value = QCoreApplication::translate("TDottedLineStrokeStyle", "Fade In");

    break;

  case 1:

    value = QCoreApplication::translate("TDottedLineStrokeStyle", "Dash");

    break;

  case 2:

    value = QCoreApplication::translate("TDottedLineStrokeStyle", "Fade Out");

    break;

  case 3:

    value = QCoreApplication::translate("TDottedLineStrokeStyle", "Gap");

    break;

  }

  return value;

}

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

void TDottedLineStrokeStyle::getParamRange(int index, double &min,

                                           double &max) const {

  assert(0 <= index && index < 4);

  switch (index) {

  case 0:

    min = 1.0;

    max = 100.0;

    break;

  case 1:

    min = 1.0;

    max = 100.0;

    break;

  case 2:

    min = 1.;

    max = 100.0;

    break;

  case 3:

    min = 0.0;

    max = 100.0;

    break;

  }

}

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

double TDottedLineStrokeStyle::getParamValue(TColorStyle::double_tag,

                                             int index) const {

  assert(0 <= index && index < 4);

  double value = 0;

  switch (index) {

  case 0:

    value = m_in;

    break;

  case 1:

    value = m_line;

    break;

  case 2:

    value = m_out;

    break;

  case 3:

    value = m_blank;

    break;

  }

  return value;

}

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

void TDottedLineStrokeStyle::setParamValue(int index, double value) {

  assert(0 <= index && index < 4);

  switch (index) {

  case 0:

    m_in = value;

    break;

  case 1:

    m_line = value;

    break;

  case 2:

    m_out = value;

    break;

  case 3:

    m_blank = value;

    break;

  }

  updateVersionNumber();

}

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

void TDottedLineStrokeStyle::computeData(Points &positions,

                                         const TStroke *stroke,

                                         const TColorFunction *cf) const {

  double length = stroke->getLength();

  double step     = 5.0;

  double linemax  = m_line;

  double inmax    = (m_in / 100);

  double outmax   = (m_out / 100);

  double blankmax = m_blank;

  double total    = 0;

  TRandom rnd;

  positions.clear();

  positions.reserve(tceil(length / step) + 1);

  TPointD oldPos1, oldPos2, oldPos3, oldPos4, pos1, pos2, pos3, pos4;

  // bool firstRing = true;

  double s            = 0;

  double meter        = 0;

  double center       = 0;

  double slopetmp     = 0;

  double minthickness = MINTHICK * sqrt(tglGetPixelSize2());

  double thickness    = 0;

  double line = 0, in = 0, out = 0, blank = 0;

  while (s <= length) {

    double w = stroke->getParameterAtLength(s);

    if (w < 0) {

      s += 0.1;

      continue;