StrokeRep.cpp

Go to the documentation of this file.

/* SPDX-FileCopyrightText: 2008-2023 Blender Authors
 *
 * SPDX-License-Identifier: GPL-2.0-or-later */

 
#include <cmath>
 
#include "Stroke.h"
#include "StrokeAdvancedIterators.h"
#include "StrokeIterators.h"
#include "StrokeRenderer.h"
#include "StrokeRep.h"
 
#include "BKE_global.hh"
 
using namespace std;
 
namespace Freestyle {
 
//
// STROKE VERTEX REP
 
StrokeVertexRep::StrokeVertexRep(const StrokeVertexRep &iBrother)
{
  _point2d = iBrother._point2d;
  _texCoord = iBrother._texCoord;
  _texCoord_w_tips = iBrother._texCoord_w_tips;
  _color = iBrother._color;
  _alpha = iBrother._alpha;
}
 
//
// STRIP
 
Strip::Strip(const vector<StrokeVertex *> &iStrokeVertices,
             bool hasTex,
             bool tipBegin,
             bool tipEnd,
             float texStep)
{
  createStrip(iStrokeVertices);
 
  setVertexColor(iStrokeVertices);
 
  if (hasTex) {
    // We compute both kinds of coordinates to use different kinds of textures
    computeTexCoord(iStrokeVertices, texStep);
    computeTexCoordWithTips(iStrokeVertices, tipBegin, tipEnd, texStep);
  }
}
 
Strip::Strip(const Strip &iBrother)
{
  if (!iBrother._vertices.empty()) {
    for (vertex_container::const_iterator v = iBrother._vertices.begin(),
                                          vend = iBrother._vertices.end();
         v != vend;
         ++v)
    {
      _vertices.push_back(new StrokeVertexRep(**v));
    }
  }
  _averageThickness = iBrother._averageThickness;
}
 
Strip::~Strip()
{
  if (!_vertices.empty()) {
    for (vertex_container::iterator v = _vertices.begin(), vend = _vertices.end(); v != vend; ++v)
    {
      delete (*v);
    }
    _vertices.clear();
  }
}

// Strip creation
 
#define EPS_SINGULARITY_RENDERER 0.05
#define ZERO 0.00001
#define MAX_RATIO_LENGTH_SINGU 2
#define HUGE_COORD 1.0e4
 
static bool notValid(Vec2r p)
{
  return (p[0] != p[0]) || (p[1] != p[1]) || (fabs(p[0]) > HUGE_COORD) ||
         (fabs(p[1]) > HUGE_COORD) || (p[0] < -HUGE_COORD) || (p[1] < -HUGE_COORD);
}
 
#if 0
static real crossP(const Vec2r &A, const Vec2r &B)
{
  return A[0] * B[1] - A[1] * B[0];
}
#endif
 
void Strip::createStrip(const vector<StrokeVertex *> &iStrokeVertices)
{
  // computeParameterization();
  if (iStrokeVertices.size() < 2) {
    if (G.debug & G_DEBUG_FREESTYLE) {
      cout << "Warning: strip has less than 2 vertices" << endl;
    }
    return;
  }
  _vertices.reserve(2 * iStrokeVertices.size());
  if (!_vertices.empty()) {
    for (vertex_container::iterator v = _vertices.begin(), vend = _vertices.end(); v != vend; ++v)
    {
      delete (*v);
    }
    _vertices.clear();
  }
  _averageThickness = 0.0;
 
  vector<StrokeVertex *>::const_iterator v, vend, v2, vPrev;
  StrokeVertex *sv, *sv2, *svPrev;
  int orientationErrors = 0;
 
  // special case of first vertex
  v2 = v = iStrokeVertices.begin();
  ++v2;
  sv = *v;
  vPrev = v;  // in case the stroke has only 2 vertices;
  sv2 = *v2;
  Vec2r dir(sv2->getPoint() - sv->getPoint());
  Vec2r orthDir(-dir[1], dir[0]);
  if (orthDir.norm() > ZERO) {
    orthDir.normalize();
  }
  Vec2r stripDir(orthDir);
  // check whether the orientation was user defined
  if (sv->attribute().isAttributeAvailableVec2f("orientation")) {
    Vec2r userDir = sv->attribute().getAttributeVec2f("orientation");
    if (userDir.norm() > 1e-6) {
      userDir.normalize();
      real dp = userDir * orthDir;
      if (dp < 0) {
        userDir = userDir * (-1.0f);
      }
      stripDir = userDir;
    }
    else {
      ++orientationErrors;
    }
  }
  const float *thickness = sv->attribute().getThickness();
  _vertices.push_back(new StrokeVertexRep(sv->getPoint() + thickness[1] * stripDir));
  _vertices.push_back(new StrokeVertexRep(sv->getPoint() - thickness[0] * stripDir));
 
#if 0
  Vec2r userDir = _stroke->getBeginningOrientation();
  if (userDir != Vec2r(0, 0)) {
    userDir.normalize();
    real o1 = (orthDir * userDir);
    real o2 = crossP(orthDir, userDir);
    real orientation = o1 * o2;
    if (orientation > 0) {
      // then the vertex to move is v0
      if (o1 > 0) {
        _vertex[0] = _vertex[1] + userDir;
      }
      else {
        _vertex[0] = _vertex[1] - userDir;
      }
    }
    if (orientation < 0) {
      // then we must move v1
      if (o1 < 0) {
        _vertex[1] = _vertex[0] + userDir;
      }
      else {
        _vertex[1] = _vertex[0] - userDir;
      }
    }
  }
#endif
 
  int i = 2;  // 2 because we have already processed the first vertex
 
  for (vend = iStrokeVertices.end(), ++v, ++v2; v2 != vend; vPrev = v++, ++v2) {
    sv = (*v);
    sv2 = (*v2);
    svPrev = (*vPrev);
    Vec2r p(sv->getPoint()), p2(sv2->getPoint()), pPrev(svPrev->getPoint());
 
    // direction and orthogonal vector to the next segment
    Vec2r dir(p2 - p);
    float dirNorm = dir.norm();
    dir.normalize();
    Vec2r orthDir(-dir[1], dir[0]);
    Vec2r stripDir = orthDir;
    if (sv->attribute().isAttributeAvailableVec2f("orientation")) {
      Vec2r userDir = sv->attribute().getAttributeVec2f("orientation");
      if (userDir.norm() > 1e-6) {
        userDir.normalize();
        real dp = userDir * orthDir;
        if (dp < 0) {
          userDir = userDir * (-1.0f);
        }
        stripDir = userDir;
      }
      else {
        ++orientationErrors;
      }
    }
 
    // direction and orthogonal vector to the previous segment
    Vec2r dirPrev(p - pPrev);
    float dirPrevNorm = dirPrev.norm();
    dirPrev.normalize();
    Vec2r orthDirPrev(-dirPrev[1], dirPrev[0]);
    Vec2r stripDirPrev = orthDirPrev;
    if (svPrev->attribute().isAttributeAvailableVec2f("orientation")) {
      Vec2r userDir = svPrev->attribute().getAttributeVec2f("orientation");
      if (userDir.norm() > 1e-6) {
        userDir.normalize();
        real dp = userDir * orthDir;
        if (dp < 0) {
          userDir = userDir * (-1.0f);
        }
        stripDirPrev = userDir;
      }
      else {
        ++orientationErrors;
      }
    }
 
    const float *thickness = sv->attribute().getThickness();
    _averageThickness += thickness[0] + thickness[1];
    Vec2r pInter;
    int interResult;
 
    interResult = GeomUtils::intersect2dLine2dLine(Vec2r(pPrev + thickness[1] * stripDirPrev),
                                                   Vec2r(p + thickness[1] * stripDirPrev),
                                                   Vec2r(p + thickness[1] * stripDir),
                                                   Vec2r(p2 + thickness[1] * stripDir),
                                                   pInter);
    if (interResult == GeomUtils::DO_INTERSECT) {
      _vertices.push_back(new StrokeVertexRep(pInter));
    }
    else {
      _vertices.push_back(new StrokeVertexRep(p + thickness[1] * stripDir));
    }
    ++i;
 
    interResult = GeomUtils::intersect2dLine2dLine(Vec2r(pPrev - thickness[0] * stripDirPrev),
                                                   Vec2r(p - thickness[0] * stripDirPrev),
                                                   Vec2r(p - thickness[0] * stripDir),
                                                   Vec2r(p2 - thickness[0] * stripDir),
                                                   pInter);
    if (interResult == GeomUtils::DO_INTERSECT) {
      _vertices.push_back(new StrokeVertexRep(pInter));
    }
    else {
      _vertices.push_back(new StrokeVertexRep(p - thickness[0] * stripDir));
    }
    ++i;
 
    // if the angle is obtuse, we simply average the directions to avoid the singularity
    stripDir = stripDir + stripDirPrev;
    if ((dirNorm < ZERO) || (dirPrevNorm < ZERO) || (stripDir.norm() < ZERO)) {
      stripDir[0] = 0;
      stripDir[1] = 0;
    }
    else {
      stripDir.normalize();
    }
 
    Vec2r vec_tmp(_vertices[i - 2]->point2d() - p);
    if ((vec_tmp.norm() > thickness[1] * MAX_RATIO_LENGTH_SINGU) || (dirNorm < ZERO) ||
        (dirPrevNorm < ZERO) || notValid(_vertices[i - 2]->point2d()) ||
        (fabs(stripDir * dir) < EPS_SINGULARITY_RENDERER))
    {
      _vertices[i - 2]->setPoint2d(p + thickness[1] * stripDir);
    }
 
    vec_tmp = _vertices[i - 1]->point2d() - p;
    if ((vec_tmp.norm() > thickness[0] * MAX_RATIO_LENGTH_SINGU) || (dirNorm < ZERO) ||
        (dirPrevNorm < ZERO) || notValid(_vertices[i - 1]->point2d()) ||
        (fabs(stripDir * dir) < EPS_SINGULARITY_RENDERER))
    {
      _vertices[i - 1]->setPoint2d(p - thickness[0] * stripDir);
    }
  }  // end of for
 
  // special case of last vertex
  sv = *v;
  sv2 = *vPrev;
  dir = Vec2r(sv->getPoint() - sv2->getPoint());
  orthDir = Vec2r(-dir[1], dir[0]);
  if (orthDir.norm() > ZERO) {
    orthDir.normalize();
  }
  Vec2r stripDirLast(orthDir);
  // check whether the orientation was user defined
  if (sv->attribute().isAttributeAvailableVec2f("orientation")) {
    Vec2r userDir = sv->attribute().getAttributeVec2f("orientation");
    if (userDir.norm() > 1e-6) {
      userDir.normalize();
      real dp = userDir * orthDir;
      if (dp < 0) {
        userDir = userDir * (-1.0f);
      }
      stripDirLast = userDir;
    }
    else {
      ++orientationErrors;
    }
  }
  const float *thicknessLast = sv->attribute().getThickness();
  _vertices.push_back(new StrokeVertexRep(sv->getPoint() + thicknessLast[1] * stripDirLast));
  ++i;
  _vertices.push_back(new StrokeVertexRep(sv->getPoint() - thicknessLast[0] * stripDirLast));
  ++i;
 
#if 0
  int n = i - 1;
  // check whether the orientation of the extremity was user defined
  userDir = _stroke->getEndingOrientation();
  if (userDir != Vec2r(0, 0)) {
    userDir.normalize();
    real o1 = (orthDir * userDir);
    real o2 = crossP(orthDir, userDir);
    real orientation = o1 * o2;
    if (orientation > 0) {
      // then the vertex to move is vn
      if (o1 < 0) {
        _vertex[n] = _vertex[n - 1] + userDir;
      }
      else {
        _vertex[n] = _vertex[n - 1] - userDir;
      }
    }
    if (orientation < 0) {
      // then we must move vn-1
      if (o1 > 0) {
        _vertex[n - 1] = _vertex[n] + userDir;
      }
      else {
        _vertex[n - 1] = _vertex[n] - userDir;
      }
    }
  }
#endif
 
  _averageThickness /= float(iStrokeVertices.size() - 2);
  // I did not use the first and last vertex for the average
  if (iStrokeVertices.size() < 3) {
    _averageThickness = 0.5 * (thicknessLast[1] + thicknessLast[0] + thickness[0] + thickness[1]);
  }
 
  if (orientationErrors > 0) {
    if (G.debug & G_DEBUG_FREESTYLE) {
      cout << "Warning: " << orientationErrors
           << " invalid zero-length orientation vector(s) found.\n";
    }
  }
 
  if (i != 2 * int(iStrokeVertices.size())) {
    if (G.debug & G_DEBUG_FREESTYLE) {
      cout << "Warning: problem with stripe size\n";
    }
  }
 
  cleanUpSingularities(iStrokeVertices);
}
 
// CLEAN UP
 
void Strip::cleanUpSingularities(const vector<StrokeVertex *> &iStrokeVertices)
{
  int k;
  int sizeStrip = _vertices.size();
 
  for (k = 0; k < sizeStrip; k++) {
    if (notValid(_vertices[k]->point2d())) {
      if (G.debug & G_DEBUG_FREESTYLE) {
        cout << "Warning: strip vertex " << k << " non valid" << endl;
      }
      return;
    }
  }
 
  // return;
  if (iStrokeVertices.size() < 2) {
    return;
  }
  int i = 0, j;
  vector<StrokeVertex *>::const_iterator v, vend, v2;
  StrokeVertex *sv, *sv2;
 
  bool singu1 = false, singu2 = false;
  int timeSinceSingu1 = 0, timeSinceSingu2 = 0;
 
  // special case of first vertex
  v = iStrokeVertices.begin();
  for (vend = iStrokeVertices.end(); v != vend; v++) {
    v2 = v;
    ++v2;
    if (v2 == vend) {
      break;
    }
    sv = (*v);
    sv2 = (*v2);
    Vec2r p(sv->getPoint()), p2(sv2->getPoint());
 
    Vec2r dir(p2 - p);
    if (dir.norm() > ZERO) {
      dir.normalize();
    }
    Vec2r dir1, dir2;
    dir1 = _vertices[2 * i + 2]->point2d() - _vertices[2 * i]->point2d();
    dir2 = _vertices[2 * i + 3]->point2d() - _vertices[2 * i + 1]->point2d();
 
    if ((dir1 * dir) < -ZERO) {
      singu1 = true;
      timeSinceSingu1++;
    }
    else {
      if (singu1) {
        int toto = i - timeSinceSingu1;
        if (toto < 0) {
          cerr << "Stephane dit \"Toto\"" << endl;
        }
        // traverse all the vertices of the singularity and average them
        Vec2r avP(0.0, 0.0);
        for (j = i - timeSinceSingu1; j <= i; j++) {
          avP = Vec2r(avP + _vertices[2 * j]->point2d());
        }
        avP = Vec2r(1.0 / float(timeSinceSingu1 + 1) * avP);
        for (j = i - timeSinceSingu1; j <= i; j++) {
          _vertices[2 * j]->setPoint2d(avP);
        }
        //_vertex[2 * j] = _vertex[2 * i];
        singu1 = false;
        timeSinceSingu1 = 0;
      }
    }
    if ((dir2 * dir) < -ZERO) {
      singu2 = true;
      timeSinceSingu2++;
    }
    else {
      if (singu2) {
        int toto = i - timeSinceSingu2;
        if (toto < 0) {
          cerr << "Stephane dit \"Toto\"" << endl;
        }
        // traverse all the vertices of the singularity and average them
        Vec2r avP(0.0, 0.0);
        for (j = i - timeSinceSingu2; j <= i; j++) {
          avP = Vec2r(avP + _vertices[2 * j + 1]->point2d());
        }
        avP = Vec2r(1.0 / float(timeSinceSingu2 + 1) * avP);
        for (j = i - timeSinceSingu2; j <= i; j++) {
          _vertices[2 * j + 1]->setPoint2d(avP);
        }
        //_vertex[2 * j + 1] = _vertex[2 * i + 1];
        singu2 = false;
        timeSinceSingu2 = 0;
      }
    }
    i++;
  }
 
  if (singu1) {
    // traverse all the vertices of the singularity and average them
    Vec2r avP(0.0, 0.0);
    for (j = i - timeSinceSingu1; j < i; j++) {
      avP = Vec2r(avP + _vertices[2 * j]->point2d());
    }
    avP = Vec2r(1.0 / float(timeSinceSingu1) * avP);
    for (j = i - timeSinceSingu1; j < i; j++) {
      _vertices[2 * j]->setPoint2d(avP);
    }
  }
  if (singu2) {
    // traverse all the vertices of the singularity and average them
    Vec2r avP(0.0, 0.0);
    for (j = i - timeSinceSingu2; j < i; j++) {
      avP = Vec2r(avP + _vertices[2 * j + 1]->point2d());
    }
    avP = Vec2r(1.0 / float(timeSinceSingu2) * avP);
    for (j = i - timeSinceSingu2; j < i; j++) {
      _vertices[2 * j + 1]->setPoint2d(avP);
    }
  }
 
  for (k = 0; k < sizeStrip; k++) {
    if (notValid(_vertices[k]->point2d())) {
      if (G.debug & G_DEBUG_FREESTYLE) {
        cout << "Warning: strip vertex " << k << " non valid after cleanup" << endl;
      }
      return;
    }
  }
}
 
// Vertex color (RGBA)
 
void Strip::setVertexColor(const vector<StrokeVertex *> &iStrokeVertices)
{
  vector<StrokeVertex *>::const_iterator v, vend;
  StrokeVertex *sv;
  int i = 0;
  for (v = iStrokeVertices.begin(), vend = iStrokeVertices.end(); v != vend; v++) {
    sv = (*v);
    _vertices[i]->setColor(Vec3r(sv->attribute().getColorRGB()));
    _vertices[i]->setAlpha(sv->attribute().getAlpha());
    i++;
    _vertices[i]->setColor(Vec3r(sv->attribute().getColorRGB()));
    _vertices[i]->setAlpha(sv->attribute().getAlpha());
    i++;
#if 0
    cerr << "col=(" << sv->attribute().getColor()[0] << ", " << sv->attribute().getColor()[1]
         << ", " << sv->attribute().getColor()[2] << ")" << endl;
#endif
  }
}
 
// Texture coordinates
 
void Strip::computeTexCoord(const vector<StrokeVertex *> &iStrokeVertices, float texStep)
{
  vector<StrokeVertex *>::const_iterator v, vend;
  StrokeVertex *sv;
  int i = 0;
  for (v = iStrokeVertices.begin(), vend = iStrokeVertices.end(); v != vend; v++) {
    sv = (*v);
    _vertices[i]->setTexCoord(
        Vec2r((real)(sv->curvilinearAbscissa() / (_averageThickness * texStep)), 0));
    i++;
    _vertices[i]->setTexCoord(
        Vec2r((real)(sv->curvilinearAbscissa() / (_averageThickness * texStep)), -1));
    i++;
  }
}
 
void Strip::computeTexCoordWithTips(const vector<StrokeVertex *> &iStrokeVertices,
                                    bool tipBegin,
                                    bool tipEnd,
                                    float texStep)
{
  vector<StrokeVertex *>::const_iterator v, vend;
  StrokeVertex *sv = nullptr;
  StrokeVertexRep *tvRep[2] = {nullptr};
 
  float l, fact, t;
  float u = 0, uPrev = 0;
  int tiles;
  int i = 0;
  float spacedThickness = _averageThickness * texStep;
 
  v = iStrokeVertices.begin();
  vend = iStrokeVertices.end();
  l = (*v)->strokeLength() / spacedThickness;
  tiles = std::roundf(l);  // round to the nearest
  fact = (float(tiles) + 0.5) / l;
 
#if 0
  cerr << "l=" << l << "  tiles=" << tiles << "    _averageThicnkess=" << _averageThickness
       << "    strokeLength=" << (*v)->strokeLength() << endl;
#endif
 
  vector<StrokeVertexRep *>::iterator currentSV = _vertices.begin();
  StrokeVertexRep *svRep;
  if (tipBegin) {
    for (; v != vend; v++) {
      sv = (*v);
      svRep = *currentSV;
      u = sv->curvilinearAbscissa() / spacedThickness * fact;
      if (u > 0.25) {
        break;
      }
 
      svRep->setTexCoord(Vec2r((real)u, -0.5), true);
      i++;
      ++currentSV;
 
      svRep = *currentSV;
      svRep->setTexCoord(Vec2r((real)u, -1), true);
      i++;
      ++currentSV;
      uPrev = u;
    }
 
    if (v != vend && i >= 2) {
      // first transition vertex
      if (fabs(u - uPrev) > ZERO) {
        t = (0.25 - uPrev) / (u - uPrev);
      }
      else {
        t = 0;
      }
      for (int k = 0; k < 2; k++) {
        tvRep[k] = new StrokeVertexRep((1 - t) * _vertices[i - 2]->point2d() +
                                       t * _vertices[i]->point2d());
        tvRep[k]->setTexCoord((1 - t) * _vertices[i - 2]->texCoord() +
                              t * _vertices[i]->texCoord());
        // v coord is -0.5 for tvRep[0], -1.0 for tvRep[1]
        tvRep[k]->setTexCoord(Vec2r(0.25, -0.5 * (k + 1)), true);
        tvRep[k]->setColor((1 - t) * _vertices[i - 2]->color() +
                           t * Vec3r(sv->attribute().getColorRGB()));
        tvRep[k]->setAlpha((1 - t) * _vertices[i - 2]->alpha() + t * sv->attribute().getAlpha());
        i++;
      }
      for (int k = 0; k < 2; k++) {
        currentSV = _vertices.insert(currentSV, tvRep[k]);
        ++currentSV;
      }
 
      // copy the vertices with different texture coordinates
      for (int k = 0; k < 2; k++) {
        tvRep[k] = new StrokeVertexRep(*(_vertices[i - 2]));
        // v coord is 0.0 for tvRep[0], -0.5 for tvRep[1]
        tvRep[k]->setTexCoord(Vec2r(0.0, -0.5 * k), true);
        i++;
      }
      for (int k = 0; k < 2; k++) {
        currentSV = _vertices.insert(currentSV, tvRep[k]);
        ++currentSV;
      }
    }
  }
  uPrev = 0;
 
  // body of the stroke
  for (; v != vend; v++) {
    sv = (*v);
    svRep = *currentSV;
    u = sv->curvilinearAbscissa() / spacedThickness * fact - 0.25;
    if (u > tiles) {
      break;
    }
 
    svRep->setTexCoord(Vec2r((real)u, 0), true);
    i++;
    ++currentSV;
 
    svRep = *currentSV;
    svRep->setTexCoord(Vec2r((real)u, -0.5), true);
    i++;
    ++currentSV;
 
    uPrev = u;
  }
 
  if (tipEnd) {
    if (v != vend && i >= 2) {
      // second transition vertex
      if (fabs(u - uPrev) > ZERO) {
        t = (float(tiles) - uPrev) / (u - uPrev);
      }
      else {
        t = 0;
      }
      for (int k = 0; k < 2; k++) {
        tvRep[k] = new StrokeVertexRep((1 - t) * _vertices[i - 2]->point2d() +
                                       t * _vertices[i]->point2d());
        tvRep[k]->setTexCoord((1 - t) * _vertices[i - 2]->texCoord() +
                              t * _vertices[i]->texCoord());
        // v coord is 0.0 for tvRep[0], -0.5 for tvRep[1]
        tvRep[k]->setTexCoord(Vec2r((real)tiles, -0.5 * k), true);
        tvRep[k]->setColor((1 - t) * _vertices[i - 2]->color() +
                           t * Vec3r(sv->attribute().getColorRGB()));
        tvRep[k]->setAlpha((1 - t) * _vertices[i - 2]->alpha() + t * sv->attribute().getAlpha());
        i++;
      }
      for (int k = 0; k < 2; k++) {
        currentSV = _vertices.insert(currentSV, tvRep[k]);
        ++currentSV;
      }
 
      // copy the vertices with different texture coordinates
      for (int k = 0; k < 2; k++) {
        tvRep[k] = new StrokeVertexRep(*(_vertices[i - 2]));
        // v coord is -0.5 for tvRep[0], -1.0 for tvRep[1]
        tvRep[k]->setTexCoord(Vec2r(0.75, -0.5 * (k + 1)), true);
        i++;
      }
      for (int k = 0; k < 2; k++) {
        currentSV = _vertices.insert(currentSV, tvRep[k]);
        ++currentSV;
      }
    }
 
    // end tip
    for (; v != vend; v++) {
      sv = (*v);
      svRep = *currentSV;
      u = 0.75 + sv->curvilinearAbscissa() / spacedThickness * fact - float(tiles) - 0.25;
 
      svRep->setTexCoord(Vec2r((real)u, -0.5), true);
      i++;
      ++currentSV;
 
      svRep = *currentSV;
      svRep->setTexCoord(Vec2r((real)u, -1), true);
      i++;
      ++currentSV;
    }
  }
 
#if 0
  cerr << "u=" << u << "    i=" << i << "/" << _sizeStrip << endl;
 
  for (i = 0; i < _sizeStrip; i++) {
    _alpha[i] = 1.0;
  }
 
  for (i = 0; i < _sizeStrip; i++) {
    cerr << "(" << _texCoord[i][0] << ", " << _texCoord[i][1] << ") ";
  }
  cerr << endl;
 
  Vec2r vec_tmp;
  for (i = 0; i < _sizeStrip / 2; i++) {
    vec_tmp = _vertex[2 * i] - _vertex[2 * i + 1];
  }
  if (vec_tmp.norm() > 4 * _averageThickness) {
    cerr << "Warning (from Fredo): There is a pb in the texture coordinates computation" << endl;
  }
#endif
}
 
//
// StrokeRep
 
StrokeRep::StrokeRep()
{
  _stroke = nullptr;
  _strokeType = Stroke::OPAQUE_MEDIUM;
  _nodeTree = nullptr;
  _hasTex = false;
  _textureStep = 1.0;
  for (int a = 0; a < MAX_MTEX; a++) {
    _mtex[a] = nullptr;
  }
  TextureManager *ptm = TextureManager::getInstance();
  if (ptm) {
    _textureId = ptm->getDefaultTextureId();
  }
#if 0
  _averageTextureAlpha = 0.5;  // default value
  if (_strokeType == OIL_STROKE) {
    _averageTextureAlpha = 0.75;
  }
  if (_strokeType >= NO_BLEND_STROKE) {
    _averageTextureAlpha = 1.0;
  }
#endif
}
 
StrokeRep::StrokeRep(Stroke *iStroke)
{
  _stroke = iStroke;
  _strokeType = iStroke->getMediumType();
  _nodeTree = iStroke->getNodeTree();
  _hasTex = iStroke->hasTex();
  _textureId = iStroke->getTextureId();
  _textureStep = iStroke->getTextureStep();
  for (int a = 0; a < MAX_MTEX; a++) {
    if (iStroke->getMTex(a)) {
      _mtex[a] = iStroke->getMTex(a);
    }
    else {
      _mtex[a] = nullptr;
    }
  }
  if (_textureId == 0) {
    TextureManager *ptm = TextureManager::getInstance();
    if (ptm) {
      _textureId = ptm->getDefaultTextureId();
    }
  }
 
#if 0
  _averageTextureAlpha = 0.5;  // default value
  if (_strokeType == OIL_STROKE) {
    _averageTextureAlpha = 0.75;
  }
  if (_strokeType >= NO_BLEND_STROKE) {
    _averageTextureAlpha = 1.0;
  }
#endif
  create();
}
 
StrokeRep::StrokeRep(const StrokeRep &iBrother)
{
  // soc unused - int i = 0;
  _stroke = iBrother._stroke;
  _strokeType = iBrother._strokeType;
  _textureId = iBrother._textureId;
  _textureStep = iBrother._textureStep;
  _nodeTree = iBrother._nodeTree;
  _hasTex = iBrother._hasTex;
  for (int a = 0; a < MAX_MTEX; a++) {
    if (iBrother._mtex[a]) {
      _mtex[a] = iBrother._mtex[a];
    }
    else {
      _mtex[a] = nullptr;
    }
  }
  for (vector<Strip *>::const_iterator s = iBrother._strips.begin(), send = iBrother._strips.end();
       s != send;
       ++s)
  {
    _strips.push_back(new Strip(**s));
  }
}
 
StrokeRep::~StrokeRep()
{
  if (!_strips.empty()) {
    for (vector<Strip *>::iterator s = _strips.begin(), send = _strips.end(); s != send; ++s) {
      delete (*s);
    }
    _strips.clear();
  }
}
 
void StrokeRep::create()
{
  vector<StrokeVertex *> strip;
  StrokeInternal::StrokeVertexIterator v = _stroke->strokeVerticesBegin();
  StrokeInternal::StrokeVertexIterator vend = _stroke->strokeVerticesEnd();
 
  bool first = true;
  bool end = false;
  while (v != vend) {
    while ((v != vend) && !(*v).attribute().isVisible()) {
      ++v;
      first = false;
    }
    while ((v != vend) && (*v).attribute().isVisible()) {
      strip.push_back(&(*v));
      ++v;
    }
    if (v != vend) {
      // add the last vertex and create
      strip.push_back(&(*v));
    }
    else {
      end = true;
    }
    if (!strip.empty() && (strip.size() > 1)) {
      _strips.push_back(new Strip(strip, _hasTex, first, end, _textureStep));
      strip.clear();
    }
    first = false;
  }
}
 
void StrokeRep::Render(const StrokeRenderer *iRenderer)
{
  iRenderer->RenderStrokeRep(this);
}
 
} /* namespace Freestyle */