Curve.h

Go to the documentation of this file.

/* SPDX-FileCopyrightText: 2023 Blender Authors
 *
 * SPDX-License-Identifier: GPL-2.0-or-later */
 
#pragma once

 
#include <deque>
 
#include "../geometry/Geom.h"
 
// #include "../scene_graph/FrsMaterial.h"
 
#include "../view_map/Interface0D.h"
#include "../view_map/Interface1D.h"
#include "../view_map/Silhouette.h"
#include "../view_map/SilhouetteGeomEngine.h"
 
#include "../system/BaseIterator.h"
 
#include "MEM_guardedalloc.h"
 
using namespace std;
 
namespace Freestyle {
 
using namespace Geometry;
 
/**********************************/
/*                                */
/*                                */
/*             CurvePoint         */
/*                                */
/*                                */
/**********************************/

class CurvePoint : public Interface0D {
 public:  // Implementation of Interface0D
  virtual string getExactTypeName() const
  {
    return "CurvePoint";
  }
 
  // Data access methods
  virtual real getX() const
  {
    return _Point3d.x();
  }

  virtual real getY() const
  {
    return _Point3d.y();
  }

  virtual real getZ() const
  {
    return _Point3d.z();
  }

  virtual Vec3r getPoint3D() const
  {
    return _Point3d;
  }

  virtual real getProjectedX() const
  {
    return _Point2d.x();
  }

  virtual real getProjectedY() const
  {
    return _Point2d.y();
  }

  virtual real getProjectedZ() const
  {
    return _Point2d.z();
  }

  virtual Vec2r getPoint2D() const
  {
    return Vec2r(_Point2d.x(), _Point2d.y());
  }
 
  virtual FEdge *getFEdge(Interface0D &inter);

  virtual Id getId() const
  {
    Id id;
    if (_t2d == 0) {
      return __A->getId();
    }
    else if (_t2d == 1) {
      return __B->getId();
    }
    return id;
  }

  virtual Nature::VertexNature getNature() const
  {
    Nature::VertexNature nature = Nature::POINT;
    if (_t2d == 0) {
      nature |= __A->getNature();
    }
    else if (_t2d == 1) {
      nature |= __B->getNature();
    }
    return nature;
  }

  virtual SVertex *castToSVertex()
  {
    if (_t2d == 0) {
      return __A;
    }
    else if (_t2d == 1) {
      return __B;
    }
    return Interface0D::castToSVertex();
  }

  virtual ViewVertex *castToViewVertex()
  {
    if (_t2d == 0) {
      return __A->castToViewVertex();
    }
    else if (_t2d == 1) {
      return __B->castToViewVertex();
    }
    return Interface0D::castToViewVertex();
  }

  virtual NonTVertex *castToNonTVertex()
  {
    if (_t2d == 0) {
      return __A->castToNonTVertex();
    }
    else if (_t2d == 1) {
      return __B->castToNonTVertex();
    }
    return Interface0D::castToNonTVertex();
  }

  virtual TVertex *castToTVertex()
  {
    if (_t2d == 0) {
      return __A->castToTVertex();
    }
    else if (_t2d == 1) {
      return __B->castToTVertex();
    }
    return Interface0D::castToTVertex();
  }
 
 public:
  typedef SVertex vertex_type;
 
 protected:
  SVertex *__A;
  SVertex *__B;
  float _t2d;
  // float _t3d;
  Vec3r _Point2d;
  Vec3r _Point3d;
 
 public:
  CurvePoint();

  CurvePoint(SVertex *iA, SVertex *iB, float t);

  CurvePoint(CurvePoint *iA, CurvePoint *iB, float t);
 
  // CurvePoint(SVertex *iA, SVertex *iB, float t2d, float t3d);

  CurvePoint(const CurvePoint &iBrother);

  CurvePoint &operator=(const CurvePoint &iBrother);

  virtual ~CurvePoint() = default;

  bool operator==(const CurvePoint &b)
  {
    return ((__A == b.__A) && (__B == b.__B) && (_t2d == b._t2d));
  }
 
  /* accessors */
  inline SVertex *A()
  {
    return __A;
  }

  inline SVertex *B()
  {
    return __B;
  }

  inline float t2d() const
  {
    return _t2d;
  }
 
#if 0
  inline const float t3d() const
  {
    return _t3d;
  }
#endif
 
  /* modifiers */
  inline void setA(SVertex *iA)
  {
    __A = iA;
  }

  inline void setB(SVertex *iB)
  {
    __B = iB;
  }

  inline void setT2d(float t)
  {
    _t2d = t;
  }
 
#if 0
  inline void SetT3d(float t)
  {
    _t3d = t;
  }
#endif
 
  /* Information access interface */
 
  FEdge *fedge();
 
  inline const Vec3r &point2d() const
  {
    return _Point2d;
  }
 
  inline const Vec3r &point3d() const
  {
    return _Point3d;
  }
 
  Vec3r normal() const;
  // FrsMaterial material() const;
  // Id shape_id() const;
  const SShape *shape() const;
  // float shape_importance() const;
 
  // const uint qi() const;
  occluder_container::const_iterator occluders_begin() const;
  occluder_container::const_iterator occluders_end() const;
  bool occluders_empty() const;
  int occluders_size() const;
  const Polygon3r &occludee() const;
  const SShape *occluded_shape() const;
  bool occludee_empty() const;
  real z_discontinuity() const;
#if 0
  float local_average_depth() const;
  float local_depth_variance() const;
  real local_average_density(float sigma = 2.3f) const;
  Vec3r shaded_color() const;
  Vec3r orientation2d() const;
  Vec3r orientation3d() const;
 
  real curvature2d() const
  {
    return viewedge()->curvature2d((_VertexA->point2d() + _VertexB->point2d()) / 2.0);
  }
 
  Vec3r curvature2d_as_vector() const;
  real curvature2d_as_angle() const;
 
  real curvatureFredo() const;
  Vec2d directionFredo() const;
#endif
 
  MEM_CXX_CLASS_ALLOC_FUNCS("Freestyle:CurvePoint")
};
 
/**********************************/
/*                                */
/*                                */
/*             Curve              */
/*                                */
/*                                */
/**********************************/
 
namespace CurveInternal {
 
class CurvePoint_const_traits;
class CurvePoint_nonconst_traits;
template<class Traits> class __point_iterator;
class CurvePointIterator;
 
}  // end of namespace CurveInternal

class Curve : public Interface1D {
 public:
  typedef CurvePoint Vertex;
  typedef CurvePoint Point;
  typedef Point point_type;
  typedef Vertex vertex_type;
  typedef deque<Vertex *> vertex_container;
 
  /* Iterator to iterate over a vertex edges */
 
  typedef CurveInternal::__point_iterator<CurveInternal::CurvePoint_nonconst_traits>
      point_iterator;
  typedef CurveInternal::__point_iterator<CurveInternal::CurvePoint_const_traits>
      const_point_iterator;
  typedef point_iterator vertex_iterator;
  typedef const_point_iterator const_vertex_iterator;
 
 protected:
  vertex_container _Vertices;
  double _Length;
  Id _Id;
  uint _nSegments;  // number of segments
 
 public:
  Curve()
  {
    _Length = 0;
    _Id = 0;
    _nSegments = 0;
  }

  Curve(const Id &id)
  {
    _Length = 0;
    _Id = id;
    _nSegments = 0;
  }

  Curve(const Curve &iBrother)
  {
    _Length = iBrother._Length;
    _Vertices = iBrother._Vertices;
    _Id = iBrother._Id;
    _nSegments = 0;
  }

  virtual ~Curve();

  virtual string getExactTypeName() const
  {
    return "Curve";
  }
 
#if 0
  /* fredo's curvature storage */
  void computeCurvatureAndOrientation();
#endif

  inline void push_vertex_back(Vertex *iVertex)
  {
    if (!_Vertices.empty()) {
      Vec3r vec_tmp(iVertex->point2d() - _Vertices.back()->point2d());
      _Length += vec_tmp.norm();
      ++_nSegments;
    }
    Vertex *new_vertex = new Vertex(*iVertex);
    _Vertices.push_back(new_vertex);
  }

  inline void push_vertex_back(SVertex *iVertex)
  {
    if (!_Vertices.empty()) {
      Vec3r vec_tmp(iVertex->point2d() - _Vertices.back()->point2d());
      _Length += vec_tmp.norm();
      ++_nSegments;
    }
    Vertex *new_vertex = new Vertex(iVertex, 0, 0);
    _Vertices.push_back(new_vertex);
  }

  inline void push_vertex_front(Vertex *iVertex)
  {
    if (!_Vertices.empty()) {
      Vec3r vec_tmp(iVertex->point2d() - _Vertices.front()->point2d());
      _Length += vec_tmp.norm();
      ++_nSegments;
    }
    Vertex *new_vertex = new Vertex(*iVertex);
    _Vertices.push_front(new_vertex);
  }

  inline void push_vertex_front(SVertex *iVertex)
  {
    if (!_Vertices.empty()) {
      Vec3r vec_tmp(iVertex->point2d() - _Vertices.front()->point2d());
      _Length += vec_tmp.norm();
      ++_nSegments;
    }
    Vertex *new_vertex = new Vertex(iVertex, 0, 0);
    _Vertices.push_front(new_vertex);
  }

  inline bool empty() const
  {
    return _Vertices.empty();
  }

  inline real getLength2D() const
  {
    return _Length;
  }

  virtual Id getId() const
  {
    return _Id;
  }

  inline uint nSegments() const
  {
    return _nSegments;
  }
 
  inline void setId(const Id &id)
  {
    _Id = id;
  }
 
  /* Information access interface */
 
#if 0
  inline Vec3r shaded_color(int iCombination = 0) const;
  inline Vec3r orientation2d(point_iterator it) const;
  Vec3r orientation2d(int iCombination = 0) const;
  Vec3r orientation3d(point_iterator it) const;
  Vec3r orientation3d(int iCombination = 0) const;
 
  real curvature2d(point_iterator it) const
  {
    return (*it)->curvature2d();
  }
 
  real curvature2d(int iCombination = 0) const;
  FrsMaterial material() const;
  int qi() const;
  occluder_container::const_iterator occluders_begin() const;
  occluder_container::const_iterator occluders_end() const;
  int occluders_size() const;
  bool occluders_empty() const;
 
  const Polygon3r &occludee() const
  {
    return *(_FEdgeA->aFace());
  }
 
  const SShape *occluded_shape() const;
  bool occludee_empty() const;
  real z_discontinuity(int iCombination = 0) const;
  int shape_id() const;
  const SShape *shape() const;
  float shape_importance(int iCombination = 0) const;
  float local_average_depth(int iCombination = 0) const;
  float local_depth_variance(int iCombination = 0) const;
  real local_average_density(float sigma = 2.3f, int iCombination = 0) const;
  Vec3r curvature2d_as_vector(int iCombination = 0) const;
  real curvature2d_as_angle(int iCombination = 0) const;
#endif
 
  /* advanced iterators access */
  point_iterator points_begin(float step = 0);
  const_point_iterator points_begin(float step = 0) const;
  point_iterator points_end(float step = 0);
  const_point_iterator points_end(float step = 0) const;
 
  /* methods given for convenience */
  point_iterator vertices_begin();
  const_point_iterator vertices_begin() const;
  point_iterator vertices_end();
  const_point_iterator vertices_end() const;
 
  // specialized iterators access
  CurveInternal::CurvePointIterator curvePointsBegin(float t = 0.0f);
  CurveInternal::CurvePointIterator curvePointsEnd(float t = 0.0f);
 
  CurveInternal::CurvePointIterator curveVerticesBegin();
  CurveInternal::CurvePointIterator curveVerticesEnd();
 
  // Iterators access
  virtual Interface0DIterator verticesBegin();

  virtual Interface0DIterator verticesEnd();

  virtual Interface0DIterator pointsBegin(float t = 0.0f);

  virtual Interface0DIterator pointsEnd(float t = 0.0f);
 
  MEM_CXX_CLASS_ALLOC_FUNCS("Freestyle:Curve")
};
 
} /* namespace Freestyle */