Cleanup: comments (long lines) in freestyle
authorCampbell Barton <ideasman42@gmail.com>
Tue, 30 Apr 2019 07:50:57 +0000 (17:50 +1000)
committerCampbell Barton <ideasman42@gmail.com>
Tue, 30 Apr 2019 21:58:27 +0000 (07:58 +1000)
145 files changed:
source/blender/freestyle/intern/application/AppView.h
source/blender/freestyle/intern/application/Controller.cpp
source/blender/freestyle/intern/application/Controller.h
source/blender/freestyle/intern/blender_interface/FRS_freestyle.cpp
source/blender/freestyle/intern/geometry/FastGrid.h
source/blender/freestyle/intern/geometry/FitCurve.cpp
source/blender/freestyle/intern/geometry/GeomCleaner.h
source/blender/freestyle/intern/geometry/GeomUtils.cpp
source/blender/freestyle/intern/geometry/GeomUtils.h
source/blender/freestyle/intern/geometry/Grid.cpp
source/blender/freestyle/intern/geometry/Grid.h
source/blender/freestyle/intern/geometry/GridHelpers.cpp
source/blender/freestyle/intern/geometry/GridHelpers.h
source/blender/freestyle/intern/geometry/SweepLine.h
source/blender/freestyle/intern/image/GaussianFilter.h
source/blender/freestyle/intern/image/Image.h
source/blender/freestyle/intern/image/ImagePyramid.cpp
source/blender/freestyle/intern/image/ImagePyramid.h
source/blender/freestyle/intern/python/BinaryPredicate1D/BPy_ViewMapGradientNormBP1D.cpp
source/blender/freestyle/intern/python/Interface0D/BPy_CurvePoint.cpp
source/blender/freestyle/intern/python/Iterator/BPy_ChainPredicateIterator.cpp
source/blender/freestyle/intern/python/Iterator/BPy_ChainSilhouetteIterator.cpp
source/blender/freestyle/intern/python/Iterator/BPy_orientedViewEdgeIterator.cpp
source/blender/freestyle/intern/python/StrokeShader/BPy_BackboneStretcherShader.cpp
source/blender/freestyle/intern/python/StrokeShader/BPy_CalligraphicShader.h
source/blender/freestyle/intern/python/StrokeShader/BPy_ConstantThicknessShader.cpp
source/blender/freestyle/intern/python/StrokeShader/BPy_ConstrainedIncreasingThicknessShader.cpp
source/blender/freestyle/intern/python/StrokeShader/BPy_ConstrainedIncreasingThicknessShader.h
source/blender/freestyle/intern/python/StrokeShader/BPy_IncreasingThicknessShader.cpp
source/blender/freestyle/intern/python/StrokeShader/BPy_PolygonalizationShader.cpp
source/blender/freestyle/intern/python/StrokeShader/BPy_StrokeTextureStepShader.cpp
source/blender/freestyle/intern/python/UnaryFunction0D/BPy_UnaryFunction0DEdgeNature.cpp
source/blender/freestyle/intern/python/UnaryFunction0D/BPy_UnaryFunction0DMaterial.cpp
source/blender/freestyle/intern/python/UnaryFunction0D/BPy_UnaryFunction0DUnsigned.cpp
source/blender/freestyle/intern/python/UnaryFunction0D/BPy_UnaryFunction0DVectorViewShape.cpp
source/blender/freestyle/intern/python/UnaryFunction0D/BPy_UnaryFunction0DVectorViewShape.h
source/blender/freestyle/intern/python/UnaryFunction0D/BPy_UnaryFunction0DViewShape.cpp
source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_Vec2f/BPy_VertexOrientation2DF0D.cpp
source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_Vec3f/BPy_VertexOrientation3DF0D.cpp
source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_float/BPy_GetCurvilinearAbscissaF0D.cpp
source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_float/BPy_GetViewMapGradientNormF0D.cpp
source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_float/BPy_ReadCompleteViewMapPixelF0D.cpp
source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_float/BPy_ReadCompleteViewMapPixelF0D.h
source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_float/BPy_ReadSteerableViewMapPixelF0D.cpp
source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_float/BPy_ReadSteerableViewMapPixelF0D.h
source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_unsigned_int/BPy_QuantitativeInvisibilityF0D.cpp
source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_unsigned_int/BPy_QuantitativeInvisibilityF0D.h
source/blender/freestyle/intern/python/UnaryFunction1D/BPy_UnaryFunction1DEdgeNature.cpp
source/blender/freestyle/intern/python/UnaryFunction1D/BPy_UnaryFunction1DUnsigned.cpp
source/blender/freestyle/intern/python/UnaryFunction1D/BPy_UnaryFunction1DVectorViewShape.cpp
source/blender/freestyle/intern/python/UnaryFunction1D/BPy_UnaryFunction1DVectorViewShape.h
source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/BPy_GetCompleteViewMapDensityF1D.cpp
source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/BPy_GetCompleteViewMapDensityF1D.h
source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/BPy_GetDirectionalViewMapDensityF1D.cpp
source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/BPy_GetDirectionalViewMapDensityF1D.h
source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/BPy_GetSteerableViewMapDensityF1D.cpp
source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/BPy_GetSteerableViewMapDensityF1D.h
source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/BPy_GetViewMapGradientNormF1D.cpp
source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_unsigned_int/BPy_QuantitativeInvisibilityF1D.cpp
source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_unsigned_int/BPy_QuantitativeInvisibilityF1D.h
source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_void/BPy_IncrementChainingTimeStampF1D.cpp
source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_void/BPy_IncrementChainingTimeStampF1D.h
source/blender/freestyle/intern/python/UnaryPredicate1D/BPy_EqualToChainingTimeStampUP1D.cpp
source/blender/freestyle/intern/python/UnaryPredicate1D/BPy_EqualToChainingTimeStampUP1D.h
source/blender/freestyle/intern/python/UnaryPredicate1D/BPy_QuantitativeInvisibilityUP1D.cpp
source/blender/freestyle/intern/python/UnaryPredicate1D/BPy_QuantitativeInvisibilityUP1D.h
source/blender/freestyle/intern/scene_graph/IndexedFaceSet.h
source/blender/freestyle/intern/scene_graph/Node.h
source/blender/freestyle/intern/scene_graph/NodeDrawingStyle.cpp
source/blender/freestyle/intern/scene_graph/NodeDrawingStyle.h
source/blender/freestyle/intern/scene_graph/NodeGroup.cpp
source/blender/freestyle/intern/scene_graph/NodeGroup.h
source/blender/freestyle/intern/scene_graph/NodeTransform.cpp
source/blender/freestyle/intern/scene_graph/Rep.cpp
source/blender/freestyle/intern/scene_graph/Rep.h
source/blender/freestyle/intern/stroke/AdvancedFunctions0D.h
source/blender/freestyle/intern/stroke/AdvancedFunctions1D.cpp
source/blender/freestyle/intern/stroke/AdvancedFunctions1D.h
source/blender/freestyle/intern/stroke/AdvancedStrokeShaders.cpp
source/blender/freestyle/intern/stroke/AdvancedStrokeShaders.h
source/blender/freestyle/intern/stroke/BasicStrokeShaders.cpp
source/blender/freestyle/intern/stroke/BasicStrokeShaders.h
source/blender/freestyle/intern/stroke/Canvas.cpp
source/blender/freestyle/intern/stroke/Canvas.h
source/blender/freestyle/intern/stroke/Chain.cpp
source/blender/freestyle/intern/stroke/ChainingIterators.cpp
source/blender/freestyle/intern/stroke/ChainingIterators.h
source/blender/freestyle/intern/stroke/Curve.cpp
source/blender/freestyle/intern/stroke/Curve.h
source/blender/freestyle/intern/stroke/CurveAdvancedIterators.h
source/blender/freestyle/intern/stroke/CurveIterators.h
source/blender/freestyle/intern/stroke/Operators.cpp
source/blender/freestyle/intern/stroke/Operators.h
source/blender/freestyle/intern/stroke/PSStrokeRenderer.cpp
source/blender/freestyle/intern/stroke/Predicates0D.h
source/blender/freestyle/intern/stroke/Predicates1D.h
source/blender/freestyle/intern/stroke/QInformationMap.h
source/blender/freestyle/intern/stroke/Stroke.cpp
source/blender/freestyle/intern/stroke/Stroke.h
source/blender/freestyle/intern/stroke/StrokeAdvancedIterators.h
source/blender/freestyle/intern/stroke/StrokeIterators.h
source/blender/freestyle/intern/stroke/StrokeRenderer.h
source/blender/freestyle/intern/stroke/StrokeRep.cpp
source/blender/freestyle/intern/stroke/StrokeShader.h
source/blender/freestyle/intern/stroke/StrokeTesselator.cpp
source/blender/freestyle/intern/system/PointerSequence.h
source/blender/freestyle/intern/system/PythonInterpreter.h
source/blender/freestyle/intern/system/StringUtils.cpp
source/blender/freestyle/intern/view_map/BoxGrid.h
source/blender/freestyle/intern/view_map/CulledOccluderSource.cpp
source/blender/freestyle/intern/view_map/FEdgeXDetector.cpp
source/blender/freestyle/intern/view_map/FEdgeXDetector.h
source/blender/freestyle/intern/view_map/Functions0D.cpp
source/blender/freestyle/intern/view_map/Functions0D.h
source/blender/freestyle/intern/view_map/Functions1D.h
source/blender/freestyle/intern/view_map/GridDensityProvider.h
source/blender/freestyle/intern/view_map/Interface0D.h
source/blender/freestyle/intern/view_map/Interface1D.h
source/blender/freestyle/intern/view_map/Silhouette.cpp
source/blender/freestyle/intern/view_map/Silhouette.h
source/blender/freestyle/intern/view_map/SilhouetteGeomEngine.cpp
source/blender/freestyle/intern/view_map/SilhouetteGeomEngine.h
source/blender/freestyle/intern/view_map/SphericalGrid.cpp
source/blender/freestyle/intern/view_map/SphericalGrid.h
source/blender/freestyle/intern/view_map/SteerableViewMap.cpp
source/blender/freestyle/intern/view_map/SteerableViewMap.h
source/blender/freestyle/intern/view_map/ViewEdgeXBuilder.cpp
source/blender/freestyle/intern/view_map/ViewEdgeXBuilder.h
source/blender/freestyle/intern/view_map/ViewMap.cpp
source/blender/freestyle/intern/view_map/ViewMap.h
source/blender/freestyle/intern/view_map/ViewMapAdvancedIterators.h
source/blender/freestyle/intern/view_map/ViewMapBuilder.cpp
source/blender/freestyle/intern/view_map/ViewMapBuilder.h
source/blender/freestyle/intern/view_map/ViewMapIO.cpp
source/blender/freestyle/intern/view_map/ViewMapIterators.h
source/blender/freestyle/intern/view_map/ViewMapTesselator.h
source/blender/freestyle/intern/winged_edge/Curvature.cpp
source/blender/freestyle/intern/winged_edge/WEdge.cpp
source/blender/freestyle/intern/winged_edge/WEdge.h
source/blender/freestyle/intern/winged_edge/WXEdge.cpp
source/blender/freestyle/intern/winged_edge/WXEdge.h
source/blender/freestyle/intern/winged_edge/WXEdgeBuilder.cpp
source/blender/freestyle/intern/winged_edge/WXEdgeBuilder.h
source/blender/freestyle/intern/winged_edge/WingedEdgeBuilder.cpp
source/blender/freestyle/intern/winged_edge/WingedEdgeBuilder.h

index 0b02989..deb0993 100644 (file)
@@ -43,7 +43,7 @@ class AppView {
   virtual ~AppView();
 
  public:
-  //inherited
+  // inherited
   inline unsigned int width()
   {
     return _width;
@@ -246,7 +246,7 @@ class AppView {
  protected:
   float _Fovy;
 
-  //The root node container
+  // The root node container
   NodeGroup _RootNode;
   NodeDrawingStyle *_ModelRootNode;
   NodeDrawingStyle *_SilhouetteRootNode;
index d516b86..4d5ffda 100644 (file)
@@ -179,7 +179,7 @@ Controller::~Controller()
     _ProgressBar = NULL;
   }
 
-  //delete _current_dirs;
+  // delete _current_dirs;
 }
 
 void Controller::setView(AppView *iView)
@@ -300,7 +300,7 @@ int Controller::LoadMesh(Render *re, ViewLayer *view_layer, Depsgraph *depsgraph
     _RootNode->AddChild(new NodeViewLayer(*re->scene, *view_layer));
 
     sceneHashFunc.reset();
-    //blenderScene->accept(sceneHashFunc);
+    // blenderScene->accept(sceneHashFunc);
     _RootNode->accept(sceneHashFunc);
     if (G.debug & G_DEBUG_FREESTYLE) {
       cout << "Scene hash       : " << sceneHashFunc.toString() << endl;
@@ -626,7 +626,7 @@ void Controller::ComputeViewMap()
 
 void Controller::ComputeSteerableViewMap()
 {
-#if 0  //soc
+#if 0  // soc
   if ((!_Canvas) || (!_ViewMap))
     return;
 
index b287a51..613ea2c 100644 (file)
@@ -58,7 +58,7 @@ class Controller {
   void setPassZ(float *buf, int width, int height);
   void setContext(bContext *C);
 
-  //soc
+  // soc
   void init_options();
 
   int LoadMesh(Render *re, ViewLayer *view_layer, Depsgraph *depsgraph);
@@ -175,15 +175,15 @@ class Controller {
 
  private:
   // Main Window:
-  //AppMainWindow *_pMainWindow;
+  // AppMainWindow *_pMainWindow;
 
   // List of models currently loaded
   vector<string> _ListOfModels;
 
   // Current directories
-  //ConfigIO* _current_dirs;
+  // ConfigIO* _current_dirs;
 
-  //View
+  // View
   // 3D
   AppView *_pView;
 
@@ -195,7 +195,7 @@ class Controller {
 
   RenderMonitor *_pRenderMonitor;
 
-  //Model
+  // Model
   // Drawing Structure
   NodeGroup *_RootNode;
 
@@ -217,7 +217,7 @@ class Controller {
 #endif
 
   // debug
-  //NodeUser<ViewMap> *_ViewMapNode; // FIXME
+  // NodeUser<ViewMap> *_ViewMapNode; // FIXME
 
   // Chronometer:
   Chronometer _Chrono;
@@ -229,7 +229,7 @@ class Controller {
   int _edgeTesselationNature;
 
   FastGrid _Grid;
-  //HashGrid _Grid;
+  // HashGrid _Grid;
 
   BBox<Vec3r> _Scene3dBBox;
   unsigned int _SceneNumFaces;
@@ -241,9 +241,9 @@ class Controller {
 
   int _render_count;
 
-  //AppStyleWindow *_pStyleWindow;
-  //AppOptionsWindow *_pOptionsWindow;
-  //AppDensityCurvesWindow *_pDensityCurvesWindow;
+  // AppStyleWindow *_pStyleWindow;
+  // AppOptionsWindow *_pOptionsWindow;
+  // AppDensityCurvesWindow *_pDensityCurvesWindow;
 
   ViewMapBuilder::visibility_algo _VisibilityAlgo;
 
index 63ff4cc..7ef3e23 100644 (file)
@@ -384,9 +384,10 @@ static void prepare(Render *re, ViewLayer *view_layer, Depsgraph *depsgraph)
             bool logical_and = ((lineset->flags & FREESTYLE_LINESET_FE_AND) != 0);
             // negation operator
             if (lineset->flags & FREESTYLE_LINESET_FE_NOT) {
-              // convert an Exclusive condition into an Inclusive equivalent using De Morgan's laws:
-              //   NOT (X OR Y) --> (NOT X) AND (NOT Y)
-              //   NOT (X AND Y) --> (NOT X) OR (NOT Y)
+              // convert an Exclusive condition into an
+              // Inclusive equivalent using De Morgan's laws:
+              // - NOT (X OR Y) --> (NOT X) AND (NOT Y)
+              // - NOT (X AND Y) --> (NOT X) OR (NOT Y)
               for (int i = 0; i < num_edge_types; i++)
                 conditions[i].value *= -1;
               logical_and = !logical_and;
index e2345d4..a3b2066 100644 (file)
@@ -28,7 +28,8 @@ namespace Freestyle {
 
 /*! Class to define a regular grid used for ray casting computations
  *  We don't use a hashtable here. The grid is explicitly stored for faster computations.
- *  However, this might result in significant increase in memory usage (compared to the regular grid)
+ *  However, this might result in significant increase in memory usage
+ *  (compared to the regular grid).
  */
 class FastGrid : public Grid {
  public:
@@ -43,8 +44,9 @@ class FastGrid : public Grid {
     clear();
   }
 
-  /*! clears the grid
-   *  Deletes all the cells, clears the hashtable, resets size, size of cell, number of cells.
+  /*!
+   * clears the grid
+   * Deletes all the cells, clears the hashtable, resets size, size of cell, number of cells.
    */
   virtual void clear();
 
index b040882..368c3d2 100644 (file)
@@ -181,8 +181,8 @@ static BezierCurve GenerateBezier(
   alpha_l = det_X_C1 / det_C0_C1;
   alpha_r = det_C0_X / det_C0_C1;
 
-  /* If alpha negative, use the Wu/Barsky heuristic (see text) (if alpha is 0, you get coincident control points
-   * that lead to divide by zero in any subsequent NewtonRaphsonRootFind() call).
+  /* If alpha negative, use the Wu/Barsky heuristic (see text) (if alpha is 0, you get coincident
+   * control points that lead to divide by zero in any subsequent NewtonRaphsonRootFind() call).
    */
   if (alpha_l < 1.0e-6 || alpha_r < 1.0e-6) {
     double dist = V2DistanceBetween2Points(&d[last], &d[first]) / 3.0;
@@ -194,8 +194,9 @@ static BezierCurve GenerateBezier(
     return bezCurve;
   }
 
-  /* First and last control points of the Bezier curve are positioned exactly at the first and last data points
-   * Control points 1 and 2 are positioned an alpha distance out on the tangent vectors, left and right, respectively
+  /* First and last control points of the Bezier curve are positioned exactly at the first and last
+   * data points Control points 1 and 2 are positioned an alpha distance out on the tangent
+   * vectors, left and right, respectively
    */
   bezCurve[0] = d[first];
   bezCurve[3] = d[last];
index 5fedf94..253d355 100644 (file)
@@ -45,20 +45,24 @@ class GeomCleaner {
 
   /*! Sorts an array of Indexed vertices
    *    iVertices
-   *      Array of vertices to sort. It is organized as a float series of vertex coordinates: XYZXYZXYZ...
+   *      Array of vertices to sort.
+   *      It is organized as a float series of vertex coordinates: XYZXYZXYZ...
    *    iVSize
    *      The size of iVertices array.
    *    iIndices
-   *      The array containing the vertex indices (used to refer to the vertex coordinates in an indexed face). Each
-   *      element is an unsignedeger multiple of 3.
+   *      The array containing the vertex indices
+   *      (used to refer to the vertex coordinates in an indexed face).
+   *      Each element is an unsignedeger multiple of 3.
    *    iISize
    *      The size of iIndices array
    *    oVertices
-   *      Output of sorted vertices. A vertex v1 precedes another one v2 in this array if v1.x<v2.x,
-   *      or v1.x=v2.x && v1.y < v2.y or v1.x=v2.y && v1.y=v2.y && v1.z < v2.z.
+   *      Output of sorted vertices.
+   *      A vertex v1 precedes another one v2 in this array
+   *      if v1.x<v2.x, or v1.x=v2.x && v1.y < v2.y or v1.x=v2.y && v1.y=v2.y && v1.z < v2.z.
    *      The array is organized as a 3-float serie giving the vertices coordinates: XYZXYZXYZ...
    *    oIndices
-   *      Output corresponding to the iIndices array but reorganized in order to match the sorted vertex array.
+   *      Output corresponding to the iIndices array but reorganized in
+   *      order to match the sorted vertex array.
    */
   static void SortIndexedVertexArray(const float *iVertices,
                                      unsigned iVSize,
@@ -67,13 +71,16 @@ class GeomCleaner {
                                      float **oVertices,
                                      unsigned **oIndices);
 
-  /*! Compress a SORTED indexed vertex array by eliminating multiple appearing occurences of a single vertex.
+  /*! Compress a SORTED indexed vertex array by eliminating multiple
+   *  appearing occurences of a single vertex.
    *    iVertices
-   *      The SORTED vertex array to compress. It is organized as a float series of vertex coordinates: XYZXYZXYZ...
+   *      The SORTED vertex array to compress.
+   *      It is organized as a float series of vertex coordinates: XYZXYZXYZ...
    *    iVSize
    *      The size of iVertices array.
    *    iIndices
-   *      The array containing the vertex indices (used to refer to the vertex coordinates in an indexed face).
+   *      The array containing the vertex indices
+   *      (used to refer to the vertex coordinates in an indexed face).
    *      Each element is an unsignedeger multiple of 3.
    *    iISize
    *      The size of iIndices array
@@ -100,7 +107,8 @@ class GeomCleaner {
    *    iVSize
    *      The size of iVertices array.
    *    iIndices
-   *      The array containing the vertex indices (used to refer to the vertex coordinates in an indexed face).
+   *      The array containing the vertex indices
+   *      (used to refer to the vertex coordinates in an indexed face).
    *      Each element is an unsignedeger multiple of 3.
    *    iISize
    *      The size of iIndices array
@@ -120,15 +128,16 @@ class GeomCleaner {
                                                 unsigned *oVSize,
                                                 unsigned **oIndices);
 
-  /*! Cleans an indexed vertex array. (Identical to SortAndCompress except that we use here a hash table
-   *  to create the new array.)
+  /*! Cleans an indexed vertex array.
+   *  (Identical to SortAndCompress except that we use here a hash table to create the new array.)
    *    iVertices
    *      The vertex array to sort then compress. It is organized as a float series of
    *      vertex coordinates: XYZXYZXYZ...
    *    iVSize
    *      The size of iVertices array.
    *    iIndices
-   *      The array containing the vertex indices (used to refer to the vertex coordinates in an indexed face).
+   *      The array containing the vertex indices
+   *      (used to refer to the vertex coordinates in an indexed face).
    *      Each element is an unsignedeger multiple of 3.
    *    iISize
    *      The size of iIndices array
@@ -154,9 +163,10 @@ class GeomCleaner {
 };
 
 /*! Binary operators */
-//inline bool operator<(const IndexedVertex& iv1, const IndexedVertex& iv2);
+// inline bool operator<(const IndexedVertex& iv1, const IndexedVertex& iv2);
 
-/*! Class Indexed Vertex. Used to represent an indexed vertex by storing the vertex coordinates as well as its index */
+/*! Class Indexed Vertex. Used to represent an indexed vertex by storing the vertex coordinates as
+ * well as its index */
 class IndexedVertex {
  private:
   Vec3f _Vector;
@@ -223,7 +233,7 @@ class IndexedVertex {
     return _Vector[i];
   }
 
-  //friend inline bool operator<(const IndexedVertex& iv1, const IndexedVertex& iv2);
+  // friend inline bool operator<(const IndexedVertex& iv1, const IndexedVertex& iv2);
   inline bool operator<(const IndexedVertex &v) const
   {
     return (_Vector < v._Vector);
index 2ac8352..bec6ed2 100644 (file)
@@ -88,8 +88,8 @@ intersection_test intersect2dSeg2dSeg(
   r1 = a2 * p1[0] + b2 * p1[1] + c2;
   r2 = a2 * p2[0] + b2 * p2[1] + c2;
 
-  // Check signs of r1 and r2.  If both point 1 and point 2 lie on same side of second line segment,
-  // the line segments do not intersect.
+  // Check signs of r1 and r2.  If both point 1 and point 2 lie on same side of second line
+  // segment, the line segments do not intersect.
   if (r1 != 0 && r2 != 0 && r1 * r2 > 0.0)
     return (DONT_INTERSECT);
 
@@ -172,8 +172,8 @@ intersection_test intersect2dSeg2dSegParametric(const Vec2r &p1,
   r1 = a2 * p1[0] + b2 * p1[1] + c2;
   r2 = a2 * p2[0] + b2 * p2[1] + c2;
 
-  // Check signs of r1 and r2.  If both point 1 and point 2 lie on same side of second line segment,
-  // the line segments do not intersect.
+  // Check signs of r1 and r2.  If both point 1 and point 2 lie on same side of second line
+  // segment, the line segments do not intersect.
   if (r1 != 0 && r2 != 0 && r1 * r2 > 0.0)
     return (DONT_INTERSECT);
 
@@ -202,8 +202,8 @@ intersection_test intersect2dSeg2dSegParametric(const Vec2r &p1,
 //   2001-03-05: released the code in its first version
 //   2001-06-18: changed the order of the tests, faster
 //
-// Acknowledgement: Many thanks to Pierre Terdiman for suggestions and discussions on how to optimize code.
-// Thanks to David Hunt for finding a ">="-bug!
+// Acknowledgement: Many thanks to Pierre Terdiman for suggestions and discussions on how to
+// optimize code. Thanks to David Hunt for finding a ">="-bug!
 
 #define X 0
 #define Y 1
@@ -337,10 +337,10 @@ intersection_test intersect2dSeg2dSegParametric(const Vec2r &p1,
 // This internal procedure is defined below.
 bool overlapPlaneBox(Vec3r &normal, real d, Vec3r &maxbox);
 
-// Use separating axis theorem to test overlap between triangle and box need to test for overlap in these directions:
-// 1) the {x,y,z}-directions (actually, since we use the AABB of the triangle we do not even need to test these)
-// 2) normal of the triangle
-// 3) crossproduct(edge from tri, {x,y,z}-directin) this gives 3x3=9 more tests
+// Use separating axis theorem to test overlap between triangle and box need to test for overlap in
+// these directions: 1) the {x,y,z}-directions (actually, since we use the AABB of the triangle we
+// do not even need to test these) 2) normal of the triangle 3) crossproduct(edge from tri,
+// {x,y,z}-directin) this gives 3x3=9 more tests
 bool overlapTriangleBox(Vec3r &boxcenter, Vec3r &boxhalfsize, Vec3r triverts[3])
 {
   Vec3r v0, v1, v2, normal, e0, e1, e2;
@@ -382,8 +382,8 @@ bool overlapTriangleBox(Vec3r &boxcenter, Vec3r &boxhalfsize, Vec3r triverts[3])
 
   // Bullet 1:
   // first test overlap in the {x,y,z}-directions
-  // find min, max of the triangle each direction, and test for overlap in that direction -- this is equivalent
-  // to testing a minimal AABB around the triangle against the AABB
+  // find min, max of the triangle each direction, and test for overlap in that direction -- this
+  // is equivalent to testing a minimal AABB around the triangle against the AABB
 
   // test in X-direction
   FINDMINMAX(v0[X], v1[X], v2[X], min, max);
@@ -664,7 +664,7 @@ void fromWorldToImage(const Vec3r &p, Vec3r &q, const real transform[4][4], cons
   // winX:
   q[0] = viewport[0] + viewport[2] * (q[0] + 1.0) / 2.0;
 
-  //winY:
+  // winY:
   q[1] = viewport[1] + viewport[3] * (q[1] + 1.0) / 2.0;
 }
 
@@ -709,10 +709,10 @@ void fromCameraToWorld(const Vec3r &p, Vec3r &q, const real model_view_matrix[4]
 /////////////////////////////////////////////////////////////////////////////
 
 // Copyright 2001, softSurfer (www.softsurfer.com)
-// This code may be freely used and modified for any purpose providing that this copyright notice is included with it.
-// SoftSurfer makes no warranty for this code, and cannot be held liable for any real or imagined damage resulting
-// from its use.
-// Users of this code must verify correctness for their application.
+// This code may be freely used and modified for any purpose providing that this copyright notice
+// is included with it. SoftSurfer makes no warranty for this code, and cannot be held liable for
+// any real or imagined damage resulting from its use. Users of this code must verify correctness
+// for their application.
 
 #define PERP(u, v) ((u)[0] * (v)[1] - (u)[1] * (v)[0])  // 2D perp product
 
index 42ef961..c469f10 100644 (file)
@@ -105,7 +105,8 @@ bool include2dSeg2dArea(const Vec2r &min, const Vec2r &max, const Vec2r &A, cons
 /*! Box-triangle overlap test, adapted from Tomas Akenine-Möller code */
 bool overlapTriangleBox(Vec3r &boxcenter, Vec3r &boxhalfsize, Vec3r triverts[3]);
 
-/*! Fast, Minimum Storage Ray-Triangle Intersection, adapted from Tomas Möller and Ben Trumbore code. */
+/*! Fast, Minimum Storage Ray-Triangle Intersection, adapted from Tomas Möller and Ben Trumbore
+ * code. */
 bool intersectRayTriangle(const Vec3r &orig,
                           const Vec3r &dir,
                           const Vec3r &v0,
@@ -126,7 +127,8 @@ intersection_test intersectRayPlane(const Vec3r &orig,
                                     const real epsilon = M_EPSILON);  // the epsilon to use
 
 /*! Intersection Ray-Bounding box (axis aligned).
- *  Adapted from Williams et al, "An Efficient Robust Ray-Box Intersection Algorithm", JGT 10:1 (2005), pp. 49-54.
+ *  Adapted from Williams et al, "An Efficient Robust Ray-Box Intersection Algorithm", JGT 10:1
+ * (2005), pp. 49-54.
  */
 bool intersectRayBBox(const Vec3r &orig,
                       const Vec3r &dir,  // ray origin and direction
index 51afb5c..aeb82d5 100644 (file)
@@ -49,10 +49,10 @@ void firstIntersectionGridVisitor::examineOccluder(Polygon3r *occ)
 {
   // check whether the edge and the polygon plane are coincident:
   //-------------------------------------------------------------
-  //first let us compute the plane equation.
+  // first let us compute the plane equation.
   Vec3r v1(((occ)->getVertices())[0]);
   Vec3d normal((occ)->getNormal());
-  //soc unused - double d = -(v1 * normal);
+  // soc unused - double d = -(v1 * normal);
 
   double tmp_u, tmp_v, tmp_t;
   if ((occ)->rayIntersect(ray_org_, ray_dir_, tmp_t, tmp_u, tmp_v)) {
@@ -167,8 +167,9 @@ void Grid::insertOccluder(Polygon3r *occluder)
   getCellCoordinates(min, imin);
 
   // We are now going to fill in the cells overlapping with the polygon bbox.
-  // If the polygon is a triangle (most of cases), we also check for each of these cells if it is overlapping with
-  // the triangle in order to only fill in the ones really overlapping the triangle.
+  // If the polygon is a triangle (most of cases), we also check for each of these cells if it is
+  // overlapping with the triangle in order to only fill in the ones really overlapping the
+  // triangle.
 
   unsigned i, x, y, z;
   vector<Vec3r>::const_iterator it;
@@ -239,8 +240,8 @@ bool Grid::nextRayCell(Vec3u &current_cell, Vec3u &next_cell)
   t_min = FLT_MAX;     // init tmin with handle of the case where one or 2 _u[i] = 0.
   unsigned coord = 0;  // predominant coord(0=x, 1=y, 2=z)
 
-  // using a parametric equation of a line : B = A + t u, we find the tx, ty and tz respectively coresponding
-  // to the intersections with the plans:
+  // using a parametric equation of a line : B = A + t u, we find the tx, ty and tz respectively
+  // coresponding to the intersections with the plans:
   //     x = _cell_size[0], y = _cell_size[1], z = _cell_size[2]
   for (i = 0; i < 3; i++) {
     if (_ray_dir[i] == 0)
@@ -318,8 +319,8 @@ Polygon3r *Grid::castRayToFindFirstIntersection(
   firstIntersectionGridVisitor visitor(orig, dir, _cell_size);
   castRayInternal(visitor);
   // ARB: This doesn't work, because occluders are unordered within any cell
-  // visitor.occluder() will be an occluder, but we have no guarantee it will be the *first* occluder.
-  // I assume that is the reason this code is not actually used for FindOccludee.
+  // visitor.occluder() will be an occluder, but we have no guarantee it will be the *first*
+  // occluder. I assume that is the reason this code is not actually used for FindOccludee.
   occluder = visitor.occluder();
   t = visitor.t_;
   u = visitor.u_;
@@ -337,7 +338,7 @@ void Grid::initRay(const Vec3r &orig, const Vec3r &end, unsigned timestamp)
 
   for (unsigned i = 0; i < 3; i++) {
     _current_cell[i] = (unsigned)floor((orig[i] - _orig[i]) / _cell_size[i]);
-    //soc unused - unsigned u = _current_cell[i];
+    // soc unused - unsigned u = _current_cell[i];
     _pt[i] = orig[i] - _orig[i] - _current_cell[i] * _cell_size[i];
   }
   //_ray_occluders.clear();
@@ -358,7 +359,7 @@ bool Grid::initInfiniteRay(const Vec3r &orig, const Vec3r &dir, unsigned timesta
   if (box.inside(orig)) {
     for (unsigned int i = 0; i < 3; i++) {
       _current_cell[i] = (unsigned int)floor((orig[i] - _orig[i]) / _cell_size[i]);
-      //soc unused - unsigned u = _current_cell[i];
+      // soc unused - unsigned u = _current_cell[i];
       _pt[i] = orig[i] - _orig[i] - _current_cell[i] * _cell_size[i];
     }
   }
@@ -372,7 +373,7 @@ bool Grid::initInfiniteRay(const Vec3r &orig, const Vec3r &dir, unsigned timesta
         _current_cell[i] = (unsigned)floor((newOrig[i] - _orig[i]) / _cell_size[i]);
         if (_current_cell[i] == _cells_nb[i])
           _current_cell[i] = _cells_nb[i] - 1;
-        //soc unused - unsigned u = _current_cell[i];
+        // soc unused - unsigned u = _current_cell[i];
         _pt[i] = newOrig[i] - _orig[i] - _current_cell[i] * _cell_size[i];
       }
     }
index a2b64a4..67aae73 100644 (file)
@@ -92,7 +92,7 @@ class Cell {
 
 class GridVisitor {
  public:
-  virtual ~GridVisitor(){};  //soc
+  virtual ~GridVisitor(){};  // soc
 
   virtual void discoverCell(Cell * /*cell*/)
   {
@@ -143,7 +143,7 @@ class allOccludersGridVisitor : public GridVisitor {
  *  The occluder and the intersection information are stored and accessible.
  */
 class firstIntersectionGridVisitor : public GridVisitor {
-  //soc - changed order to remove warnings
+  // soc - changed order to remove warnings
  public:
   double u_, v_, t_;
 
@@ -217,7 +217,8 @@ class Grid {
    */
   virtual void configure(const Vec3r &orig, const Vec3r &size, unsigned nb);
 
-  /*! returns a vector of integer containing the coordinates of the cell containing the point passed as argument
+  /*! returns a vector of integer containing the coordinates of the cell containing the point
+   * passed as argument
    *    p
    *      The point for which we're looking the cell
    */
@@ -241,8 +242,8 @@ class Grid {
   /*! returns the cell whose coordinates are pased as argument */
   virtual Cell *getCell(const Vec3u &coord) = 0;
 
-  /*! returns the cell containing the point passed as argument. If the cell is empty (contains no occluder),
-   *  NULL is returned
+  /*! returns the cell containing the point passed as argument.
+   *  If the cell is empty (contains no occluder),  NULL is returned:
    *    p
    *      The point for which we're looking the cell
    */
@@ -253,7 +254,8 @@ class Grid {
     return getCell(coord);
   }
 
-  /*! Retrieves the x,y,z coordinates of the origin of the cell whose coordinates (i,j,k) is passed as argument
+  /*! Retrieves the x,y,z coordinates of the origin of the cell whose coordinates (i,j,k)
+   *  is passed as argument:
    *    cell_coord
    *      i,j,k integer coordinates for the cell
    *    orig
@@ -265,7 +267,7 @@ class Grid {
       orig[i] = _orig[i] + cell_coord[i] * _cell_size[i];
   }
 
-  /*! Retrieves the box corresponding to the cell whose coordinates are passed as argument.
+  /*! Retrieves the box corresponding to the cell whose coordinates are passed as argument:
    *    cell_coord
    *      i,j,k integer coordinates for the cell
    *    min_out
@@ -280,9 +282,8 @@ class Grid {
   }
 
   /*! inserts a convex polygon occluder
-   *  This method is quite coarse insofar as it adds all cells intersecting the polygon bounding box
-   *    convex_poly
-   *      The list of 3D points constituting a convex polygon
+   *  This method is quite coarse insofar as it adds all cells intersecting the polygon bounding
+   * box convex_poly The list of 3D points constituting a convex polygon
    */
   void insertOccluder(Polygon3r *convex_poly);
 
@@ -301,8 +302,8 @@ class Grid {
   // Prepares to cast ray without generating OccludersSet
   void initAcceleratedRay(const Vec3r &orig, const Vec3r &end, unsigned timestamp);
 
-  /*! Casts an infinite ray (still finishing at the end of the grid) from a starting point and in a given direction.
-   *  Returns the list of occluders contained in the cells intersected by this ray
+  /*! Casts an infinite ray (still finishing at the end of the grid) from a starting point and in a
+   * given direction. Returns the list of occluders contained in the cells intersected by this ray
    *  Starts with a call to InitRay.
    */
   void castInfiniteRay(const Vec3r &orig,
@@ -313,9 +314,9 @@ class Grid {
   // Prepares to cast ray without generating OccludersSet.
   bool initAcceleratedInfiniteRay(const Vec3r &orig, const Vec3r &dir, unsigned timestamp);
 
-  /*! Casts an infinite ray (still finishing at the end of the grid) from a starting point and in a given direction.
-   *  Returns the first intersection (occluder,t,u,v) or null.
-   *  Starts with a call to InitRay.
+  /*! Casts an infinite ray (still finishing at the end of the grid) from a starting point and in a
+   * given direction. Returns the first intersection (occluder,t,u,v) or null. Starts with a call
+   * to InitRay.
    */
   Polygon3r *castRayToFindFirstIntersection(
       const Vec3r &orig, const Vec3r &dir, double &t, double &u, double &v, unsigned timestamp);
@@ -344,7 +345,7 @@ class Grid {
     return _cell_size;
   }
 
-  //ARB profiling only:
+  // ARB profiling only:
   inline OccludersSet *getOccluders()
   {
     return &_occluders;
@@ -392,12 +393,13 @@ class Grid {
 
   Vec3r _ray_dir;       // direction vector for the ray
   Vec3u _current_cell;  // The current cell being processed (designated by its 3 coordinates)
-  Vec3r
-      _pt;  // Points corresponding to the incoming and outgoing intersections of one cell with the ray
+  Vec3r _pt;    // Points corresponding to the incoming and outgoing intersections of one cell with
+                // the ray
   real _t_end;  // To know when we are at the end of the ray
   real _t;
 
-  //OccludersSet _ray_occluders; // Set storing the occluders contained in the cells traversed by a ray
+  // OccludersSet _ray_occluders; // Set storing the occluders contained in the cells traversed by
+  // a ray
   OccludersSet _occluders;  // List of all occluders inserted in the grid
 
 #ifdef WITH_CXX_GUARDEDALLOC
index 1f87bb7..a83dc38 100644 (file)
@@ -26,14 +26,15 @@ namespace Freestyle {
 void GridHelpers::getDefaultViewProscenium(real viewProscenium[4])
 {
   // Get proscenium boundary for culling
-  // bufferZone determines the amount by which the area processed should exceed the actual image area.
-  // This is intended to avoid visible artifacts generated along the proscenium edge.
-  // Perhaps this is no longer needed now that entire view edges are culled at once, since that theoretically
-  // should eliminate visible artifacts.
-  // To the extent it is still useful, bufferZone should be put into the UI as configurable percentage value
+  // bufferZone determines the amount by which the area processed should exceed the actual image
+  // area. This is intended to avoid visible artifacts generated along the proscenium edge. Perhaps
+  // this is no longer needed now that entire view edges are culled at once, since that
+  // theoretically should eliminate visible artifacts. To the extent it is still useful, bufferZone
+  // should be put into the UI as configurable percentage value
   const real bufferZone = 0.05;
   // borderZone describes a blank border outside the proscenium, but still inside the image area.
-  // Only intended for exposing possible artifacts along or outside the proscenium edge during debugging.
+  // Only intended for exposing possible artifacts along or outside the proscenium edge during
+  // debugging.
   const real borderZone = 0.0;
   viewProscenium[0] = g_freestyle.viewport[2] * (borderZone - bufferZone);
   viewProscenium[1] = g_freestyle.viewport[2] * (1.0f - borderZone + bufferZone);
index 8a75033..3f3c669 100644 (file)
@@ -126,8 +126,8 @@ class Transform {
 
 inline bool insideProscenium(const real proscenium[4], const Polygon3r &polygon)
 {
-  // N.B. The bounding box check is redundant for inserting occluders into cells, because the cell selection code
-  // in insertOccluders has already guaranteed that the bounding boxes will overlap.
+  // N.B. The bounding box check is redundant for inserting occluders into cells, because the cell
+  // selection code in insertOccluders has already guaranteed that the bounding boxes will overlap.
   // First check the viewport edges, since they are the easiest case
   // Check if the bounding box is entirely outside the proscenium
   Vec3r bbMin, bbMax;
index 81b0fd9..36094bf 100644 (file)
@@ -188,8 +188,8 @@ template<class T, class Point> class Segment {
 #  pragma warning(pop)
 #endif
 
-/*! defines a binary function that can be overload by the user to specify at each condition the intersection
- *  between 2 edges must be computed
+/*! defines a binary function that can be overload by the user to specify at each condition the
+ * intersection between 2 edges must be computed
  */
 template<class T1, class T2> struct binary_rule {
   binary_rule()
index 5b74e62..e6824fc 100644 (file)
@@ -46,7 +46,8 @@ class GaussianFilter {
   float _sigma;
   float *_mask;
   int _bound;
-  // the real mask size (must be odd)(the size of the mask we store is ((_maskSize+1)/2)*((_maskSize+1)/2))
+  // the real mask size (must be odd)(the size of the mask we store is
+  // ((_maskSize+1)/2)*((_maskSize+1)/2))
   int _maskSize;
   int _storedMaskSize;  // (_maskSize+1)/2)
 
@@ -56,13 +57,13 @@ class GaussianFilter {
   GaussianFilter &operator=(const GaussianFilter &);
   virtual ~GaussianFilter();
 
-  /*! Returns the value for pixel x,y of image "map" after a gaussian blur, made using the sigma value.
-   *  The sigma value determines the mask size (~ 2 x sigma).
-   *  \param map:
-   *    The image we wish to work on. The Map template must implement the following methods:
-   *    - float pixel(unsigned int x,unsigned int y) const;
-   *    - unsigned width() const;
-   *    - unsigned height() const;
+  /*! Returns the value for pixel x,y of image "map" after a gaussian blur, made using the sigma
+   * value. The sigma value determines the mask size (~ 2 x sigma).
+   * \param map: The image we wish to work on.
+   * The Map template must implement the following methods:
+   * - float pixel(unsigned int x,unsigned int y) const;
+   * - unsigned width() const;
+   * - unsigned height() const;
    *  \param x:
    *    The abscissa of the pixel where we want to evaluate the gaussian blur.
    *  \param y:
@@ -127,8 +128,8 @@ template<class Map> float GaussianFilter::getSmoothedPixel(Map *map, int x, int
 {
   float sum = 0.0f;
   float L = 0.0f;
-  int w = (int)map->width();   //soc
-  int h = (int)map->height();  //soc
+  int w = (int)map->width();   // soc
+  int h = (int)map->height();  // soc
 
   // Current pixel is x,y
   // Sum surrounding pixels L value:
@@ -145,7 +146,7 @@ template<class Map> float GaussianFilter::getSmoothedPixel(Map *map, int x, int
       sum += m;
     }
   }
-  //L /= sum;
+  // L /= sum;
   return L;
 }
 
index 344766b..b854e41 100644 (file)
@@ -35,9 +35,10 @@ namespace Freestyle {
 //
 ///////////////////////////////////////////////////////////////////////////////
 
-/*! This class allows the storing of part of an image, while allowing a normal access to its pixel values.
- *  You can for example only a rectangle of sw*sh, whose lower-left corner is at (ox, oy), of an image of
- *  size w*h, and access these pixels using x,y coordinates specified in the whole image coordinate system.
+/*! This class allows the storing of part of an image, while allowing a normal access to its pixel
+ * values. You can for example only a rectangle of sw*sh, whose lower-left corner is at (ox, oy),
+ * of an image of size w*h, and access these pixels using x,y coordinates specified in the whole
+ * image coordinate system.
  */
 class FrsImage {
  public:
@@ -209,7 +210,8 @@ class RGBImage : public FrsImage {
   /*! Builds an RGB partial image from the useful part buffer.
    *  \param rgb:
    *    The array of size 3*sw*sh containing the RGB values of the sw*sh pixels we need to stored.
-   *    These sw*sh pixels constitute a rectangular part of a bigger RGB image containing w*h pixels.
+   *    These sw*sh pixels constitute a rectangular part of a bigger
+   *    RGB image containing w*h pixels.
    *  \param w:
    *    The width of the complete image
    *  \param h:
@@ -346,7 +348,8 @@ class GrayImage : public FrsImage {
   /*! Builds a partial image from the useful part buffer.
    *  \param lvl:
    *    The array of size sw*sh containing the gray values of the sw*sh pixels we need to stored.
-   *    These sw*sh pixels constitute a rectangular part of a bigger gray image containing w*h pixels.
+   *    These sw*sh pixels constitute a rectangular part of a bigger
+   *    gray image containing w*h pixels.
    *  \param w:
    *    The width of the complete image
    *  \param h:
index 12d322d..e5b4053 100644 (file)
@@ -153,7 +153,7 @@ void GaussianPyramid::BuildPyramid(GrayImage *level0, unsigned nbLevels)
   unsigned w = pLevel->width();
   unsigned h = pLevel->height();
   if (nbLevels != 0) {
-    for (unsigned int i = 0; i < nbLevels; ++i) {  //soc
+    for (unsigned int i = 0; i < nbLevels; ++i) {  // soc
       w = pLevel->width() >> 1;
       h = pLevel->height() >> 1;
       GrayImage *img = new GrayImage(w, h);
index 0e388fd..8c6a8bc 100644 (file)
@@ -43,7 +43,7 @@ class ImagePyramid {
   {
   }
   ImagePyramid(const ImagePyramid &iBrother);
-  //ImagePyramid(const GrayImage& level0, unsigned nbLevels);
+  // ImagePyramid(const GrayImage& level0, unsigned nbLevels);
   virtual ~ImagePyramid();
 
   /*! Builds the pyramid.
index 2068fe8..2169ee1 100644 (file)
@@ -31,7 +31,7 @@ extern "C" {
 
 //------------------------INSTANCE METHODS ----------------------------------
 
-//ViewMapGradientNormBP1D(int level, IntegrationType iType=MEAN, float sampling=2.0)
+// ViewMapGradientNormBP1D(int level, IntegrationType iType=MEAN, float sampling=2.0)
 
 static char ViewMapGradientNormBP1D___doc__[] =
     "Class hierarchy: :class:`freestyle.types.BinaryPredicate1D` > "
@@ -82,7 +82,7 @@ static int ViewMapGradientNormBP1D___init__(BPy_ViewMapGradientNormBP1D *self,
   return 0;
 }
 
-/*-----------------------BPy_ViewMapGradientNormBP1D type definition ------------------------------*/
+/*-----------------------BPy_ViewMapGradientNormBP1D type definition ----------------------------*/
 
 PyTypeObject ViewMapGradientNormBP1D_Type = {
     PyVarObject_HEAD_INIT(NULL, 0) "ViewMapGradientNormBP1D", /* tp_name */
index e685491..8a5bb0b 100644 (file)
@@ -136,7 +136,7 @@ static int CurvePoint_init(BPy_CurvePoint *self, PyObject *args, PyObject *kwds)
   return 0;
 }
 
-///bool     operator== (const CurvePoint &b)
+/// bool     operator== (const CurvePoint &b)
 
 /*----------------------CurvePoint get/setters ----------------------------*/
 
index f25435b..189d41e 100644 (file)
@@ -161,7 +161,7 @@ static void ChainPredicateIterator_dealloc(BPy_ChainPredicateIterator *self)
   ChainingIterator_Type.tp_dealloc((PyObject *)self);
 }
 
-/*-----------------------BPy_ChainPredicateIterator type definition ------------------------------*/
+/*-----------------------BPy_ChainPredicateIterator type definition ----------------------------*/
 
 PyTypeObject ChainPredicateIterator_Type = {
     PyVarObject_HEAD_INIT(NULL, 0) "ChainPredicateIterator", /* tp_name */
index 6a4af0f..d72e830 100644 (file)
@@ -31,8 +31,8 @@ extern "C" {
 
 //------------------------INSTANCE METHODS ----------------------------------
 
-// ChainSilhouetteIterator (bool restrict_to_selection=true, ViewEdge *begin=NULL, bool orientation=true)
-// ChainSilhouetteIterator (const ChainSilhouetteIterator &brother)
+// ChainSilhouetteIterator (bool restrict_to_selection=true, ViewEdge *begin=NULL, bool
+// orientation=true) ChainSilhouetteIterator (const ChainSilhouetteIterator &brother)
 
 PyDoc_STRVAR(ChainSilhouetteIterator_doc,
              "Class hierarchy: :class:`freestyle.types.Iterator` >\n"
@@ -117,7 +117,7 @@ static int ChainSilhouetteIterator_init(BPy_ChainSilhouetteIterator *self,
   return 0;
 }
 
-/*-----------------------BPy_ChainSilhouetteIterator type definition ------------------------------*/
+/*-----------------------BPy_ChainSilhouetteIterator type definition ----------------------------*/
 
 PyTypeObject ChainSilhouetteIterator_Type = {
     PyVarObject_HEAD_INIT(NULL, 0) "ChainSilhouetteIterator", /* tp_name */
index 3cb114a..21e3e82 100644 (file)
@@ -137,7 +137,7 @@ static PyGetSetDef BPy_orientedViewEdgeIterator_getseters[] = {
     {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
 };
 
-/*-----------------------BPy_orientedViewEdgeIterator type definition ------------------------------*/
+/*-----------------------BPy_orientedViewEdgeIterator type definition ---------------------------*/
 
 PyTypeObject orientedViewEdgeIterator_Type = {
     PyVarObject_HEAD_INIT(NULL, 0) "orientedViewEdgeIterator", /* tp_name */
index 7ee1372..9a37acb 100644 (file)
@@ -63,7 +63,7 @@ static int BackboneStretcherShader___init__(BPy_BackboneStretcherShader *self,
   return 0;
 }
 
-/*-----------------------BPy_BackboneStretcherShader type definition ------------------------------*/
+/*-----------------------BPy_BackboneStretcherShader type definition ----------------------------*/
 
 PyTypeObject BackboneStretcherShader_Type = {
     PyVarObject_HEAD_INIT(NULL, 0) "BackboneStretcherShader", /* tp_name */
index 8acb121..35a94a1 100644 (file)
@@ -31,7 +31,8 @@ extern "C" {
 
 extern PyTypeObject CalligraphicShader_Type;
 
-#define BPy_CalligraphicShader_Check(v) (PyObject_IsInstance((PyObject *)v, (PyObject *)&CalligraphicShader_Type)
+#define BPy_CalligraphicShader_Check(v) \
+  (PyObject_IsInstance((PyObject *)v, (PyObject *)&CalligraphicShader_Type)
 
 /*---------------------------Python BPy_CalligraphicShader structure definition----------*/
 typedef struct {
index c226cc0..5177d27 100644 (file)
@@ -62,7 +62,7 @@ static int ConstantThicknessShader___init__(BPy_ConstantThicknessShader *self,
   return 0;
 }
 
-/*-----------------------BPy_ConstantThicknessShader type definition ------------------------------*/
+/*-----------------------BPy_ConstantThicknessShader type definition ----------------------------*/
 
 PyTypeObject ConstantThicknessShader_Type = {
     PyVarObject_HEAD_INIT(NULL, 0) "ConstantThicknessShader", /* tp_name */
index 22a67c6..4afe148 100644 (file)
@@ -68,7 +68,7 @@ static int ConstrainedIncreasingThicknessShader___init__(
   return 0;
 }
 
-/*-----------------------BPy_ConstrainedIncreasingThicknessShader type definition ------------------------------*/
+/*-----------------------BPy_ConstrainedIncreasingThicknessShader type definition ---------------*/
 
 PyTypeObject ConstrainedIncreasingThicknessShader_Type = {
     PyVarObject_HEAD_INIT(NULL, 0) "ConstrainedIncreasingThicknessShader", /* tp_name */
index 907355e..0491249 100644 (file)
@@ -34,7 +34,8 @@ extern PyTypeObject ConstrainedIncreasingThicknessShader_Type;
 #define BPy_ConstrainedIncreasingThicknessShader_Check(v) \
   (PyObject_IsInstance((PyObject *)v, (PyObject *)&ConstrainedIncreasingThicknessShader_Type))
 
-/*---------------------------Python BPy_ConstrainedIncreasingThicknessShader structure definition----------*/
+/*---------------------------Python BPy_ConstrainedIncreasingThicknessShader structure
+ * definition----------*/
 typedef struct {
   BPy_StrokeShader py_ss;
 } BPy_ConstrainedIncreasingThicknessShader;
index 324f1c1..b791fc5 100644 (file)
@@ -68,7 +68,7 @@ static int IncreasingThicknessShader___init__(BPy_IncreasingThicknessShader *sel
   return 0;
 }
 
-/*-----------------------BPy_IncreasingThicknessShader type definition ------------------------------*/
+/*-----------------------BPy_IncreasingThicknessShader type definition --------------------------*/
 
 PyTypeObject IncreasingThicknessShader_Type = {
     PyVarObject_HEAD_INIT(NULL, 0) "IncreasingThicknessShader", /* tp_name */
index 273e41a..7eb20d4 100644 (file)
@@ -69,7 +69,7 @@ static int PolygonalizationShader___init__(BPy_PolygonalizationShader *self,
   return 0;
 }
 
-/*-----------------------BPy_PolygonalizationShader type definition ------------------------------*/
+/*-----------------------BPy_PolygonalizationShader type definition -----------------------------*/
 
 PyTypeObject PolygonalizationShader_Type = {
     PyVarObject_HEAD_INIT(NULL, 0) "PolygonalizationShader", /* tp_name */
index 3d76d71..e8183b4 100644 (file)
@@ -62,7 +62,7 @@ static int StrokeTextureStepShader___init__(BPy_StrokeTextureStepShader *self,
   return 0;
 }
 
-/*-----------------------BPy_StrokeTextureStepShader type definition ------------------------------*/
+/*-----------------------BPy_StrokeTextureStepShader type definition ----------------------------*/
 
 PyTypeObject StrokeTextureStepShader_Type = {
     PyVarObject_HEAD_INIT(NULL, 0) "StrokeTextureStepShader", /* tp_name */
index 76dbe2e..f6292f0 100644 (file)
@@ -115,7 +115,7 @@ static PyObject *UnaryFunction0DEdgeNature___call__(BPy_UnaryFunction0DEdgeNatur
   return BPy_Nature_from_Nature(self->uf0D_edgenature->result);
 }
 
-/*-----------------------BPy_UnaryFunction0DEdgeNature type definition ------------------------------*/
+/*-----------------------BPy_UnaryFunction0DEdgeNature type definition --------------------------*/
 
 PyTypeObject UnaryFunction0DEdgeNature_Type = {
     PyVarObject_HEAD_INIT(NULL, 0) "UnaryFunction0DEdgeNature", /* tp_name */
index a375ac5..63f9ff0 100644 (file)
@@ -114,7 +114,7 @@ static PyObject *UnaryFunction0DMaterial___call__(BPy_UnaryFunction0DMaterial *s
   return BPy_FrsMaterial_from_FrsMaterial(self->uf0D_material->result);
 }
 
-/*-----------------------BPy_UnaryFunction0DMaterial type definition ------------------------------*/
+/*-----------------------BPy_UnaryFunction0DMaterial type definition ----------------------------*/
 
 PyTypeObject UnaryFunction0DMaterial_Type = {
     PyVarObject_HEAD_INIT(NULL, 0) "UnaryFunction0DMaterial", /* tp_name */
index 756e5cd..65d8d63 100644 (file)
@@ -115,7 +115,7 @@ static PyObject *UnaryFunction0DUnsigned___call__(BPy_UnaryFunction0DUnsigned *s
   return PyLong_FromLong(self->uf0D_unsigned->result);
 }
 
-/*-----------------------BPy_UnaryFunction0DUnsigned type definition ------------------------------*/
+/*-----------------------BPy_UnaryFunction0DUnsigned type definition ----------------------------*/
 
 PyTypeObject UnaryFunction0DUnsigned_Type = {
     PyVarObject_HEAD_INIT(NULL, 0) "UnaryFunction0DUnsigned", /* tp_name */
index 039727f..d908b3f 100644 (file)
@@ -124,7 +124,7 @@ static PyObject *UnaryFunction0DVectorViewShape___call__(BPy_UnaryFunction0DVect
   return list;
 }
 
-/*-----------------------BPy_UnaryFunction0DVectorViewShape type definition ------------------------------*/
+/*-----------------------BPy_UnaryFunction0DVectorViewShape type definition ---------------------*/
 
 PyTypeObject UnaryFunction0DVectorViewShape_Type = {
     PyVarObject_HEAD_INIT(NULL, 0) "UnaryFunction0DVectorViewShape", /* tp_name */
index 22cf50c..586f7ec 100644 (file)
@@ -37,13 +37,15 @@ extern PyTypeObject UnaryFunction0DVectorViewShape_Type;
 #define BPy_UnaryFunction0DVectorViewShape_Check(v) \
   (PyObject_IsInstance((PyObject *)v, (PyObject *)&UnaryFunction0DVectorViewShape_Type))
 
-/*---------------------------Python BPy_UnaryFunction0DVectorViewShape structure definition----------*/
+/*---------------------------Python BPy_UnaryFunction0DVectorViewShape structure
+ * definition----------*/
 typedef struct {
   BPy_UnaryFunction0D py_uf0D;
   UnaryFunction0D<std::vector<ViewShape *>> *uf0D_vectorviewshape;
 } BPy_UnaryFunction0DVectorViewShape;
 
-/*---------------------------Python BPy_UnaryFunction0DVectorViewShape visible prototypes-----------*/
+/*---------------------------Python BPy_UnaryFunction0DVectorViewShape visible
+ * prototypes-----------*/
 int UnaryFunction0DVectorViewShape_Init(PyObject *module);
 
 ///////////////////////////////////////////////////////////////////////////////////////////
index 1df3be0..8c04d8e 100644 (file)
@@ -121,7 +121,7 @@ static PyObject *UnaryFunction0DViewShape___call__(BPy_UnaryFunction0DViewShape
   return BPy_ViewShape_from_ViewShape(*(self->uf0D_viewshape->result));
 }
 
-/*-----------------------BPy_UnaryFunction0DViewShape type definition ------------------------------*/
+/*-----------------------BPy_UnaryFunction0DViewShape type definition ---------------------------*/
 
 PyTypeObject UnaryFunction0DViewShape_Type = {
     PyVarObject_HEAD_INIT(NULL, 0) "UnaryFunction0DViewShape", /* tp_name */
index 623ec4d..ec37559 100644 (file)
@@ -64,7 +64,7 @@ static int VertexOrientation2DF0D___init__(BPy_VertexOrientation2DF0D *self,
   return 0;
 }
 
-/*-----------------------BPy_VertexOrientation2DF0D type definition ------------------------------*/
+/*-----------------------BPy_VertexOrientation2DF0D type definition -----------------------------*/
 
 PyTypeObject VertexOrientation2DF0D_Type = {
     PyVarObject_HEAD_INIT(NULL, 0) "VertexOrientation2DF0D", /* tp_name */
index 6ed5201..d5e073b 100644 (file)
@@ -64,7 +64,7 @@ static int VertexOrientation3DF0D___init__(BPy_VertexOrientation3DF0D *self,
   return 0;
 }
 
-/*-----------------------BPy_VertexOrientation3DF0D type definition ------------------------------*/
+/*-----------------------BPy_VertexOrientation3DF0D type definition -----------------------------*/
 
 PyTypeObject VertexOrientation3DF0D_Type = {
     PyVarObject_HEAD_INIT(NULL, 0) "VertexOrientation3DF0D", /* tp_name */
index ce8852a..2db536d 100644 (file)
@@ -62,7 +62,7 @@ static int GetCurvilinearAbscissaF0D___init__(BPy_GetCurvilinearAbscissaF0D *sel
   return 0;
 }
 
-/*-----------------------BPy_GetCurvilinearAbscissaF0D type definition ------------------------------*/
+/*-----------------------BPy_GetCurvilinearAbscissaF0D type definition --------------------------*/
 
 PyTypeObject GetCurvilinearAbscissaF0D_Type = {
     PyVarObject_HEAD_INIT(NULL, 0) "GetCurvilinearAbscissaF0D", /* tp_name */
index 3cf5efc..21e0532 100644 (file)
@@ -67,7 +67,7 @@ static int GetViewMapGradientNormF0D___init__(BPy_GetViewMapGradientNormF0D *sel
   return 0;
 }
 
-/*-----------------------BPy_GetViewMapGradientNormF0D type definition ------------------------------*/
+/*-----------------------BPy_GetViewMapGradientNormF0D type definition --------------------------*/
 
 PyTypeObject GetViewMapGradientNormF0D_Type = {
     PyVarObject_HEAD_INIT(NULL, 0) "GetViewMapGradientNormF0D", /* tp_name */
index a70cf81..506aa15 100644 (file)
@@ -65,7 +65,7 @@ static int ReadCompleteViewMapPixelF0D___init__(BPy_ReadCompleteViewMapPixelF0D
   return 0;
 }
 
-/*-----------------------BPy_ReadCompleteViewMapPixelF0D type definition ------------------------------*/
+/*-----------------------BPy_ReadCompleteViewMapPixelF0D type definition ------------------------*/
 
 PyTypeObject ReadCompleteViewMapPixelF0D_Type = {
     PyVarObject_HEAD_INIT(NULL, 0) "ReadCompleteViewMapPixelF0D", /* tp_name */
index 6ccfd97..48d3654 100644 (file)
@@ -34,7 +34,8 @@ extern PyTypeObject ReadCompleteViewMapPixelF0D_Type;
 #define BPy_ReadCompleteViewMapPixelF0D_Check(v) \
   (PyObject_IsInstance((PyObject *)v, (PyObject *)&ReadCompleteViewMapPixelF0D_Type))
 
-/*---------------------------Python BPy_ReadCompleteViewMapPixelF0D structure definition----------*/
+/*---------------------------Python BPy_ReadCompleteViewMapPixelF0D structure
+ * definition----------*/
 typedef struct {
   BPy_UnaryFunction0DFloat py_uf0D_float;
 } BPy_ReadCompleteViewMapPixelF0D;
index 3dec389..0eee141 100644 (file)
@@ -69,7 +69,7 @@ static int ReadSteerableViewMapPixelF0D___init__(BPy_ReadSteerableViewMapPixelF0
   return 0;
 }
 
-/*-----------------------BPy_ReadSteerableViewMapPixelF0D type definition ------------------------------*/
+/*-----------------------BPy_ReadSteerableViewMapPixelF0D type definition -----------------------*/
 
 PyTypeObject ReadSteerableViewMapPixelF0D_Type = {
     PyVarObject_HEAD_INIT(NULL, 0) "ReadSteerableViewMapPixelF0D", /* tp_name */
index c0c62a5..3cff99b 100644 (file)
@@ -34,7 +34,8 @@ extern PyTypeObject ReadSteerableViewMapPixelF0D_Type;
 #define BPy_ReadSteerableViewMapPixelF0D_Check(v) \
   (PyObject_IsInstance((PyObject *)v, (PyObject *)&ReadSteerableViewMapPixelF0D_Type))
 
-/*---------------------------Python BPy_ReadSteerableViewMapPixelF0D structure definition----------*/
+/*---------------------------Python BPy_ReadSteerableViewMapPixelF0D structure
+ * definition----------*/
 typedef struct {
   BPy_UnaryFunction0DFloat py_uf0D_float;
 } BPy_ReadSteerableViewMapPixelF0D;
index f35f6ad..0b6a116 100644 (file)
@@ -67,7 +67,7 @@ static int QuantitativeInvisibilityF0D___init__(BPy_QuantitativeInvisibilityF0D
   return 0;
 }
 
-/*-----------------------BPy_QuantitativeInvisibilityF0D type definition ------------------------------*/
+/*-----------------------BPy_QuantitativeInvisibilityF0D type definition ------------------------*/
 
 PyTypeObject QuantitativeInvisibilityF0D_Type = {
     PyVarObject_HEAD_INIT(NULL, 0) "QuantitativeInvisibilityF0D", /* tp_name */
index 933deb7..dd64fb4 100644 (file)
@@ -34,7 +34,8 @@ extern PyTypeObject QuantitativeInvisibilityF0D_Type;
 #define BPy_QuantitativeInvisibilityF0D_Check(v) \
   (PyObject_IsInstance((PyObject *)v, (PyObject *)&QuantitativeInvisibilityF0D_Type))
 
-/*---------------------------Python BPy_QuantitativeInvisibilityF0D structure definition----------*/
+/*---------------------------Python BPy_QuantitativeInvisibilityF0D structure
+ * definition----------*/
 typedef struct {
   BPy_UnaryFunction0DUnsigned py_uf0D_unsigned;
 } BPy_QuantitativeInvisibilityF0D;
index 2bcda97..262fdbc 100644 (file)
@@ -166,7 +166,7 @@ static PyGetSetDef BPy_UnaryFunction1DEdgeNature_getseters[] = {
     {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
 };
 
-/*-----------------------BPy_UnaryFunction1DEdgeNature type definition ------------------------------*/
+/*-----------------------BPy_UnaryFunction1DEdgeNature type definition --------------------------*/
 
 PyTypeObject UnaryFunction1DEdgeNature_Type = {
     PyVarObject_HEAD_INIT(NULL, 0) "UnaryFunction1DEdgeNature", /* tp_name */
index a284483..37d37db 100644 (file)
@@ -166,7 +166,7 @@ static PyGetSetDef BPy_UnaryFunction1DUnsigned_getseters[] = {
     {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
 };
 
-/*-----------------------BPy_UnaryFunction1DUnsigned type definition ------------------------------*/
+/*-----------------------BPy_UnaryFunction1DUnsigned type definition ----------------------------*/
 
 PyTypeObject UnaryFunction1DUnsigned_Type = {
     PyVarObject_HEAD_INIT(NULL, 0) "UnaryFunction1DUnsigned", /* tp_name */
index f7a80a2..eb4974e 100644 (file)
@@ -190,7 +190,7 @@ static PyGetSetDef BPy_UnaryFunction1DVectorViewShape_getseters[] = {
     {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
 };
 
-/*-----------------------BPy_UnaryFunction1DVectorViewShape type definition ------------------------------*/
+/*-----------------------BPy_UnaryFunction1DVectorViewShape type definition ---------------------*/
 
 PyTypeObject UnaryFunction1DVectorViewShape_Type = {
     PyVarObject_HEAD_INIT(NULL, 0) "UnaryFunction1DVectorViewShape", /* tp_name */
index 92889dd..2869b36 100644 (file)
@@ -37,13 +37,15 @@ extern PyTypeObject UnaryFunction1DVectorViewShape_Type;
 #define BPy_UnaryFunction1DVectorViewShape_Check(v) \
   (PyObject_IsInstance((PyObject *)v, (PyObject *)&UnaryFunction1DVectorViewShape_Type))
 
-/*---------------------------Python BPy_UnaryFunction1DVectorViewShape structure definition----------*/
+/*---------------------------Python BPy_UnaryFunction1DVectorViewShape structure
+ * definition----------*/
 typedef struct {
   BPy_UnaryFunction1D py_uf1D;
   UnaryFunction1D<std::vector<ViewShape *>> *uf1D_vectorviewshape;
 } BPy_UnaryFunction1DVectorViewShape;
 
-/*---------------------------Python BPy_UnaryFunction1DVectorViewShape visible prototypes-----------*/
+/*---------------------------Python BPy_UnaryFunction1DVectorViewShape visible
+ * prototypes-----------*/
 int UnaryFunction1DVectorViewShape_Init(PyObject *module);
 
 ///////////////////////////////////////////////////////////////////////////////////////////
index 419ea1f..4b2f444 100644 (file)
@@ -84,7 +84,7 @@ static int GetCompleteViewMapDensityF1D___init__(BPy_GetCompleteViewMapDensityF1
   return 0;
 }
 
-/*-----------------------BPy_GetCompleteViewMapDensityF1D type definition ------------------------------*/
+/*-----------------------BPy_GetCompleteViewMapDensityF1D type definition -----------------------*/
 
 PyTypeObject GetCompleteViewMapDensityF1D_Type = {
     PyVarObject_HEAD_INIT(NULL, 0) "GetCompleteViewMapDensityF1D", /* tp_name */
index c0a78e8..dacfb33 100644 (file)
@@ -34,7 +34,8 @@ extern PyTypeObject GetCompleteViewMapDensityF1D_Type;
 #define BPy_GetCompleteViewMapDensityF1D_Check(v) \
   (PyObject_IsInstance((PyObject *)v, (PyObject *)&GetCompleteViewMapDensityF1D_Type))
 
-/*---------------------------Python BPy_GetCompleteViewMapDensityF1D structure definition----------*/
+/*---------------------------Python BPy_GetCompleteViewMapDensityF1D structure
+ * definition----------*/
 typedef struct {
   BPy_UnaryFunction1DDouble py_uf1D_double;
 } BPy_GetCompleteViewMapDensityF1D;
index 58290f6..8b31c31 100644 (file)
@@ -91,7 +91,7 @@ static int GetDirectionalViewMapDensityF1D___init__(BPy_GetDirectionalViewMapDen
   return 0;
 }
 
-/*-----------------------BPy_GetDirectionalViewMapDensityF1D type definition ------------------------------*/
+/*-----------------------BPy_GetDirectionalViewMapDensityF1D type definition --------------------*/
 
 PyTypeObject GetDirectionalViewMapDensityF1D_Type = {
     PyVarObject_HEAD_INIT(NULL, 0) "GetDirectionalViewMapDensityF1D", /* tp_name */
index d78ffe8..b039fad 100644 (file)
@@ -34,7 +34,8 @@ extern PyTypeObject GetDirectionalViewMapDensityF1D_Type;
 #define BPy_GetDirectionalViewMapDensityF1D_Check(v) \
   (PyObject_IsInstance((PyObject *)v, (PyObject *)&GetDirectionalViewMapDensityF1D_Type))
 
-/*---------------------------Python BPy_GetDirectionalViewMapDensityF1D structure definition----------*/
+/*---------------------------Python BPy_GetDirectionalViewMapDensityF1D structure
+ * definition----------*/
 typedef struct {
   BPy_UnaryFunction1DDouble py_uf1D_double;
 } BPy_GetDirectionalViewMapDensityF1D;
index a112dee..615faed 100644 (file)
@@ -81,7 +81,7 @@ static int GetSteerableViewMapDensityF1D___init__(BPy_GetSteerableViewMapDensity
   return 0;
 }
 
-/*-----------------------BPy_GetSteerableViewMapDensityF1D type definition ------------------------------*/
+/*-----------------------BPy_GetSteerableViewMapDensityF1D type definition ----------------------*/
 
 PyTypeObject GetSteerableViewMapDensityF1D_Type = {
     PyVarObject_HEAD_INIT(NULL, 0) "GetSteerableViewMapDensityF1D", /* tp_name */
index c4881a7..47f168a 100644 (file)
@@ -33,7 +33,8 @@ extern PyTypeObject GetSteerableViewMapDensityF1D_Type;
 
 #define BPy_GetSteerableViewMapDensityF1D_Check(v) \
   (PyObject_IsInstance((PyObject *)v, (PyObject *)&GetSteerableViewMapDensityF1D_Type))
-/*---------------------------Python BPy_GetSteerableViewMapDensityF1D structure definition----------*/
+/*---------------------------Python BPy_GetSteerableViewMapDensityF1D structure
+ * definition----------*/
 typedef struct {
   BPy_UnaryFunction1DDouble py_uf1D_double;
 } BPy_GetSteerableViewMapDensityF1D;
index b2bb294..7e77e79 100644 (file)
@@ -81,7 +81,7 @@ static int GetViewMapGradientNormF1D___init__(BPy_GetViewMapGradientNormF1D *sel
   return 0;
 }
 
-/*-----------------------BPy_GetViewMapGradientNormF1D type definition ------------------------------*/
+/*-----------------------BPy_GetViewMapGradientNormF1D type definition --------------------------*/
 
 PyTypeObject GetViewMapGradientNormF1D_Type = {
     PyVarObject_HEAD_INIT(NULL, 0) "GetViewMapGradientNormF1D", /* tp_name */
index f955c90..bce95e5 100644 (file)
@@ -72,7 +72,7 @@ static int QuantitativeInvisibilityF1D___init__(BPy_QuantitativeInvisibilityF1D
   return 0;
 }
 
-/*-----------------------BPy_QuantitativeInvisibilityF1D type definition ------------------------------*/
+/*-----------------------BPy_QuantitativeInvisibilityF1D type definition ------------------------*/
 
 PyTypeObject QuantitativeInvisibilityF1D_Type = {
     PyVarObject_HEAD_INIT(NULL, 0) "QuantitativeInvisibilityF1D", /* tp_name */
index 35cd9e7..0d4d118 100644 (file)
@@ -34,7 +34,8 @@ extern PyTypeObject QuantitativeInvisibilityF1D_Type;
 #define BPy_QuantitativeInvisibilityF1D_Check(v) \
   (PyObject_IsInstance((PyObject *)v, (PyObject *)&QuantitativeInvisibilityF1D_Type))
 
-/*---------------------------Python BPy_QuantitativeInvisibilityF1D structure definition----------*/
+/*---------------------------Python BPy_QuantitativeInvisibilityF1D structure
+ * definition----------*/
 typedef struct {
   BPy_UnaryFunction1DUnsigned py_uf1D_unsigned;
 } BPy_QuantitativeInvisibilityF1D;
index 3aa694a..04d724b 100644 (file)
@@ -59,7 +59,7 @@ static int IncrementChainingTimeStampF1D___init__(BPy_IncrementChainingTimeStamp
   return 0;
 }
 
-/*-----------------------BPy_IncrementChainingTimeStampF1D type definition ------------------------------*/
+/*-----------------------BPy_IncrementChainingTimeStampF1D type definition ----------------------*/
 
 PyTypeObject IncrementChainingTimeStampF1D_Type = {
     PyVarObject_HEAD_INIT(NULL, 0) "IncrementChainingTimeStampF1D", /* tp_name */
index 3030528..0d74b1f 100644 (file)
@@ -34,7 +34,8 @@ extern PyTypeObject IncrementChainingTimeStampF1D_Type;
 #define BPy_IncrementChainingTimeStampF1D_Check(v) \
   (PyObject_IsInstance((PyObject *)v, (PyObject *)&IncrementChainingTimeStampF1D_Type))
 
-/*---------------------------Python BPy_IncrementChainingTimeStampF1D structure definition----------*/
+/*---------------------------Python BPy_IncrementChainingTimeStampF1D structure
+ * definition----------*/
 typedef struct {
   BPy_UnaryFunction1DVoid py_uf1D_void;
 } BPy_IncrementChainingTimeStampF1D;
index f3b6a71..fb42b29 100644 (file)
@@ -62,7 +62,7 @@ static int EqualToChainingTimeStampUP1D___init__(BPy_EqualToChainingTimeStampUP1
   return 0;
 }
 
-/*-----------------------BPy_EqualToChainingTimeStampUP1D type definition ------------------------------*/
+/*-----------------------BPy_EqualToChainingTimeStampUP1D type definition -----------------------*/
 
 PyTypeObject EqualToChainingTimeStampUP1D_Type = {
     PyVarObject_HEAD_INIT(NULL, 0) "EqualToChainingTimeStampUP1D", /* tp_name */
index eab08c6..e2ba8b7 100644 (file)
@@ -34,7 +34,8 @@ extern PyTypeObject EqualToChainingTimeStampUP1D_Type;
 #define BPy_EqualToChainingTimeStampUP1D_Check(v) \
   (PyObject_IsInstance((PyObject *)v, (PyObject *)&EqualToChainingTimeStampUP1D_Type))
 
-/*---------------------------Python BPy_EqualToChainingTimeStampUP1D structure definition----------*/
+/*---------------------------Python BPy_EqualToChainingTimeStampUP1D structure
+ * definition----------*/
 typedef struct {
   BPy_UnaryPredicate1D py_up1D;
 } BPy_EqualToChainingTimeStampUP1D;
index 885ecb1..907a864 100644 (file)
@@ -66,7 +66,7 @@ static int QuantitativeInvisibilityUP1D___init__(BPy_QuantitativeInvisibilityUP1
   return 0;
 }
 
-/*-----------------------BPy_QuantitativeInvisibilityUP1D type definition ------------------------------*/
+/*-----------------------BPy_QuantitativeInvisibilityUP1D type definition -----------------------*/
 
 PyTypeObject QuantitativeInvisibilityUP1D_Type = {
     PyVarObject_HEAD_INIT(NULL, 0) "QuantitativeInvisibilityUP1D", /* tp_name */
index 879c6c5..bbb1dce 100644 (file)
@@ -34,7 +34,8 @@ extern PyTypeObject QuantitativeInvisibilityUP1D_Type;
 #define BPy_QuantitativeInvisibilityUP1D_Check(v) \
   (PyObject_IsInstance((PyObject *)v, (PyObject *)&QuantitativeInvisibilityUP1D_Type))
 
-/*---------------------------Python BPy_QuantitativeInvisibilityUP1D structure definition----------*/
+/*---------------------------Python BPy_QuantitativeInvisibilityUP1D structure
+ * definition----------*/
 typedef struct {
   BPy_UnaryPredicate1D py_up1D;
 } BPy_QuantitativeInvisibilityUP1D;
index 8367219..2a38e6f 100644 (file)
@@ -99,13 +99,11 @@ class IndexedFaceSet : public Rep {
    *    iMISize
    *      The size of iMIndices
    *    iTIndices
-   *      The Texture coordinates indices (per vertex). The integers contained in this array must be multiple of 2.
-   *    iTISize
-   *      The size of iMIndices
-   *    iCopy
-   *      0 : the arrays are not copied. The pointers passed as arguments are used. IndexedFaceSet takes these
-   *          arrays desallocation in charge.
-   *      1 : the arrays are copied. The caller is in charge of the arrays, passed as arguments desallocation.
+   *      The Texture coordinates indices (per vertex). The integers contained in this array must
+   * be multiple of 2. iTISize The size of iMIndices iCopy 0 : the arrays are not copied. The
+   * pointers passed as arguments are used. IndexedFaceSet takes these arrays desallocation in
+   * charge. 1 : the arrays are copied. The caller is in charge of the arrays, passed as arguments
+   * desallocation.
    */
   IndexedFaceSet(float *iVertices,
                  unsigned iVSize,
index a9424fe..2e0e94e 100644 (file)
@@ -19,7 +19,8 @@
 
 /** \file
  * \ingroup freestyle
- * \brief Abstract class for scene graph nodes. Inherits from BaseObject which defines the addRef release mechanism.
+ * \brief Abstract class for scene graph nodes. Inherits from BaseObject which defines the addRef
+ * release mechanism.
  */
 
 #include "SceneVisitor.h"
index 2564a46..75accce 100644 (file)
@@ -16,7 +16,8 @@
 
 /** \file
  * \ingroup freestyle
- * \brief Class to define a Drawing Style to be applied to the underlying children. Inherits from NodeGroup.
+ * \brief Class to define a Drawing Style to be applied to the underlying children. Inherits from
+ * NodeGroup.
  */
 
 #include "NodeDrawingStyle.h"
index ea617a9..f1dfad0 100644 (file)
@@ -19,7 +19,8 @@
 
 /** \file
  * \ingroup freestyle
- * \brief Class to define a Drawing Style to be applied to the underlying children. Inherits from NodeGroup.
+ * \brief Class to define a Drawing Style to be applied to the underlying children. Inherits from
+ * NodeGroup.
  */
 
 #include "DrawingStyle.h"
index 204e5e1..7ea495c 100644 (file)
@@ -17,7 +17,8 @@
 /** \file
  * \ingroup freestyle
  * \brief Class to represent a group node. This node can contains several children.
- * \brief It also contains a transform matrix indicating the transform state of the underlying children.
+ * \brief It also contains a transform matrix indicating the transform state of the underlying
+ * children.
  */
 
 #include "NodeGroup.h"
@@ -36,10 +37,9 @@ void NodeGroup::AddChild(Node *iChild)
 int NodeGroup::destroy()
 {
   /*! Node::destroy makes a release on the object and then returns the reference counter.
-   *  If the reference counter is equal to 0, that means that nobody else is linking this node group and
-   *  that we can destroy the whole underlying tree.
-   *  Else, one or several Node link this node group, and we only returns the reference counter
-   *  decremented by Node::destroy();
+   *  If the reference counter is equal to 0, that means that nobody else is linking this node
+   * group and that we can destroy the whole underlying tree. Else, one or several Node link this
+   * node group, and we only returns the reference counter decremented by Node::destroy();
    */
   int refThis = Node::destroy();
 
index 89f81cc..f40deb1 100644 (file)
@@ -20,7 +20,8 @@
 /** \file
  * \ingroup freestyle
  * \brief Class to represent a group node. This node can contains several children.
- * \brief It also contains a transform matrix indicating the transform state of the underlying children.
+ * \brief It also contains a transform matrix indicating the transform state of the underlying
+ * children.
  */
 
 #include <vector>
index 69179eb..5452c23 100644 (file)
@@ -35,7 +35,7 @@ void NodeTransform::Translate(real x, real y, real z)
 
 void NodeTransform::Rotate(real iAngle, real x, real y, real z)
 {
-  //Normalize the x,y,z vector;
+  // Normalize the x,y,z vector;
   real norm = (real)sqrt(x * x + y * y + z * z);
   if (0 == norm)
     return;
index 94f6e1f..5b49243 100644 (file)
@@ -16,7 +16,8 @@
 
 /** \file
  * \ingroup freestyle
- * \brief Base class for all shapes. Inherits from BasicObjects for references counter management (addRef, release).
+ * \brief Base class for all shapes. Inherits from BasicObjects for references counter management
+ * (addRef, release).
  */
 
 #include "Rep.h"
index 7b5e752..2207842 100644 (file)
@@ -19,7 +19,8 @@
 
 /** \file
  * \ingroup freestyle
- * \brief Base class for all shapes. Inherits from BasicObjects for references counter management (addRef, release).
+ * \brief Base class for all shapes.
+ * Inherits from BasicObjects for references counter management (addRef, release).
  */
 
 #include <string>
@@ -111,8 +112,8 @@ class Rep : public BaseObject {
   }
 
   /*! Computes the rep bounding box.
-   *  Each Inherited rep must compute its bbox depending on the way the data are stored. So, each inherited class
-   *  must overload this method
+   *  Each Inherited rep must compute its bbox depending on the way the data are stored. So, each
+   * inherited class must overload this method
    */
   virtual void ComputeBBox() = 0;
 
index 24c710b..dcab48f 100644 (file)
@@ -38,15 +38,15 @@ namespace Functions0D {
 
 // DensityF0D
 /*! Returns the density of the (result) image evaluated at an Interface0D.
- *  This density is evaluated using a pixels square window around the evaluation point and integrating
- *  these values using a gaussian.
+ *  This density is evaluated using a pixels square window around the evaluation point and
+ * integrating these values using a gaussian.
  */
 class DensityF0D : public UnaryFunction0D<double> {
  public:
   /*! Builds the functor from the gaussian sigma value.
    *  \param sigma:
-   *    sigma indicates the x value for which the gaussian function is 0.5. It leads to the window size value.
-   *    (the larger, the smoother)
+   *    sigma indicates the x value for which the gaussian function is 0.5.
+   *    It leads to the window size value. (the larger, the smoother)
    */
   DensityF0D(double sigma = 2) : UnaryFunction0D<double>()
   {
index eadc899..fd97138 100644 (file)
@@ -104,14 +104,14 @@ int GetSteerableViewMapDensityF1D::operator()(Interface1D &inter)
 
 int GetDirectionalViewMapDensityF1D::operator()(Interface1D &inter)
 {
-  //soc unsigned size;
+  // soc unsigned size;
   result = integrate(_fun, inter.pointsBegin(_sampling), inter.pointsEnd(_sampling), _integration);
   return 0;
 }
 
 int GetCompleteViewMapDensityF1D::operator()(Interface1D &inter)
 {
-  //soc unsigned size;
+  // soc unsigned size;
   /* Id id = inter.getId(); */ /* UNUSED */
   result = integrate(_fun, inter.pointsBegin(_sampling), inter.pointsEnd(_sampling), _integration);
   return 0;
index 76a70d4..a1fd3fb 100644 (file)
@@ -37,8 +37,9 @@ namespace Functions1D {
 
 // DensityF1D
 /*! Returns the density evaluated for an Interface1D.
- *  The density is evaluated for a set of points along the Interface1D (using the DensityF0D functor) with a
- *  user-defined sampling and then integrated into a single value using a user-defined integration method.
+ *  The density is evaluated for a set of points along the Interface1D (using the DensityF0D
+ * functor) with a user-defined sampling and then integrated into a single value using a
+ * user-defined integration method.
  */
 class DensityF1D : public UnaryFunction1D<double> {
  private:
@@ -51,9 +52,9 @@ class DensityF1D : public UnaryFunction1D<double> {
    *  \param iType:
    *    The integration method used to compute a single value from a set of values.
    *  \param sampling:
-   *    The resolution used to sample the chain: the corresponding 0D function is evaluated at each sample point and
-   *    the result is obtained by combining the resulting values into a single one, following the method specified
-   *    by iType.
+   *    The resolution used to sample the chain: the corresponding 0D function is evaluated at each
+   * sample point and the result is obtained by combining the resulting values into a single one,
+   * following the method specified by iType.
    */
   DensityF1D(double sigma = 2, IntegrationType iType = MEAN, float sampling = 2.0f)
       : UnaryFunction1D<double>(iType), _fun(sigma)
@@ -86,8 +87,9 @@ class DensityF1D : public UnaryFunction1D<double> {
 
 // LocalAverageDepthF1D
 /*! Returns the average depth evaluated for an Interface1D.
- *  The average depth is evaluated for a set of points along the Interface1D (using the LocalAverageDepthF0D functor)
- *  with a user-defined sampling and then integrated into a single value using a user-defined integration method.
+ *  The average depth is evaluated for a set of points along the Interface1D (using the
+ * LocalAverageDepthF0D functor) with a user-defined sampling and then integrated into a single
+ * value using a user-defined integration method.
  */
 class LocalAverageDepthF1D : public UnaryFunction1D<double> {
  public:
@@ -121,8 +123,9 @@ class LocalAverageDepthF1D : public UnaryFunction1D<double> {
 
 // GetCompleteViewMapDensity
 /*! Returns the density evaluated for an Interface1D in the complete viewmap image.
- *  The density is evaluated for a set of points along the Interface1D (using the ReadCompleteViewMapPixelF0D functor)
- *  and then integrated into a single value using a user-defined integration method.
+ *  The density is evaluated for a set of points along the Interface1D (using the
+ * ReadCompleteViewMapPixelF0D functor) and then integrated into a single value using a
+ * user-defined integration method.
  */
 class GetCompleteViewMapDensityF1D : public UnaryFunction1D<double> {
  public:
@@ -162,7 +165,8 @@ class GetCompleteViewMapDensityF1D : public UnaryFunction1D<double> {
 // GetDirectionalViewMapDensity
 /*! Returns the density evaluated for an Interface1D in of the steerable viewmaps image.
  *  The direction telling which Directional map to choose is explicitly specified by the user.
- *  The density is evaluated for a set of points along the Interface1D (using the ReadSteerableViewMapPixelF0D functor)
+ *  The density is evaluated for a set of points along the Interface1D
+ *  (using the ReadSteerableViewMapPixelF0D functor)
  *  and then integrated into a single value using a user-defined integration method.
  */
 class GetDirectionalViewMapDensityF1D : public UnaryFunction1D<double> {
@@ -175,9 +179,9 @@ class GetDirectionalViewMapDensityF1D : public UnaryFunction1D<double> {
    *  \param iType:
    *    The integration method used to compute a single value from a set of values.
    *  \param sampling:
-   *    The resolution used to sample the chain: the corresponding 0D function is evaluated at each sample point and
-   *    the result is obtained by combining the resulting values into a single one, following the method specified
-   *    by iType.
+   *    The resolution used to sample the chain: the corresponding 0D function is evaluated at
+   *    each sample point and the result is obtained by combining the resulting values into a
+   *    single one, following the method specified by iType.
    */
   GetDirectionalViewMapDensityF1D(unsigned iOrientation,
                                   unsigned level,
@@ -203,8 +207,8 @@ class GetDirectionalViewMapDensityF1D : public UnaryFunction1D<double> {
 };
 
 // GetSteerableViewMapDensityF1D
-/*! Returns the density of the viewmap for a given Interface1D. The density of each FEdge is evaluated
- *  in the proper steerable ViewMap depending on its oorientation.
+/*! Returns the density of the viewmap for a given Interface1D. The density of each FEdge is
+ * evaluated in the proper steerable ViewMap depending on its oorientation.
  */
 class GetSteerableViewMapDensityF1D : public UnaryFunction1D<double> {
  private:
@@ -218,9 +222,9 @@ class GetSteerableViewMapDensityF1D : public UnaryFunction1D<double> {
    *  \param iType:
    *    The integration method used to compute a single value from a set of values.
    *  \param sampling:
-   *    The resolution used to sample the chain: the corresponding 0D function is evaluated at each sample point and
-   *    the result is obtained by combining the resulting values into a single one, following the method specified
-   *    by iType.
+   *    The resolution used to sample the chain: the corresponding 0D function is evaluated at each
+   * sample point and the result is obtained by combining the resulting values into a single one,
+   * following the method specified by iType.
    */
   GetSteerableViewMapDensityF1D(int level, IntegrationType iType = MEAN, float sampling = 2.0f)
       : UnaryFunction1D<double>(iType)
@@ -245,8 +249,8 @@ class GetSteerableViewMapDensityF1D : public UnaryFunction1D<double> {
 };
 
 // GetViewMapGradientNormF1D
-/*! Returns the density of the viewmap for a given Interface1D. The density of each FEdge is evaluated in
- *  the proper steerable ViewMap depending on its oorientation.
+/*! Returns the density of the viewmap for a given Interface1D. The density of each FEdge is
+ * evaluated in the proper steerable ViewMap depending on its oorientation.
  */
 class GetViewMapGradientNormF1D : public UnaryFunction1D<double> {
  private:
@@ -261,9 +265,9 @@ class GetViewMapGradientNormF1D : public UnaryFunction1D<double> {
    *  \param iType:
    *    The integration method used to compute a single value from a set of values.
    *  \param sampling:
-   *    The resolution used to sample the chain: the corresponding 0D function is evaluated at each sample point and
-   *    the result is obtained by combining the resulting values into a single one, following the method specified
-   *    by iType.
+   *    The resolution used to sample the chain: the corresponding 0D function is evaluated at each
+   *    sample point and the result is obtained by combining the resulting values into a single
+   *    one, following the method specified by iType.
    */
   GetViewMapGradientNormF1D(int level, IntegrationType iType = MEAN, float sampling = 2.0f)
       : UnaryFunction1D<double>(iType), _func(level)
index a788318..6a0d3b0 100644 (file)
@@ -261,7 +261,7 @@ void Smoother::iteration()
                            edgeStopping(diffC2, _anisoCurvature) *
                                diffC2;  //_factorCurvatureDifference;
     motionCurvature *= _factorCurvatureDifference;
-    //motionCurvature = _factorCurvatureDifference * (diffC1 + diffC2);
+    // motionCurvature = _factorCurvatureDifference * (diffC1 + diffC2);
     if (_safeTest)
       _vertex[i] = Vec2r(_vertex[i] + (motionNormal + motionCurvature) * _normal[i]);
     Vec2r v1(_vertex[i - 1] - _vertex[i]);
@@ -283,7 +283,7 @@ void Smoother::iteration()
                            edgeStopping(diffC2, _anisoCurvature) *
                                diffC2;  //_factorCurvatureDifference;
     motionCurvature *= _factorCurvatureDifference;
-    //motionCurvature = _factorCurvatureDifference * (diffC1 + diffC2);
+    // motionCurvature = _factorCurvatureDifference * (diffC1 + diffC2);
     _vertex[0] = Vec2r(_vertex[0] + (motionNormal + motionCurvature) * _normal[0]);
     _vertex[_nbVertices - 1] = _vertex[0];
   }
index 17b1805..8f05db2 100644 (file)
@@ -27,9 +27,9 @@
 namespace Freestyle {
 
 /*! [ Thickness Shader ].
- *  Assigns thicknesses to the stroke vertices so that the stroke looks like made with a calligraphic tool.
- *  i.e. The stroke will be the thickest in a main direction, the thinest in the direction perpendicular to this one,
- *  and an interpolation inbetween.
+ *  Assigns thicknesses to the stroke vertices so that the stroke looks like made with a
+ * calligraphic tool. i.e. The stroke will be the thickest in a main direction, the thinest in the
+ * direction perpendicular to this one, and an interpolation inbetween.
  */
 class CalligraphicShader : public StrokeShader {
  public:
@@ -103,9 +103,9 @@ class SpatialNoiseShader : public StrokeShader {
 /*! [ Geometry Shader ].
  *  Smoothes the stroke.
  *  (Moves the vertices to make the stroke smoother).
- *  Uses curvature flow to converge towards a curve of constant curvature. The diffusion method we use is anisotropic
- *  to prevent the diffusion accross corners.
- * \see \htmlonly <a href=/smoothing/smoothing.html>smoothing/smoothing.html</a> \endhtmlonly
+ *  Uses curvature flow to converge towards a curve of constant curvature. The diffusion method we
+ * use is anisotropic to prevent the diffusion accross corners. \see \htmlonly <a
+ * href=/smoothing/smoothing.html>smoothing/smoothing.html</a> \endhtmlonly
  */
 class SmoothingShader : public StrokeShader {
  public:
index 15541c1..9bdad9f 100644 (file)
@@ -57,7 +57,8 @@ int ConstantThicknessShader::shade(Stroke &stroke) const
   int i = 0;
   int size = stroke.strokeVerticesSize();
   for (v = stroke.strokeVerticesBegin(), vend = stroke.strokeVerticesEnd(); v != vend; ++v) {
-    // XXX What's the use of i here? And is not the thickness always overriden by the last line of the loop?
+    // XXX What's the use of i here? And is not the thickness always overriden by the last line of
+    // the loop?
     if ((1 == i) || (size - 2 == i))
       v->attribute().setThickness(_thickness / 4.0, _thickness / 4.0);
     if ((0 == i) || (size - 1 == i))
@@ -74,7 +75,8 @@ int ConstantExternThicknessShader::shade(Stroke &stroke) const
   int i = 0;
   int size = stroke.strokeVerticesSize();
   for (v = stroke.strokeVerticesBegin(), vend = stroke.strokeVerticesEnd(); v != vend; ++v) {
-    // XXX What's the use of i here? And is not the thickness always overriden by the last line of the loop?
+    // XXX What's the use of i here? And is not the thickness always overriden by the last line of
+    // the loop?
     if ((1 == i) || (size - 2 == i))
       v->attribute().setThickness(_thickness / 2.0, 0);
     if ((0 == i) || (size - 1 == i))
@@ -109,7 +111,8 @@ int ConstrainedIncreasingThicknessShader::shade(Stroke &stroke) const
   StrokeInternal::StrokeVertexIterator v, vend;
   for (i = 0, v = stroke.strokeVerticesBegin(), vend = stroke.strokeVerticesEnd(); v != vend;
        ++v, ++i) {
-    // XXX Why not using an if/else here? Else, if last condition is true, everything else is computed for nothing!
+    // XXX Why not using an if/else here? Else, if last condition is true, everything else is
+    // computed for nothing!
     float t;
     if (i < (float)n / 2.0f)
       t = (1.0 - (float)i / (float)n) * _ThicknessMin + (float)i / (float)n * maxT;
@@ -140,7 +143,8 @@ int LengthDependingThicknessShader::shade(Stroke &stroke) const
   int i = 0;
   int size = stroke.strokeVerticesSize();
   for (v = stroke.strokeVerticesBegin(), vend = stroke.strokeVerticesEnd(); v != vend; ++v) {
-    // XXX What's the use of i here? And is not the thickness always overriden by the last line of the loop?
+    // XXX What's the use of i here? And is not the thickness always overriden by the last line of
+    // the loop?
     if ((1 == i) || (size - 2 == i))
       v->attribute().setThickness(thickness / 4.0, thickness / 4.0);
     if ((0 == i) || (size - 1 == i))
@@ -337,7 +341,7 @@ int SamplingShader::shade(Stroke &stroke) const
 
 int ExternalContourStretcherShader::shade(Stroke &stroke) const
 {
-  //float l = stroke.getLength2D();
+  // float l = stroke.getLength2D();
   Interface0DIterator it;
   Functions0D::Normal2DF0D fun;
   StrokeVertex *sv;
@@ -362,7 +366,7 @@ int BezierCurveShader::shade(Stroke &stroke) const
   // Build the Bezier curve from this set of data points:
   vector<Vec2d> data;
   StrokeInternal::StrokeVertexIterator v = stroke.strokeVerticesBegin(), vend;
-  data.push_back(Vec2d(v->x(), v->y()));  //first one
+  data.push_back(Vec2d(v->x(), v->y()));  // first one
   StrokeInternal::StrokeVertexIterator previous = v;
   ++v;
   for (vend = stroke.strokeVerticesEnd(); v != vend; ++v) {
@@ -562,7 +566,7 @@ int PolygonalizationShader::shade(Stroke &stroke) const
     Vec2d u = (*cp)->B - (*cp)->A;
     Vec2d n(u[1], -u[0]);
     n.normalize();
-    //Vec2d n(0, 0);
+    // Vec2d n(0, 0);
     float offset = ((*cp)->_error);
     StrokeInternal::StrokeVertexIterator v;
     for (v = a; v != b; ++v) {
@@ -653,7 +657,7 @@ int TipRemoverShader::shade(Stroke &stroke) const
   // Resample so that our new stroke have the same number of vertices than before
   stroke.Resample(originalSize);
 
-  if ((int)stroke.strokeVerticesSize() != originalSize)  //soc
+  if ((int)stroke.strokeVerticesSize() != originalSize)  // soc
     cerr << "Warning: resampling problem" << endl;
 
   // assign old attributes to new stroke vertices:
index e128817..db57384 100644 (file)
@@ -81,9 +81,9 @@ class ConstantThicknessShader : public StrokeShader {
 };
 
 /* [ Thickness Shader ].
- *  Assigns an absolute constant external thickness to every vertices of the Stroke. The external thickness of a point
- *  is its thickness from the point to the strip border in the direction pointing outside the object the
- *  Stroke delimitates.
+ *  Assigns an absolute constant external thickness to every vertices of the Stroke. The external
+ * thickness of a point is its thickness from the point to the strip border in the direction
+ * pointing outside the object the Stroke delimitates.
  */
 class ConstantExternThicknessShader : public StrokeShader {
  public:
@@ -108,10 +108,10 @@ class ConstantExternThicknessShader : public StrokeShader {
 };
 
 /*! [ Thickness Shader ].
- *  Assigns thicknesses values such as the thickness increases from a thickness value A to a thickness value B between
- *  the first vertex to the midpoint vertex and then decreases from B to a A between this midpoint vertex
- *  and the last vertex.
- *  The thickness is linearly interpolated from A to B.
+ *  Assigns thicknesses values such as the thickness increases from a thickness value A to a
+ * thickness value B between the first vertex to the midpoint vertex and then decreases from B to a
+ * A between this midpoint vertex and the last vertex. The thickness is linearly interpolated from
+ * A to B.
  */
 class IncreasingThicknessShader : public StrokeShader {
  public:
@@ -146,8 +146,8 @@ class IncreasingThicknessShader : public StrokeShader {
 };
 
 /*! [ Thickness shader ].
- *  Same as previous but here we allow the user to control the ratio thickness/length so that  we don't get
- *  fat short lines
+ *  Same as previous but here we allow the user to control the ratio thickness/length so that  we
+ * don't get fat short lines
  */
 class ConstrainedIncreasingThicknessShader : public StrokeShader {
  private:
@@ -288,8 +288,8 @@ class ConstantColorShader : public StrokeShader {
 
 /*!  [ Color Shader ].
  *   Assigns a varying color to the stroke.
- *   The user specifies 2 colors A and B. The stroke color will change linearly from A to B between the
- *   first and the last vertex.
+ *   The user specifies 2 colors A and B. The stroke color will change linearly from A to B between
+ * the first and the last vertex.
  */
 class IncreasingColorShader : public StrokeShader {
  private:
@@ -346,7 +346,8 @@ class IncreasingColorShader : public StrokeShader {
 };
 
 /* [ Color Shader ].
- *  Assigns a color to the stroke depending on the material of the shape to which ot belongs to. (Disney shader)
+ *  Assigns a color to the stroke depending on the material of the shape to which ot belongs to.
+ * (Disney shader)
  */
 class MaterialColorShader : public StrokeShader {
  private:
@@ -399,7 +400,8 @@ class ColorNoiseShader : public StrokeShader {
 //
 ///////////////////////////////////////////////////////////////////////////////
 /*! [ Geometry Shader ].
- *  Stretches the stroke at its two extremities and following the respective directions: v(1)v(0) and v(n-1)v(n).
+ *  Stretches the stroke at its two extremities and following the respective directions: v(1)v(0)
+ * and v(n-1)v(n).
  */
 class BackboneStretcherShader : public StrokeShader {
  private:
@@ -471,9 +473,9 @@ class ExternalContourStretcherShader : public StrokeShader {
 
 // Bezier curve stroke shader
 /*! [ Geometry Shader ].
- *  Transforms the stroke backbone geometry so that it corresponds to a Bezier Curve approximation of the
- *  original backbone geometry.
- * \see \htmlonly <a href=bezier/bezier.html>bezier/bezier.html</a> \endhtmlonly
+ *  Transforms the stroke backbone geometry so that it corresponds to a Bezier Curve approximation
+ * of the original backbone geometry. \see \htmlonly <a
+ * href=bezier/bezier.html>bezier/bezier.html</a> \endhtmlonly
  */
 class BezierCurveShader : public StrokeShader {
  private:
@@ -501,8 +503,9 @@ class BezierCurveShader : public StrokeShader {
 
 /*! [ Geometry Shader ].
  *  Shader to modify the Stroke geometry so that it looks more "polygonal".
- *  The basic idea is to start from the minimal stroke approximation consisting in a line joining the first vertex
- *  to the last one and to subdivide using the original stroke vertices until a certain error is reached.
+ *  The basic idea is to start from the minimal stroke approximation consisting in a line joining
+ * the first vertex to the last one and to subdivide using the original stroke vertices until a
+ * certain error is reached.
  */
 class PolygonalizationShader : public StrokeShader {
  private:
@@ -511,9 +514,9 @@ class PolygonalizationShader : public StrokeShader {
  public:
   /*! Builds the shader.
    *  \param iError:
-   *    The error we want our polygonal approximation to have with respect to the original geometry.
-   *    The smaller, the closer the new stroke to the orinal one.
-   *    This error corresponds to the maximum distance between the new stroke and the old one.
+   *    The error we want our polygonal approximation to have with respect to the original
+   * geometry. The smaller, the closer the new stroke to the orinal one. This error corresponds to
+   * the maximum distance between the new stroke and the old one.
    */
   PolygonalizationShader(float iError) : StrokeShader()
   {
@@ -542,8 +545,9 @@ class GuidingLinesShader : public StrokeShader {
  public:
   /*! Builds a Guiding Lines shader
    *    \param iOffset:
-   *      The line that replaces the stroke is initially in the middle of the initial stroke "bbox".
-   *      iOffset is the value of the displacement which is applied to this line along its normal.
+   *      The line that replaces the stroke is initially in the middle of the initial stroke
+   * "bbox". iOffset is the value of the displacement which is applied to this line along its
+   * normal.
    */
   GuidingLinesShader(float iOffset) : StrokeShader()
   {
index b497b47..95bbafc 100644 (file)
@@ -38,8 +38,8 @@
 
 #include "BKE_global.h"
 
-//soc #include <qimage.h>
-//soc #include <QString>
+// soc #include <qimage.h>
+// soc #include <QString>
 
 extern "C" {
 #include "IMB_imbuf.h"
@@ -325,7 +325,7 @@ void Canvas::loadMap(const char *iFileName,
     filePath = iFileName;
   }
 
-#if 0  //soc
+#if 0  // soc
   QImage *qimg;
   QImage newMap(filePath.c_str());
   if (newMap.isNull()) {
@@ -402,7 +402,7 @@ void Canvas::loadMap(const char *iFileName,
   GaussianPyramid *pyramid = new GaussianPyramid(tmp, iNbLevels, iSigma);
   int ow = pyramid->width(0);
   int oh = pyramid->height(0);
-  string base(iMapName);  //soc
+  string base(iMapName);  // soc
   for (int i = 0; i < pyramid->getNumberOfLevels(); ++i) {
     // save each image:
 #if 0
@@ -410,19 +410,19 @@ void Canvas::loadMap(const char *iFileName,
     h = pyramid.height(i);
 #endif
 
-    //soc  QImage qtmp(ow, oh, QImage::Format_RGB32);
+    // soc  QImage qtmp(ow, oh, QImage::Format_RGB32);
     ImBuf *qtmp = IMB_allocImBuf(ow, oh, 32, IB_rect);
 
-    //int k = (1 << i);
+    // int k = (1 << i);
     for (y = 0; y < oh; ++y) {
       for (x = 0; x < ow; ++x) {
         int c = pyramid->pixel(x, y, i);  // 255 * pyramid->pixel(x, y, i);
-        //soc qtmp.setPixel(x, y, qRgb(c, c, c));
+        // soc qtmp.setPixel(x, y, qRgb(c, c, c));
         pix = (char *)qtmp->rect + y * rowbytes + x * 4;
         pix[0] = pix[1] = pix[2] = c;
       }
     }
-    //soc qtmp.save(base + QString::number(i) + ".bmp", "BMP");
+    // soc qtmp.save(base + QString::number(i) + ".bmp", "BMP");
     stringstream filename;
     filename << base;
     filename << i << ".bmp";
@@ -443,7 +443,7 @@ void Canvas::loadMap(const char *iFileName,
 #endif
 
   _maps[iMapName] = pyramid;
-  //newMap->save("toto.bmp", "BMP");
+  // newMap->save("toto.bmp", "BMP");
 }
 
 float Canvas::readMapPixel(const char *iMapName, int level, int x, int y)
index e059bb0..2a0ebbe 100644 (file)
@@ -137,8 +137,8 @@ class Canvas {
   }
 
   /* Maps management */
-  /*! Loads an image map. The map will be scaled (without preserving the ratio in order to fit the actual
-   *  canvas size.).
+  /*! Loads an image map. The map will be scaled
+   *  (without preserving the ratio in order to fit the actual canvas size.).
    *  The image must be a gray values image...
    *  \param iFileName:
    *    The name of the image file
@@ -160,9 +160,11 @@ class Canvas {
    *  \param level:
    *    The level of the pyramid from which the pixel must be read.
    *  \param x:
-   *    The abscissa of the desired pixel specified in level0 coordinate system. The origin is the lower left corner.
+   *    The abscissa of the desired pixel specified in level0 coordinate system.
+   *    The origin is the lower left corner.
    *  \param y:
-   *    The ordinate of the desired pixel specified in level0 coordinate system. The origin is the lower left corner.
+   *    The ordinate of the desired pixel specified in level0 coordinate system.
+   *    The origin is the lower left corner.
    */
   float readMapPixel(const char *iMapName, int level, int x, int y);
 
index 32b3ec2..d4cc4fd 100644 (file)
@@ -76,7 +76,7 @@ void Chain::push_viewedge_back(ViewEdge *iViewEdge, bool orientation)
   } while ((v != vend) && (v != vfirst));
 
   if (v == vfirst) {
-    //Add last one:
+    // Add last one:
     current = (*v)->point2d();
     Curve::push_vertex_back(*v);
     //_Length += (current - previous).norm();
@@ -138,7 +138,7 @@ void Chain::push_viewedge_front(ViewEdge *iViewEdge, bool orientation)
   } while ((v != vend) && (v != vfirst));
 
   if (v == vfirst) {
-    //Add last one:
+    // Add last one:
     current = (*v)->point2d();
     Curve::push_vertex_front(*v);
     //_Length += (current - previous).norm();
index de6c50f..551b9aa 100644 (file)
@@ -143,10 +143,11 @@ int ChainSilhouetteIterator::traverse(const AdjacencyIterator &ait)
     return 0;
   }
   if (nextVertex->getNature() & Nature::NON_T_VERTEX) {
-    //soc NonTVertex *nontvertex = (NonTVertex*)nextVertex;
+    // soc NonTVertex *nontvertex = (NonTVertex*)nextVertex;
     ViewEdge *newEdge(0);
     // we'll try to chain the edges by keeping the same nature...
-    // the preseance order is : SILHOUETTE, BORDER, CREASE, MATERIAL_BOUNDARY, EDGE_MARK, SUGGESTIVE, VALLEY, RIDGE
+    // the preseance order is : SILHOUETTE, BORDER, CREASE, MATERIAL_BOUNDARY, EDGE_MARK,
+    // SUGGESTIVE, VALLEY, RIDGE
     Nature::EdgeNature natures[8] = {
         Nature::SILHOUETTE,
         Nature::BORDER,
index 57a73c6..94b4108 100644 (file)
@@ -32,7 +32,7 @@
 #include "../view_map/ViewMapIterators.h"
 #include "../view_map/ViewMapAdvancedIterators.h"
 
-//using namespace ViewEdgeInternal;
+// using namespace ViewEdgeInternal;
 
 namespace Freestyle {
 
@@ -98,7 +98,8 @@ class AdjacencyIterator : public Iterator {
     return _internalIterator.isBegin();
   }
 
-  /*! Returns true if the current ViewEdge is coming towards the iteration vertex. False otherwise. */
+  /*! Returns true if the current ViewEdge is coming towards the iteration vertex. False otherwise.
+   */
   bool isIncoming() const;
 
   /*! Returns a *pointer* to the pointed ViewEdge. */
@@ -144,14 +145,15 @@ class AdjacencyIterator : public Iterator {
  *  It makes the works of chaining rules description easier.
  *  The two main methods that need to overloaded are traverse() and init().
  *  traverse() tells which ViewEdge to follow, among the adjacent ones.
- *  If you specify restriction rules (such as "Chain only ViewEdges of the selection"), they will be included
- *  in the adjacency iterator. (i.e, the adjacent iterator will only stop on "valid" edges).
+ *  If you specify restriction rules (such as "Chain only ViewEdges of the selection"), they will
+ * be included in the adjacency iterator. (i.e, the adjacent iterator will only stop on "valid"
+ * edges).
  */
 class ChainingIterator : public ViewEdgeInternal::ViewEdgeIterator {
  protected:
   bool _restrictToSelection;
   bool _restrictToUnvisited;
-  bool _increment;  //true if we're currently incrementing, false when decrementing
+  bool _increment;  // true if we're currently incrementing, false when decrementing
 
  public:
   ViewEdge *result;
@@ -159,13 +161,11 @@ class ChainingIterator : public ViewEdgeInternal::ViewEdgeIterator {
 
   /*! Builds a Chaining Iterator from the first ViewEdge used for iteration and its orientation.
    *  \param iRestrictToSelection:
-   *    Indicates whether to force the chaining to stay within the set of selected ViewEdges or not.
-   *  \param iRestrictToUnvisited:
-   *    Indicates whether a ViewEdge that has already been chained must be ignored ot not.
-   *  \param begin:
-   *    The ViewEdge from which to start the chain.
-   *  \param orientation:
-   *    The direction to follow to explore the graph. If true, the direction indicated by the first ViewEdge is used.
+   *    Indicates whether to force the chaining to stay within the set of selected ViewEdges or
+   * not. \param iRestrictToUnvisited: Indicates whether a ViewEdge that has already been chained
+   * must be ignored ot not. \param begin: The ViewEdge from which to start the chain. \param
+   * orientation: The direction to follow to explore the graph. If true, the direction indicated by
+   * the first ViewEdge is used.
    */
   ChainingIterator(bool iRestrictToSelection = true,
                    bool iRestrictToUnvisited = true,
@@ -200,17 +200,19 @@ class ChainingIterator : public ViewEdgeInternal::ViewEdgeIterator {
    */
   virtual int init();
 
-  /*! This method iterates over the potential next ViewEdges and returns the one that will be followed next.
-   *  returns the next ViewEdge to follow or 0 when the end of the chain is reached.
+  /*! This method iterates over the potential next ViewEdges and returns the one that will be
+   * followed next. returns the next ViewEdge to follow or 0 when the end of the chain is reached.
    *  \param it:
    *    The iterator over the ViewEdges adjacent to the end vertex of the current ViewEdge.
-   *    The Adjacency iterator reflects the restriction rules by only iterating over the valid ViewEdges.
+   *    The Adjacency iterator reflects the restriction rules by only iterating over the valid
+   * ViewEdges.
    */
   virtual int traverse(const AdjacencyIterator &it);
 
   /* accessors */
-  /*! Returns true if the orientation of the current ViewEdge corresponds to its natural orientation */
-  //inline bool getOrientation() const {}
+  /*! Returns true if the orientation of the current ViewEdge corresponds to its natural
+   * orientation */
+  // inline bool getOrientation() const {}
 
   /*! Returns the vertex which is the next crossing */
   inline ViewVertex *getVertex()
@@ -251,20 +253,18 @@ class ChainingIterator : public ViewEdgeInternal::ViewEdgeIterator {
 
 /*! A ViewEdge Iterator used to follow ViewEdges the most naturally.
  *  For example, it will follow visible ViewEdges of same nature.
- *  As soon, as the nature or the visibility changes, the iteration stops (by setting the pointed ViewEdge to 0).
- *  In the case of an iteration over a set of ViewEdge that are both Silhouette and Crease, there will be a precedence
- *  of the silhouette over the crease criterion.
+ *  As soon, as the nature or the visibility changes, the iteration stops (by setting the pointed
+ * ViewEdge to 0). In the case of an iteration over a set of ViewEdge that are both Silhouette and
+ * Crease, there will be a precedence of the silhouette over the crease criterion.
  */
 class ChainSilhouetteIterator : public ChainingIterator {
  public:
-  /*! Builds a ChainSilhouetteIterator from the first ViewEdge used for iteration and its orientation.
-   *  \param iRestrictToSelection:
-   *    Indicates whether to force the chaining to stay within the set of selected ViewEdges or not.
-   *  \param begin:
-   *    The ViewEdge from where to start the iteration.
-   *  \param orientation:
-   *    If true, we'll look for the next ViewEdge among the ViewEdges that surround the ending ViewVertex of begin.
-   *    If false, we'll search over the ViewEdges surrounding the ending ViewVertex of begin.
+  /*! Builds a ChainSilhouetteIterator from the first ViewEdge used for iteration and its
+   * orientation. \param iRestrictToSelection: Indicates whether to force the chaining to stay
+   * within the set of selected ViewEdges or not. \param begin: The ViewEdge from where to start
+   * the iteration. \param orientation: If true, we'll look for the next ViewEdge among the
+   * ViewEdges that surround the ending ViewVertex of begin. If false, we'll search over the
+   * ViewEdges surrounding the ending ViewVertex of begin.
    */
   ChainSilhouetteIterator(bool iRestrictToSelection = true,
                           ViewEdge *begin = NULL,
@@ -284,8 +284,8 @@ class ChainSilhouetteIterator : public ChainingIterator {
     return "ChainSilhouetteIterator";
   }
 
-  /*! This method iterates over the potential next ViewEdges and returns the one that will be followed next.
-   *  When reaching the end of a chain, 0 is returned.
+  /*! This method iterates over the potential next ViewEdges and returns the one that will be
+   * followed next. When reaching the end of a chain, 0 is returned.
    */
   virtual int traverse(const AdjacencyIterator &it);
 
@@ -301,13 +301,13 @@ class ChainSilhouetteIterator : public ChainingIterator {
 //
 ///////////////////////////////////////////////////////////
 
-/*! A "generic" user-controlled ViewEdge iterator. This iterator is in particular built from a unary predicate and
- *  a binary predicate.
- *  First, the unary predicate is evaluated for all potential next ViewEdges in order to only keep the ones respecting
- *  a certain constraint.
- *  Then, the binary predicate is evaluated on the current ViewEdge together with each ViewEdge of the previous
- *  selection. The first ViewEdge respecting both the unary predicate and the binary predicate is kept as the next one.
- *  If none of the potential next ViewEdge respects these 2 predicates, 0 is returned.
+/*! A "generic" user-controlled ViewEdge iterator. This iterator is in particular built from a
+ * unary predicate and a binary predicate. First, the unary predicate is evaluated for all
+ * potential next ViewEdges in order to only keep the ones respecting a certain constraint. Then,
+ * the binary predicate is evaluated on the current ViewEdge together with each ViewEdge of the
+ * previous selection. The first ViewEdge respecting both the unary predicate and the binary
+ * predicate is kept as the next one. If none of the potential next ViewEdge respects these 2
+ * predicates, 0 is returned.
  */
 class ChainPredicateIterator : public ChainingIterator {
  protected:
@@ -318,14 +318,12 @@ class ChainPredicateIterator : public ChainingIterator {
  public:
   /*! Builds a ChainPredicateIterator from a starting ViewEdge and its orientation.
    *  \param iRestrictToSelection:
-   *    Indicates whether to force the chaining to stay within the set of selected ViewEdges or not.
-   *  \param iRestrictToUnvisited:
-   *    Indicates whether a ViewEdge that has already been chained must be ignored ot not.
-   *  \param begin:
-   *    The ViewEdge from where to start the iteration.
-   *  \param orientation:
-   *    If true, we'll look for the next ViewEdge among the ViewEdges that surround the ending ViewVertex of begin.
-   *    If false, we'll search over the ViewEdges surrounding the ending ViewVertex of begin.
+   *    Indicates whether to force the chaining to stay within the set of selected ViewEdges or
+   * not. \param iRestrictToUnvisited: Indicates whether a ViewEdge that has already been chained
+   * must be ignored ot not. \param begin: The ViewEdge from where to start the iteration. \param
+   * orientation: If true, we'll look for the next ViewEdge among the ViewEdges that surround the
+   * ending ViewVertex of begin. If false, we'll search over the ViewEdges surrounding the ending
+   * ViewVertex of begin.
    */
   ChainPredicateIterator(bool iRestrictToSelection = true,
                          bool iRestrictToUnvisited = true,
@@ -337,21 +335,18 @@ class ChainPredicateIterator : public ChainingIterator {
     _unary_predicate = 0;
   }
 
-  /*! Builds a ChainPredicateIterator from a unary predicate, a binary predicate, a starting ViewEdge and
-   *  its orientation.
-   *  \param iRestrictToSelection:
-   *    Indicates whether to force the chaining to stay within the set of selected ViewEdges or not.
-   *  \param iRestrictToUnvisited:
+  /*! Builds a ChainPredicateIterator from a unary predicate, a binary predicate, a starting
+   * ViewEdge and its orientation. \param iRestrictToSelection: Indicates whether to force the
+   * chaining to stay within the set of selected ViewEdges or not. \param iRestrictToUnvisited:
    *    Indicates whether a ViewEdge that has already been chained must be ignored ot not.
    *  \param upred:
    *    The unary predicate that the next ViewEdge must satisfy.
    *  \param bpred:
-   *    The binary predicate that the next ViewEdge must satisfy together with the actual pointed ViewEdge.
-   *  \param begin:
-   *    The ViewEdge from where to start the iteration.
-   *  \param orientation:
-   *    If true, we'll look for the next ViewEdge among the ViewEdges that surround the ending ViewVertex of begin.
-   *    If false, we'll search over the ViewEdges surrounding the ending ViewVertex of begin.
+   *    The binary predicate that the next ViewEdge must satisfy together with the actual pointed
+   * ViewEdge. \param begin: The ViewEdge from where to start the iteration. \param orientation: If
+   * true, we'll look for the next ViewEdge among the ViewEdges that surround the ending ViewVertex
+   * of begin. If false, we'll search over the ViewEdges surrounding the ending ViewVertex of
+   * begin.
    */
   ChainPredicateIterator(UnaryPredicate1D &upred,
                          BinaryPredicate1D &bpred,
@@ -385,8 +380,8 @@ class ChainPredicateIterator : public ChainingIterator {
     return "ChainPredicateIterator";
   }
 
-  /*! This method iterates over the potential next ViewEdges and returns the one that will be followed next.
-   *  When reaching the end of a chain, 0 is returned.
+  /*! This method iterates over the potential next ViewEdges and returns the one that will be
+   * followed next. When reaching the end of a chain, 0 is returned.
    */
   virtual int traverse(const AdjacencyIterator &it);
 
index a0709b0..fe61764 100644 (file)
@@ -527,7 +527,7 @@ Curve::point_iterator Curve::points_begin(float step)
   ++second;
   return point_iterator(
       _Vertices.begin(), second, _Vertices.begin(), _Vertices.end(), _nSegments, step, 0.0f, 0.0f);
-  //return point_iterator(_Vertices.begin(), second, _nSegments, step, 0.0f, 0.0f);
+  // return point_iterator(_Vertices.begin(), second, _nSegments, step, 0.0f, 0.0f);
 }
 
 Curve::const_point_iterator Curve::points_begin(float step) const
@@ -536,7 +536,7 @@ Curve::const_point_iterator Curve::points_begin(float step) const
   ++second;
   return const_point_iterator(
       _Vertices.begin(), second, _Vertices.begin(), _Vertices.end(), _nSegments, step, 0.0f, 0.0f);
-  //return const_point_iterator(_Vertices.begin(), second, _nSegments, step, 0.0f, 0.0f);
+  // return const_point_iterator(_Vertices.begin(), second, _nSegments, step, 0.0f, 0.0f);
 }
 
 Curve::point_iterator Curve::points_end(float step)
@@ -549,7 +549,7 @@ Curve::point_iterator Curve::points_end(float step)
                         step,
                         1.0f,
                         _Length);
-  //return point_iterator(_Vertices.end(), _Vertices.end(), _nSegments, step, 1.0f, _Length);
+  // return point_iterator(_Vertices.end(), _Vertices.end(), _nSegments, step, 1.0f, _Length);
 }
 
 Curve::const_point_iterator Curve::points_end(float step) const
@@ -562,7 +562,8 @@ Curve::const_point_iterator Curve::points_end(float step) const
                               step,
                               1.0f,
                               _Length);
-  //return const_point_iterator(_Vertices.end(), _Vertices.end(), _nSegments, step, 1.0f, _Length);
+  // return const_point_iterator(_Vertices.end(), _Vertices.end(), _nSegments, step, 1.0f,
+  // _Length);
 }
 
 // Adavnced Iterators access
index 2a1d80f..b84ce45 100644 (file)
@@ -55,10 +55,10 @@ using namespace Geometry;
 
 /*! Class to represent a point of a curve.
  *  A CurvePoint can be any point of a 1D curve (it doesn't have to be a vertex of the curve).
- *  Any Interface1D is built upon ViewEdges, themselves built upon FEdges. Therefore, a curve is basically
- *  a polyline made of a list SVertex.
- *  Thus, a CurvePoint is built by lineraly interpolating two SVertex.
- *  CurvePoint can be used as virtual points while querying 0D information along a curve at a given resolution.
+ *  Any Interface1D is built upon ViewEdges, themselves built upon FEdges. Therefore, a curve is
+ * basically a polyline made of a list SVertex. Thus, a CurvePoint is built by lineraly
+ * interpolating two SVertex. CurvePoint can be used as virtual points while querying 0D
+ * information along a curve at a given resolution.
  */
 class CurvePoint : public Interface0D {
  public:  // Implementation of Interface0D
@@ -188,7 +188,7 @@ class CurvePoint : public Interface0D {
   SVertex *__A;
   SVertex *__B;
   float _t2d;
-  //float _t3d;
+  // float _t3d;
   Vec3r _Point2d;
   Vec3r _Point3d;
 
@@ -216,7 +216,7 @@ class CurvePoint : public Interface0D {
    */
   CurvePoint(CurvePoint *iA, CurvePoint *iB, float t2d);
 
-  //CurvePoint(SVertex *iA, SVertex *iB, float t2d, float t3d);
+  // CurvePoint(SVertex *iA, SVertex *iB, float t2d, float t3d);
 
   /*! Copy Constructor. */
   CurvePoint(const CurvePoint &iBrother);
@@ -302,12 +302,12 @@ class CurvePoint : public Interface0D {
   }
 
   Vec3r normal() const;
-  //FrsMaterial material() const;
-  //Id shape_id() const;
+  // FrsMaterial material() const;
+  // Id shape_id() const;
   const SShape *shape() const;
-  //float shape_importance() const;
+  // float shape_importance() const;
 
-  //const unsigned qi() const;
+  // const unsigned qi() const;
   occluder_container::const_iterator occluders_begin() const;
   occluder_container::const_iterator occluders_end() const;
   bool occluders_empty() const;
@@ -564,25 +564,25 @@ class Curve : public Interface1D {
   CurveInternal::CurvePointIterator curveVerticesEnd();
 
   // Iterators access
-  /*! Returns an Interface0DIterator pointing onto the first vertex of the Curve and that can iterate
-   *  over the \a vertices of the Curve.
+  /*! Returns an Interface0DIterator pointing onto the first vertex of the Curve and that can
+   * iterate over the \a vertices of the Curve.
    */
   virtual Interface0DIterator verticesBegin();
 
-  /*! Returns an Interface0DIterator pointing after the last vertex of the Curve and that can iterate
-   *  over the \a vertices of the Curve.
+  /*! Returns an Interface0DIterator pointing after the last vertex of the Curve and that can
+   * iterate over the \a vertices of the Curve.
    */
   virtual Interface0DIterator verticesEnd();
 
-  /*! Returns an Interface0DIterator pointing onto the first point of the Curve and that can iterate
-   *  over the \a points of the Curve at any resolution.
-   *  At each iteration a virtual temporary CurvePoint is created.
+  /*! Returns an Interface0DIterator pointing onto the first point of the Curve and that can
+   * iterate over the \a points of the Curve at any resolution. At each iteration a virtual
+   * temporary CurvePoint is created.
    */
   virtual Interface0DIterator pointsBegin(float t = 0.0f);
 
-  /*! Returns an Interface0DIterator pointing after the last point of the Curve and that can iterate
-   *  over the \a points of the Curve at any resolution.
-   *  At each iteration a virtual temporary CurvePoint is created.
+  /*! Returns an Interface0DIterator pointing after the last point of the Curve and that can
+   * iterate over the \a points of the Curve at any resolution. At each iteration a virtual
+   * temporary CurvePoint is created.
    */
   virtual Interface0DIterator pointsEnd(float t = 0.0f);
 
index f993c21..5cbdd26 100644 (file)
@@ -50,8 +50,8 @@ class CurvePoint_nonconst_traits : public Nonconst_traits<CurvePoint *> {
 /*                                */
 /**********************************/
 
-/*! iterator on a curve. Allows an iterating outside  initial vertices. A CurvePoint is instanciated an returned
- *  when the iterator is dereferenced.
+/*! iterator on a curve. Allows an iterating outside  initial vertices. A CurvePoint is
+ * instanciated an returned when the iterator is dereferenced.
  */
 template<class Traits>
 class __point_iterator : public IteratorBase<Traits, BidirectionalIteratorTag_Traits> {
@@ -86,7 +86,7 @@ class __point_iterator : public IteratorBase<Traits, BidirectionalIteratorTag_Tr
   friend class __point_iterator<CurvePoint_nonconst_traits>;
   friend class iterator;
 #endif
-  //protected:
+  // protected:
  public:
   float _CurvilinearLength;
   float _step;
@@ -169,7 +169,7 @@ class __point_iterator : public IteratorBase<Traits, BidirectionalIteratorTag_Tr
       delete _Point;
   }
 
-  //protected:  //FIXME
+  // protected:  //FIXME
  public:
   inline __point_iterator(vertex_container_iterator iA,
                           vertex_container_iterator iB,
@@ -307,7 +307,7 @@ class __point_iterator : public IteratorBase<Traits, BidirectionalIteratorTag_Tr
     else {
       _t = 1.0f;  // AB is a null segment, we're directly at its end
     }
-    //if normAB ~= 0, we don't change these values
+    // if normAB ~= 0, we don't change these values
     if (_t >= 1) {
       _CurvilinearLength -= normAB * (_t - 1);
       if (_currentn == _n - 1) {
index 428ea02..b05c983 100644 (file)
@@ -187,7 +187,7 @@ class CurvePointIterator : public Interface0DIteratorNested {
     return false;
   }
 
-  //protected:
+  // protected:
   virtual int increment()
   {
     if ((_currentn == _n - 1) && (_t == 1.0f)) {
@@ -223,7 +223,7 @@ class CurvePointIterator : public Interface0DIteratorNested {
     else {
       _t = 1.0f;  // AB is a null segment, we're directly at its end
     }
-    //if normAB ~= 0, we don't change these values
+    // if normAB ~= 0, we don't change these values
     if (_t >= 1) {
       _CurvilinearLength -= normAB * (_t - 1);
       if (_currentn == _n - 1) {
@@ -241,7 +241,7 @@ class CurvePointIterator : public Interface0DIteratorNested {
 
   virtual int decrement()
   {
-    if (_t == 0.0f) {  //we're at the beginning of the edge
+    if (_t == 0.0f) {  // we're at the beginning of the edge
       _t = 1.0f;
       --_currentn;
       --__A;
index fc4d099..0374e60 100644 (file)
@@ -278,7 +278,7 @@ void Operators::bidirectionalChain(ViewEdgeIterator &it, UnaryPredicate1D &pred)
 
     Chain *new_chain = new Chain(id);
     ++id;
-#  if 0  //FIXME
+#  if 0  // FIXME
     ViewEdgeIterator it_back(it);
     --it_back;
 #  endif
@@ -841,7 +841,7 @@ static int __recursiveSplit(Chain *_curve,
   real _min = FLT_MAX;
   ++it;
   real mean = 0.f;
-  //soc unused - real variance                              = 0.0f;
+  // soc unused - real variance                              = 0.0f;
   unsigned count = 0;
   CurveInternal::CurvePointIterator next = it;
   ++next;
@@ -865,7 +865,7 @@ static int __recursiveSplit(Chain *_curve,
   }
   mean /= (float)count;
 
-  //if ((!bsplit) || (mean - _min > mean)) { // we didn't find any minimum
+  // if ((!bsplit) || (mean - _min > mean)) { // we didn't find any minimum
   if (!bsplit) {  // we didn't find any minimum
     newChains.push_back(_curve);
     return 0;
@@ -1210,7 +1210,7 @@ inline int applyShading(Stroke &stroke, vector<StrokeShader *> &shaders)
 
 int Operators::create(UnaryPredicate1D &pred, vector<StrokeShader *> shaders)
 {
-  //Canvas* canvas = Canvas::getInstance();
+  // Canvas* canvas = Canvas::getInstance();
   if (!_current_set) {
     cerr << "Warning: current set empty" << endl;
     return 0;
@@ -1229,7 +1229,7 @@ int Operators::create(UnaryPredicate1D &pred, vector<StrokeShader *> shaders)
         delete stroke;
         goto error;
       }
-      //canvas->RenderStroke(stroke);
+      // canvas->RenderStroke(stroke);
       new_strokes_set.push_back(stroke);
     }
   }
index 9d63108..517f63e 100644 (file)
@@ -43,8 +43,9 @@
 namespace Freestyle {
 
 /*! Class defining the operators used in a style module.
- *  There are 4 classes of operators: Selection, Chaining, Splitting and Creating. All these operators are
- *  user controlled in the scripting language through Functors, Predicates and Shaders that are taken as arguments.
+ *  There are 4 classes of operators: Selection, Chaining, Splitting and Creating. All these
+ * operators are user controlled in the scripting language through Functors, Predicates and Shaders
+ * that are taken as arguments.
  */
 class Operators {
 
@@ -63,146 +64,127 @@ class Operators {
   static int select(UnaryPredicate1D &pred);
 
   /*! Builds a set of chains from the current set of ViewEdges.
-   *  Each ViewEdge of the current list starts a new chain. The chaining operator then iterates over the ViewEdges
-   *  of the ViewMap using the user specified iterator.
-   *  This operator only iterates using the increment operator and is therefore unidirectional.
-   *  \param it:
-   *           The iterator on the ViewEdges of the ViewMap. It contains the chaining rule.
-   *  \param pred:
-   *           The predicate on the ViewEdge that expresses the stopping condition.
-   *  \param modifier:
-   *           A function that takes a ViewEdge as argument and that is used to modify the processed ViewEdge
-   *           state (the timestamp incrementation is a typical illustration of such a modifier)
+   *  Each ViewEdge of the current list starts a new chain. The chaining operator then iterates
+   * over the ViewEdges of the ViewMap using the user specified iterator. This operator only
+   * iterates using the increment operator and is therefore unidirectional. \param it: The iterator
+   * on the ViewEdges of the ViewMap. It contains the chaining rule. \param pred: The predicate on
+   * the ViewEdge that expresses the stopping condition. \param modifier: A function that takes a
+   * ViewEdge as argument and that is used to modify the processed ViewEdge state (the timestamp
+   * incrementation is a typical illustration of such a modifier)
    */
   static int chain(ViewEdgeInternal::ViewEdgeIterator &it,
                    UnaryPredicate1D &pred,
                    UnaryFunction1D_void &modifier);
 
   /*! Builds a set of chains from the current set of ViewEdges.
-   *  Each ViewEdge of the current list starts a new chain. The chaining operator then iterates over the ViewEdges
-   *  of the ViewMap using the user specified iterator.
-   *  This operator only iterates using the increment operator and is therefore unidirectional.
-   *  This chaining operator is different from the previous one because it doesn't take any modifier as argument.
-   *  Indeed, the time stamp (insuring that a ViewEdge is processed one time) is automatically managed in this case.
-   *  \param it:
-   *           The iterator on the ViewEdges of the ViewMap. It contains the chaining rule.
-   *  \param pred:
-   *           The predicate on the ViewEdge that expresses the stopping condition.
+   *  Each ViewEdge of the current list starts a new chain. The chaining operator then iterates
+   * over the ViewEdges of the ViewMap using the user specified iterator. This operator only
+   * iterates using the increment operator and is therefore unidirectional. This chaining operator
+   * is different from the previous one because it doesn't take any modifier as argument. Indeed,
+   * the time stamp (insuring that a ViewEdge is processed one time) is automatically managed in
+   * this case. \param it: The iterator on the ViewEdges of the ViewMap. It contains the chaining
+   * rule. \param pred: The predicate on the ViewEdge that expresses the stopping condition.
    */
   static int chain(ViewEdgeInternal::ViewEdgeIterator &it, UnaryPredicate1D &pred);
 
   /*! Builds a set of chains from the current set of ViewEdges.
-   *  Each ViewEdge of the current list potentially starts a new chain. The chaining operator then iterates over
-   *  the ViewEdges of the ViewMap using the user specified iterator.
-   *  This operator iterates both using the increment and decrement operators and is therefore bidirectional.
-   *  This operator works with a ChainingIterator which contains the chaining rules. It is this last one which can
-   *  be told to chain only edges that belong to the selection or not to process twice a ViewEdge during the chaining.
-   *  Each time a ViewEdge is added to a chain, its chaining time stamp is incremented. This allows you to keep track
-   *  of the number of chains to which a ViewEdge belongs to.
-   *  \param it:
-   *           The ChainingIterator on the ViewEdges of the ViewMap. It contains the chaining rule.
-   *  \param pred:
-   *           The predicate on the ViewEdge that expresses the stopping condition.
+   *  Each ViewEdge of the current list potentially starts a new chain. The chaining operator then
+   * iterates over the ViewEdges of the ViewMap using the user specified iterator. This operator
+   * iterates both using the increment and decrement operators and is therefore bidirectional. This
+   * operator works with a ChainingIterator which contains the chaining rules. It is this last one
+   * which can be told to chain only edges that belong to the selection or not to process twice a
+   * ViewEdge during the chaining. Each time a ViewEdge is added to a chain, its chaining time
+   * stamp is incremented. This allows you to keep track of the number of chains to which a
+   * ViewEdge belongs to. \param it: The ChainingIterator on the ViewEdges of the ViewMap. It
+   * contains the chaining rule. \param pred: The predicate on the ViewEdge that expresses the
+   * stopping condition.
    */
   static int bidirectionalChain(ChainingIterator &it, UnaryPredicate1D &pred);
 
-  /*! The only difference with the above bidirectional chaining algorithm is that we don't need to pass a stopping
-   *  criterion. This might be desirable when the stopping criterion is already contained in the iterator definition.
-   *  Builds a set of chains from the current set of ViewEdges.
-   *  Each ViewEdge of the current list potentially starts a new chain. The chaining operator then iterates over
-   *  the ViewEdges of the ViewMap using the user specified iterator.
-   *  This operator iterates both using the increment and decrement operators and is therefore bidirectional.
-   *  This operator works with a ChainingIterator which contains the chaining rules. It is this last one which can be
-   *  told to chain only edges that belong to the selection or not to process twice a ViewEdge during the chaining.
-   *  Each time a ViewEdge is added to a chain, its chaining time stamp is incremented. This allows you to keep track
-   *  of the number of chains to which a ViewEdge belongs to.
-   *  \param it:
-   *           The ChainingIterator on the ViewEdges of the ViewMap. It contains the chaining rule.
+  /*! The only difference with the above bidirectional chaining algorithm is that we don't need to
+   * pass a stopping criterion. This might be desirable when the stopping criterion is already
+   * contained in the iterator definition. Builds a set of chains from the current set of
+   * ViewEdges. Each ViewEdge of the current list potentially starts a new chain. The chaining
+   * operator then iterates over the ViewEdges of the ViewMap using the user specified iterator.
+   *  This operator iterates both using the increment and decrement operators and is therefore
+   * bidirectional. This operator works with a ChainingIterator which contains the chaining rules.
+   * It is this last one which can be told to chain only edges that belong to the selection or not
+   * to process twice a ViewEdge during the chaining. Each time a ViewEdge is added to a chain, its
+   * chaining time stamp is incremented. This allows you to keep track of the number of chains to
+   * which a ViewEdge belongs to. \param it: The ChainingIterator on the ViewEdges of the ViewMap.
+   * It contains the chaining rule.
    */
   static int bidirectionalChain(ChainingIterator &it);
 
   /*! Splits each chain of the current set of chains in a sequential way.
    *  The points of each chain are processed (with a specified sampling) sequentially.
-   *  Each time a user specified starting condition is verified, a new chain begins and ends as soon as a
-   *  user-defined stopping predicate is verified.
-   *  This allows chains overlapping rather than chains partitioning.
-   *  The first point of the initial chain is the first point of one of the resulting chains.
-   *  The splitting ends when no more chain can start.
-   *  \param startingPred:
+   *  Each time a user specified starting condition is verified, a new chain begins and ends as
+   * soon as a user-defined stopping predicate is verified. This allows chains overlapping rather
+   * than chains partitioning. The first point of the initial chain is the first point of one of
+   * the resulting chains. The splitting ends when no more chain can start. \param startingPred:
    *           The predicate on a point that expresses the starting condition
    *  \param stoppingPred:
    *           The predicate on a point that expresses the stopping condition
    *  \param sampling:
-   *           The resolution used to sample the chain for the predicates evaluation. (The chain is not actually
-   *           resampled, a virtual point only progresses along the curve using this resolution)
+   *           The resolution used to sample the chain for the predicates evaluation. (The chain is
+   * not actually resampled, a virtual point only progresses along the curve using this resolution)
    */
   static int sequentialSplit(UnaryPredicate0D &startingPred,
                              UnaryPredicate0D &stoppingPred,
                              float sampling = 0.0f);
 
   /*! Splits each chain of the current set of chains in a sequential way.
-   *  The points of each chain are processed (with a specified sampling) sequentially and each time a user
-   *  specified condition is verified, the chain is split into two chains.
-   *  The resulting set of chains is a partition of the initial chain
-   *  \param pred:
-   *           The predicate on a point that expresses the splitting condition
-   *  \param sampling:
-   *           The resolution used to sample the chain for the predicate evaluation. (The chain is not actually
-   *           resampled, a virtual point only progresses along the curve using this resolution)
+   *  The points of each chain are processed (with a specified sampling) sequentially and each time
+   * a user specified condition is verified, the chain is split into two chains. The resulting set
+   * of chains is a partition of the initial chain \param pred: The predicate on a point that
+   * expresses the splitting condition \param sampling: The resolution used to sample the chain for
+   * the predicate evaluation. (The chain is not actually resampled, a virtual point only
+   * progresses along the curve using this resolution)
    */
   static int sequentialSplit(UnaryPredicate0D &pred, float sampling = 0.0f);
 
   /*! Splits the current set of chains in a recursive way.
-   *  We process the points of each chain (with a specified sampling) to find the point minimizing a specified
-   *  function. The chain is split in two at this point and the two new chains are processed in the same way.
-   *  The recursivity level is controlled through a predicate 1D that expresses a stopping condition
-   *  on the chain that is about to be processed.
-   *  \param func:
-   *           The Unary Function evaluated at each point of the chain.
-   *           The splitting point is the point minimizing this function
-   *  \param pred:
-   *           The Unary Predicate ex pressing the recursivity stopping condition.
-   *           This predicate is evaluated for each curve before it actually gets split.
-   *           If pred(chain) is true, the curve won't be split anymore.
-   *  \param sampling:
-   *           The resolution used to sample the chain for the predicates evaluation. (The chain is not actually
-   *           resampled, a virtual point only progresses along the curve using this resolution)
+   *  We process the points of each chain (with a specified sampling) to find the point minimizing
+   * a specified function. The chain is split in two at this point and the two new chains are
+   * processed in the same way. The recursivity level is controlled through a predicate 1D that
+   * expresses a stopping condition on the chain that is about to be processed. \param func: The
+   * Unary Function evaluated at each point of the chain. The splitting point is the point
+   * minimizing this function \param pred: The Unary Predicate ex pressing the recursivity stopping
+   * condition. This predicate is evaluated for each curve before it actually gets split. If
+   * pred(chain) is true, the curve won't be split anymore. \param sampling: The resolution used to
+   * sample the chain for the predicates evaluation. (The chain is not actually resampled, a
+   * virtual point only progresses along the curve using this resolution)
    */
   static int recursiveSplit(UnaryFunction0D<double> &func,
                             UnaryPredicate1D &pred,
                             float sampling = 0);
 
   /*! Splits the current set of chains in a recursive way.
-   *  We process the points of each chain (with a specified sampling) to find the point minimizing a specified
-   *  function. The chain is split in two at this point and the two new chains are processed in the same way.
-   *  The user can specify a 0D predicate to make a first selection on the points that can potentially be split.
-   *  A point that doesn't verify the 0D predicate won't be candidate in realizing the min.
-   *  The recursivity level is controlled through a predicate 1D that expresses a stopping condition
-   *  on the chain that is about to be processed.
-   *  \param func:
+   *  We process the points of each chain (with a specified sampling) to find the point minimizing
+   * a specified function. The chain is split in two at this point and the two new chains are
+   * processed in the same way. The user can specify a 0D predicate to make a first selection on
+   * the points that can potentially be split. A point that doesn't verify the 0D predicate won't
+   * be candidate in realizing the min. The recursivity level is controlled through a predicate 1D
+   * that expresses a stopping condition on the chain that is about to be processed. \param func:
    *           The Unary Function evaluated at each point of the chain.
    *           The splitting point is the point minimizing this function
    *  \param pred0d:
-   *           The Unary Predicate 0D used to select the candidate points where the split can occur.
-   *           For example, it is very likely that would rather have your chain splitting around its middle point
-   *           than around one of its extremities. A 0D predicate working on the curvilinear abscissa allows
-   *           to add this kind of constraints.
-   *  \param pred:
-   *           The Unary Predicate ex pressing the recursivity stopping condition.
-   *           This predicate is evaluated for each curve before it actually gets split.
-   *           If pred(chain) is true, the curve won't be split anymore.
-   *  \param sampling:
-   *           The resolution used to sample the chain for the predicates evaluation. (The chain is not actually
-   *           resampled, a virtual point only progresses along the curve using this resolution)
+   *           The Unary Predicate 0D used to select the candidate points where the split can
+   * occur. For example, it is very likely that would rather have your chain splitting around its
+   * middle point than around one of its extremities. A 0D predicate working on the curvilinear
+   * abscissa allows to add this kind of constraints. \param pred: The Unary Predicate ex pressing
+   * the recursivity stopping condition. This predicate is evaluated for each curve before it
+   * actually gets split. If pred(chain) is true, the curve won't be split anymore. \param
+   * sampling: The resolution used to sample the chain for the predicates evaluation. (The chain is
+   * not actually resampled, a virtual point only progresses along the curve using this resolution)
    */
   static int recursiveSplit(UnaryFunction0D<double> &func,
                             UnaryPredicate0D &pred0d,
                             UnaryPredicate1D &pred,
                             float sampling = 0.0f);
 
-  /*! Sorts the current set of chains (or viewedges) according to the comparison predicate given as argument.
-   *  \param pred:
-   *           The binary predicate used for the comparison
+  /*! Sorts the current set of chains (or viewedges) according to the comparison predicate given as
+   * argument. \param pred: The binary predicate used for the comparison
    */
   static int sort(BinaryPredicate1D &pred);
 
index 20dac64..e7428c7 100644 (file)
@@ -70,8 +70,8 @@ void PSStrokeRenderer::RenderStrokeRepBasic(StrokeRep *iStrokeRep) const
       svRep[2] = *(v[2]);
 
       color[0] = svRep[0]->color();
-      //color[1] = svRep[1]->color();
-      //color[2] = svRep[2]->color();
+      // color[1] = svRep[1]->color();
+      // color[2] = svRep[2]->color();
 
       _ofstream << "newpath" << endl;
       _ofstream << (color[0])[0] << " " << (color[0])[1] << " " << (color[0])[2] << " setrgbcolor"
index f511c0c..90b6d99 100644 (file)
@@ -65,8 +65,8 @@ class UnaryPredicate0D {
 
   /*! The () operator. Must be overload by inherited classes.
    *  \param it:
-   *    The Interface0DIterator pointing onto the Interface0D at which we wish to evaluate the predicate.
-   *  \return true if the condition is satisfied, false otherwise.
+   *    The Interface0DIterator pointing onto the Interface0D at which we wish to evaluate the
+   * predicate. \return true if the condition is satisfied, false otherwise.
    */
   virtual int operator()(Interface0DIterator &it);
 
index be70907..3560f29 100644 (file)
@@ -183,8 +183,8 @@ class FalseUP1D : public UnaryPredicate1D {
 };
 
 // QuantitativeInvisibilityUP1D
-/*! Returns true if the Quantitative Invisibility evaluated at an Interface1D, using the QuantitativeInvisibilityF1D
- *  functor, equals a certain user-defined value.
+/*! Returns true if the Quantitative Invisibility evaluated at an Interface1D, using the
+ * QuantitativeInvisibilityF1D functor, equals a certain user-defined value.
  */
 class QuantitativeInvisibilityUP1D : public UnaryPredicate1D {
  public:
@@ -344,7 +344,8 @@ class EqualToChainingTimeStampUP1D : public UnaryPredicate1D {
 };
 
 // ShapeUP1D
-/*! Returns true if the shape to which the Interface1D belongs to has the same Id as the one specified by the user. */
+/*! Returns true if the shape to which the Interface1D belongs to has the same Id as the one
+ * specified by the user. */
 class ShapeUP1D : public UnaryPredicate1D {
  private:
   Id _id;
@@ -487,7 +488,8 @@ class FalseBP1D : public BinaryPredicate1D {
 };
 
 // Length2DBP1D
-/*! Returns true if the 2D length of the Interface1D i1 is less than the 2D length of the Interface1D i2. */
+/*! Returns true if the 2D length of the Interface1D i1 is less than the 2D length of the
+ * Interface1D i2. */
 class Length2DBP1D : public BinaryPredicate1D {
  public:
   /*! Returns the string "Length2DBP1D" */
@@ -538,7 +540,8 @@ class SameShapeIdBP1D : public BinaryPredicate1D {
 };
 
 // ViewMapGradientNormBP1D
-/*! Returns true if the evaluation of the Gradient norm Function is higher for Interface1D i1 than for i2. */
+/*! Returns true if the evaluation of the Gradient norm Function is higher for Interface1D i1 than
+ * for i2. */
 class ViewMapGradientNormBP1D : public BinaryPredicate1D {
  private:
   Functions1D::GetViewMapGradientNormF1D _func;
index 99393a8..d3a4218 100644 (file)
@@ -38,7 +38,7 @@ class QInformationMap : public InformationMap {
   QInformationMap(const QInformationMap &);
   QInformationMap &operator=(const QInformationMap &);
 
-  //float getSmoothedPixel(int x, int y, float sigma = 0.2f);1
+  // float getSmoothedPixel(int x, int y, float sigma = 0.2f);1
   virtual float getMean(int x, int y);
   virtual void retrieveMeanAndVariance(int x, int y, float &oMean, float &oVariance);
 
index ef40865..ff0cd64 100644 (file)
@@ -484,7 +484,7 @@ void Stroke::setLength(float iLength)
 
 float Stroke::ComputeSampling(int iNVertices)
 {
-  if (iNVertices <= (int)_Vertices.size())  //soc
+  if (iNVertices <= (int)_Vertices.size())  // soc
     return _sampling;
 
   float sampling = _Length / (float)(iNVertices - _Vertices.size() + 1);
@@ -563,7 +563,7 @@ int Stroke::Resample(int iNPoints)
       if (s->_resampled == false) {
         if ((!checkEveryone) && (s->_length < meanlength))
           continue;
-        //resample
+        // resample
         s->_n = s->_n + 1;
         s->_sampling = s->_length / (float)(s->_n + 1);
         s->_resampled = resampled = true;
@@ -577,10 +577,11 @@ int Stroke::Resample(int iNPoints)
     checkEveryone = true;
   }
   if (N < NPointsToAdd) {
-    // fatal error, likely because _Length is inconsistent with the stroke length computed with the vertices
+    // fatal error, likely because _Length is inconsistent with the stroke length computed with the
+    // vertices
     return -1;
   }
-  //actually resample:
+  // actually resample:
   for (vector<StrokeSegment>::iterator s = strokeSegments.begin(), send = strokeSegments.end();
        s != send;
        ++s) {
@@ -617,7 +618,7 @@ int Stroke::Resample(int iNPoints)
 
 int Stroke::Resample(float iSampling)
 {
-  //cerr << "old size :" << strokeVerticesSize() << endl;
+  // cerr << "old size :" << strokeVerticesSize() << endl;
   if (iSampling == 0)
     return 0;
   if (iSampling >= _sampling)
@@ -625,7 +626,7 @@ int Stroke::Resample(float iSampling)
 
   _sampling = iSampling;
   // Resample...
-  //real curvilinearLength = 0.0f;
+  // real curvilinearLength = 0.0f;
   vertex_container newVertices;
   real t = 0.0f;
   const real limit = 0.99;
@@ -641,17 +642,17 @@ int Stroke::Resample(float iSampling)
     Vec2r vec_tmp(b - a);
     real norm_var = vec_tmp.norm();
     if (norm_var <= _sampling) {
-      //curvilinearLength += norm_var;
+      // curvilinearLength += norm_var;
       ++it;
       ++next;
       continue;
     }
 
-    //curvilinearLength += _sampling;
+    // curvilinearLength += _sampling;
     t = _sampling / norm_var;
     while (t < limit) {
       newVertex = new StrokeVertex(&(*it), &(*next), t);
-      //newVertex->setCurvilinearAbscissa(curvilinearLength);
+      // newVertex->setCurvilinearAbscissa(curvilinearLength);
       newVertices.push_back(newVertex);
       t = t + _sampling / norm_var;
     }
@@ -798,7 +799,7 @@ Stroke::vertex_iterator Stroke::vertices_begin(float sampling)
   if ((sampling != 0) && (sampling < _sampling))
     Resample(sampling);
   return vertex_iterator(_Vertices.begin(), _Vertices.begin(), _Vertices.end());
-  //return _Vertices.begin();
+  // return _Vertices.begin();
 }
 
 #if 0
index 3eae5e9..ec72251 100644 (file)
@@ -143,8 +143,8 @@ class StrokeAttribute {
   }
 
   /*! Returns the attribute's thickness.
-   *  \return an array of 2 floats. the first value is the thickness on the right of the vertex when following
-   *  the stroke, the second one is the thickness on the left.
+   *  \return an array of 2 floats. the first value is the thickness on the right of the vertex
+   * when following the stroke, the second one is the thickness on the left.
    */
   inline const float *getThickness() const
   {
@@ -163,7 +163,8 @@ class StrokeAttribute {
     return _thickness[1];
   }
 
-  /*! Returns the thickness on the right and on the left of the vertex when following the stroke. */
+  /*! Returns the thickness on the right and on the left of the vertex when following the stroke.
+   */
   inline Vec2f getThicknessRL() const
   {
     return Vec2f(_thickness[0], _thickness[1]);
@@ -462,8 +463,8 @@ class StrokeVertex : public CurvePoint {
     _CurvilignAbscissa = iAbscissa;
   }
 
-  /*! sets the Stroke's length (it's only a value stored by the Stroke Vertex, it won't change the real
-   *  Stroke's length.)
+  /*! sets the Stroke's length (it's only a value stored by the Stroke Vertex, it won't change the
+   * real Stroke's length.)
    */
   inline void setStrokeLength(float iLength)
   {
@@ -498,7 +499,8 @@ class StrokeVertexIterator;
 /*! Class to define a stroke.
  *  A stroke is made of a set of 2D vertices (StrokeVertex), regularly spaced out.
  *  This set of vertices defines the stroke's backbone geometry.
- *  Each of these stroke vertices defines the stroke's shape and appearance at this vertex position.
+ *  Each of these stroke vertices defines the stroke's shape and appearance at this vertex
+ * position.
  */
 class Stroke : public Interface1D {
  public:  // Implementation of Interface1D
@@ -532,7 +534,7 @@ class Stroke : public Interface1D {
       const_vertex_iterator;
 
  public:
-  //typedef StrokeVertex vertex_type;
+  // typedef StrokeVertex vertex_type;
 
  private:
   vertex_container _Vertices;  //! The stroke's backbone vertices
@@ -575,8 +577,8 @@ class Stroke : public Interface1D {
   Stroke &operator=(const Stroke &iBrother);
 
   /*! Compute the sampling needed to get iNVertices vertices.
-   *  If the specified number of vertices is less than the actual number of vertices, the actual sampling value
-   *  is returned. (To remove Vertices, use the RemoveVertex() method of this class).
+   *  If the specified number of vertices is less than the actual number of vertices, the actual
+   * sampling value is returned. (To remove Vertices, use the RemoveVertex() method of this class).
    *  \param iNVertices:
    *    The number of StrokeVertices we eventually want in our Stroke.
    *  \return the sampling that must be used in the Resample(float) method.
@@ -586,11 +588,10 @@ class Stroke : public Interface1D {
   float ComputeSampling(int iNVertices);
 
   /*! Resampling method.
-   *  Resamples the curve so that it eventually has iNPoints. That means it is going to add iNPoints-vertices_size,
-   *  if vertices_size is the number of points we already have.
-   *  If vertices_size >= iNPoints, no resampling is done.
-   *  \param iNPoints:
-   *    The number of vertices we eventually want in our stroke.
+   *  Resamples the curve so that it eventually has iNPoints. That means it is going to add
+   * iNPoints-vertices_size, if vertices_size is the number of points we already have. If
+   * vertices_size >= iNPoints, no resampling is done. \param iNPoints: The number of vertices we
+   * eventually want in our stroke.
    */
   int Resample(int iNPoints);
 
@@ -838,11 +839,9 @@ class Stroke : public Interface1D {
   const_vertex_iterator vertices_end() const;
   vertex_iterator vertices_end();
 
-  /*! Returns a StrokeVertexIterator pointing on the first StrokeVertex of the Stroke. One can specify a sampling
-   *  value to resample the Stroke on the fly if needed.
-   *  \param t:
-   *    The resampling value with which we want our Stroke to be resampled.
-   *    If 0 is specified, no resampling is done.
+  /*! Returns a StrokeVertexIterator pointing on the first StrokeVertex of the Stroke. One can
+   * specify a sampling value to resample the Stroke on the fly if needed. \param t: The resampling
+   * value with which we want our Stroke to be resampled. If 0 is specified, no resampling is done.
    */
   StrokeInternal::StrokeVertexIterator strokeVerticesBegin(float t = 0.0f);
 
index e9d4659..ccf5773 100644 (file)
@@ -51,7 +51,7 @@ class vertex_iterator_base : public IteratorBase<Traits, BidirectionalIteratorTa
   typedef vertex_iterator_base<vertex_nonconst_traits> iterator;
   typedef vertex_iterator_base<vertex_const_traits> const_iterator;
 
-  //protected:
+  // protected:
  public:
   vertex_container_iterator _it;
   vertex_container_iterator _begin;
@@ -59,7 +59,7 @@ class vertex_iterator_base : public IteratorBase<Traits, BidirectionalIteratorTa
 
  public:
   friend class Stroke;
-  //friend class vertex_iterator;
+  // friend class vertex_iterator;
 
   inline vertex_iterator_base() : parent_class()
   {
@@ -79,7 +79,7 @@ class vertex_iterator_base : public IteratorBase<Traits, BidirectionalIteratorTa
     _end = iBrother._end;
   }
 
-  //protected: //FIXME
+  // protected: //FIXME
  public:
   inline vertex_iterator_base(vertex_container_iterator it,
                               vertex_container_iterator begin,
index 1999b02..624f2a0 100644 (file)
@@ -34,15 +34,14 @@ namespace StrokeInternal {
 /////////////////////////////////////////////////
 
 /*! Class defining an iterator designed to iterate over the StrokeVertex of a Stroke.
- *  An instance of a StrokeVertexIterator can only be obtained from a Stroke by calling strokeVerticesBegin() or
- *  strokeVerticesEnd().
- *  It is iterating over the same vertices as an Interface0DIterator.
- *  The difference resides in the object access. Indeed, an Interface0DIterator allows only an access to an
- *  Interface0D whereas we could need to access the specialized StrokeVertex type. In this case, one
- *  should use a StrokeVertexIterator.
- *  The castToInterface0DIterator() method is useful to get an Interface0DIterator from a StrokeVertexIterator in
- *  order to call any functions of the type UnaryFunction0D.
- * \attention In the scripting language, you must call \code it2 = StrokeVertexIterator(it1) \endcode instead of
+ *  An instance of a StrokeVertexIterator can only be obtained from a Stroke by calling
+ * strokeVerticesBegin() or strokeVerticesEnd(). It is iterating over the same vertices as an
+ * Interface0DIterator. The difference resides in the object access. Indeed, an Interface0DIterator
+ * allows only an access to an Interface0D whereas we could need to access the specialized
+ * StrokeVertex type. In this case, one should use a StrokeVertexIterator. The
+ * castToInterface0DIterator() method is useful to get an Interface0DIterator from a
+ * StrokeVertexIterator in order to call any functions of the type UnaryFunction0D. \attention In
+ * the scripting language, you must call \code it2 = StrokeVertexIterator(it1) \endcode instead of
  * \code it2 = it1 \endcode where \a it1 and \a it2 are 2 StrokeVertexIterator.
  *  Otherwise, incrementing \a it1 will also increment \a it2.
  */
@@ -84,9 +83,9 @@ class StrokeVertexIterator : public Interface0DIteratorNested {
   }
 
   /*! operator=
-   *  \attention In the scripting language, you must call \code it2 = StrokeVertexIterator(it1) \endcode instead of
-   *  \code it2 = it1 \endcode where \a it1 and \a it2 are 2 StrokeVertexIterator.
-   *  Otherwise, incrementing \a it1 will also increment \a it2.
+   *  \attention In the scripting language, you must call \code it2 = StrokeVertexIterator(it1)
+   * \endcode instead of \code it2 = it1 \endcode where \a it1 and \a it2 are 2
+   * StrokeVertexIterator. Otherwise, incrementing \a it1 will also increment \a it2.
    */
   StrokeVertexIterator &operator=(const StrokeVertexIterator &vi)
   {
index 03e6893..79767b4 100644 (file)
@@ -116,7 +116,8 @@ class TextureManager {
 /*                                */
 /**********************************/
 
-/*! Class to render a stroke. Creates a triangle strip and stores it strip is lazily created at the first rendering */
+/*! Class to render a stroke. Creates a triangle strip and stores it strip is lazily created at the
+ * first rendering */
 class StrokeRenderer {
  public:
   StrokeRenderer();
@@ -130,7 +131,7 @@ class StrokeRenderer {
   // lazy, checks if it has already been done
   static bool loadTextures();
 
-  //static unsigned int getTextureIndex(unsigned int index);
+  // static unsigned int getTextureIndex(unsigned int index);
   static TextureManager *_textureManager;
 
 #ifdef WITH_CXX_GUARDEDALLOC
index f1483e8..a6c00f6 100644 (file)
@@ -113,7 +113,7 @@ static real crossP(const Vec2r &A, const Vec2r &B)
 
 void Strip::createStrip(const vector<StrokeVertex *> &iStrokeVertices)
 {
-  //computeParameterization();
+  // computeParameterization();
   if (iStrokeVertices.size() < 2) {
     if (G.debug & G_DEBUG_FREESTYLE) {
       cout << "Warning: strip has less than 2 vertices" << endl;
@@ -134,11 +134,11 @@ void Strip::createStrip(const vector<StrokeVertex *> &iStrokeVertices)
   StrokeVertex *sv, *sv2, *svPrev;
   int orientationErrors = 0;
 
-  //special case of first vertex
+  // special case of first vertex
   v2 = v = iStrokeVertices.begin();
   ++v2;
   sv = *v;
-  vPrev = v;  //in case the stroke has only 2 vertices;
+  vPrev = v;  // in case the stroke has only 2 vertices;
   sv2 = *v2;
   Vec2r dir(sv2->getPoint() - sv->getPoint());
   Vec2r orthDir(-dir[1], dir[0]);
@@ -195,7 +195,7 @@ void Strip::createStrip(const vector<StrokeVertex *> &iStrokeVertices)
     svPrev = (*vPrev);
     Vec2r p(sv->getPoint()), p2(sv2->getPoint()), pPrev(svPrev->getPoint());
 
-    //direction and orthogonal vector to the next segment
+    // direction and orthogonal vector to the next segment
     Vec2r dir(p2 - p);
     float dirNorm = dir.norm();
     dir.normalize();
@@ -215,7 +215,7 @@ void Strip::createStrip(const vector<StrokeVertex *> &iStrokeVertices)
       }
     }
 
-    //direction and orthogonal vector to the previous segment
+    // direction and orthogonal vector to the previous segment
     Vec2r dirPrev(p - pPrev);
     float dirPrevNorm = dirPrev.norm();
     dirPrev.normalize();
@@ -287,7 +287,7 @@ void Strip::createStrip(const vector<StrokeVertex *> &iStrokeVertices)
     }
   }  // end of for
 
-  //special case of last vertex
+  // special case of last vertex
   sv = *v;
   sv2 = *vPrev;
   dir = Vec2r(sv->getPoint() - sv2->getPoint());
@@ -342,7 +342,7 @@ void Strip::createStrip(const vector<StrokeVertex *> &iStrokeVertices)
 #endif
 
   _averageThickness /= float(iStrokeVertices.size() - 2);
-  //I did not use the first and last vertex for the average
+  // 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]);
 
@@ -379,7 +379,7 @@ void Strip::cleanUpSingularities(const vector<StrokeVertex *> &iStrokeVertices)
     }
   }
 
-  //return;
+  // return;
   if (iStrokeVertices.size() < 2)
     return;
   int i = 0, j;
@@ -389,7 +389,7 @@ void Strip::cleanUpSingularities(const vector<StrokeVertex *> &iStrokeVertices)
   bool singu1 = false, singu2 = false;
   int timeSinceSingu1 = 0, timeSinceSingu2 = 0;
 
-  //special case of first vertex
+  // special case of first vertex
   v = iStrokeVertices.begin();
   for (vend = iStrokeVertices.end(); v != vend; v++) {
     v2 = v;
@@ -416,7 +416,7 @@ void Strip::cleanUpSingularities(const vector<StrokeVertex *> &iStrokeVertices)
         int toto = i - timeSinceSingu1;
         if (toto < 0)
           cerr << "Stephane dit \"Toto\"" << endl;
-        //traverse all the vertices of the singularity and average them
+        // 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());
@@ -437,7 +437,7 @@ void Strip::cleanUpSingularities(const vector<StrokeVertex *> &iStrokeVertices)
         int toto = i - timeSinceSingu2;
         if (toto < 0)
           cerr << "Stephane dit \"Toto\"" << endl;
-        //traverse all the vertices of the singularity and average them
+        // 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());
@@ -453,7 +453,7 @@ void Strip::cleanUpSingularities(const vector<StrokeVertex *> &iStrokeVertices)
   }
 
   if (singu1) {
-    //traverse all the vertices of the singularity and average them
+    // 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());
@@ -462,7 +462,7 @@ void Strip::cleanUpSingularities(const vector<StrokeVertex *> &iStrokeVertices)
       _vertices[2 * j]->setPoint2d(avP);
   }
   if (singu2) {
-    //traverse all the vertices of the singularity and average them
+    // 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());
@@ -760,7 +760,7 @@ StrokeRep::StrokeRep(Stroke *iStroke)
 
 StrokeRep::StrokeRep(const StrokeRep &iBrother)
 {
-  //soc unused - int i = 0;
+  // soc unused - int i = 0;
   _stroke = iBrother._stroke;
   _strokeType = iBrother._strokeType;
   _textureId = iBrother._textureId;
index 3f31239..7b1f12a 100644 (file)
@@ -44,20 +44,17 @@ class Stroke;
  *  Any Stroke Shader must inherit from this class and overload the shade() method.
  *  A StrokeShader is designed to modify any Stroke's attribute such as Thickness, Color,
  *  Geometry, Texture, Blending mode...
- *  The basic way to achieve this operation consists in iterating over the StrokeVertices of the Stroke
- *  and to modify each one's StrokeAttribute.
- *  Here is a python code example of such an iteration:
- * \code
- *  it = ioStroke.strokeVerticesBegin()
- *  while not it.isEnd():
- *      att = it.getObject().attribute()
+ *  The basic way to achieve this operation consists in iterating over the StrokeVertices of the
+ * Stroke and to modify each one's StrokeAttribute. Here is a python code example of such an
+ * iteration: \code it = ioStroke.strokeVerticesBegin() while not it.isEnd(): att =
+ * it.getObject().attribute()
  *      ## perform here any attribute modification
  *      it.increment()
  * \endcode
  *  Here is a C++ code example of such an iteration:
  * \code
- *  for (StrokeInternal::StrokeVertexIterator v = ioStroke.strokeVerticesBegin(), vend = ioStroke.strokeVerticesEnd();
- *      v != vend;
+ *  for (StrokeInternal::StrokeVertexIterator v = ioStroke.strokeVerticesBegin(), vend =
+ * ioStroke.strokeVerticesEnd(); v != vend;
  *      ++v)
  *  {
  *      StrokeAttribute& att = v->attribute();
index e135f83..8d2e554 100644 (file)
@@ -72,7 +72,7 @@ NodeGroup *StrokeTesselator::Tesselate(StrokeVertexIterator begin, StrokeVertexI
   NodeGroup *group = new NodeGroup;
   NodeShape *tshape = new NodeShape;
   group->AddChild(tshape);
-  //tshape->material().setDiffuse(0.0f, 0.0f, 0.0f, 1.0f);
+  // tshape->material().setDiffuse(0.0f, 0.0f, 0.0f, 1.0f);
   tshape->setFrsMaterial(_FrsMaterial);
 
   for (StrokeVertexIterator c = begin, cend = end; c != cend; c++) {
index 015033b..d136632 100644 (file)
  *
  *  PointerSequence
  *
- *  Produces a wrapped version of a sequence type (std::vector, std::deque, std::list) that will take ownership of
- *  pointers that it stores.  Those pointers will be deleted in its destructor.
+ *  Produces a wrapped version of a sequence type (std::vector, std::deque, std::list) that will
+ * take ownership of pointers that it stores.  Those pointers will be deleted in its destructor.
  *
- *  Because the contained pointers are wholly owned by the sequence, you cannot make a copy of the sequence.
- *  Making a copy would result in a double free.
+ *  Because the contained pointers are wholly owned by the sequence, you cannot make a copy of the
+ * sequence. Making a copy would result in a double free.
  *
- *  This is a no-frills class that provides no additional facilities.  The user is responsible for managing any
- *  pointers that are removed from the list, and for making sure that any pointers contained in the class are not
- *  deleted elsewhere.  Because this class does no reference counting, the user must also make sure that any pointer
- *  appears only once in the sequence.
+ *  This is a no-frills class that provides no additional facilities.  The user is responsible for
+ * managing any pointers that are removed from the list, and for making sure that any pointers
+ * contained in the class are not deleted elsewhere.  Because this class does no reference
+ * counting, the user must also make sure that any pointer appears only once in the sequence.
  *
  *  If more sophisticated facilities are needed, use tr1::shared_ptr or boost::shared_ptr.
- *  This class is only intended to allow one to eke by in projects where tr1 or boost are not available.
+ *  This class is only intended to allow one to eke by in projects where tr1 or boost are not
+ * available.
  *
- *  Usage: The template takes two parameters, the standard container, and the class held in the container. This is a
- *  limitation of C++ templates, where T::iterator is not a type when T is a template parameter. If anyone knows a way
- *  around this limitation, then the second parameter can be eliminated.
+ *  Usage: The template takes two parameters, the standard container, and the class held in the
+ * container. This is a limitation of C++ templates, where T::iterator is not a type when T is a
+ * template parameter. If anyone knows a way around this limitation, then the second parameter can
+ * be eliminated.
  *
  *  Example:
  *    PointerSequence<vector<Widget*>, Widget*> v;
index bcb36d8..1fed6a0 100644 (file)
@@ -31,7 +31,7 @@ extern "C" {
 #include "StringUtils.h"
 #include "Interpreter.h"
 
-//soc
+// soc
 extern "C" {
 #include "MEM_guardedalloc.h"
 
index 027491a..99ec9ae 100644 (file)
@@ -19,7 +19,7 @@
  * \brief String utilities
  */
 
-//soc #include <qfileinfo.h>
+// soc #include <qfileinfo.h>
 
 #include "FreestyleConfig.h"
 #include "StringUtils.h"
index 83c3791..35b5e4d 100644 (file)
@@ -58,9 +58,9 @@ class BoxGrid {
     Polygon3r poly;
     Polygon3r cameraSpacePolygon;
     real shallowest, deepest;
-    // N.B. We could, of course, store face in poly's userdata member, like the old ViewMapBuilder code does.
-    // However, code comments make it clear that userdata is deprecated, so we avoid the temptation
-    // to save 4 or 8 bytes.
+    // N.B. We could, of course, store face in poly's userdata member, like the old ViewMapBuilder
+    // code does. However, code comments make it clear that userdata is deprecated, so we avoid the
+    // temptation to save 4 or 8 bytes.
     WFace *face;
 
 #ifdef WITH_CXX_GUARDEDALLOC
@@ -84,24 +84,27 @@ class BoxGrid {
     void indexPolygons();
 
     real boundary[4];
-    //deque<OccluderData*> faces;
+    // deque<OccluderData*> faces;
     vector<OccluderData *> faces;
   };
 
  public:
   /* Iterator needs to allow the user to avoid full 3D comparison in two cases:
    *
-   * (1) Where (*current)->deepest < target[2], where the occluder is unambiguously in front of the target point.
+   * (1) Where (*current)->deepest < target[2], where the occluder is unambiguously in front of the
+   * target point.
    *
-   * (2) Where (*current)->shallowest > target[2], where the occluder is unambiguously in back of the target point.
+   * (2) Where (*current)->shallowest > target[2], where the occluder is unambiguously in back of
+   * the target point.
    *
-   * In addition, when used by OptimizedFindOccludee, Iterator should stop iterating as soon as it has an
-   * occludee candidate and (*current)->shallowest > candidate[2], because at that point forward no new occluder
-   * could possibly be a better occludee.
+   * In addition, when used by OptimizedFindOccludee, Iterator should stop iterating as soon as it
+   * has an occludee candidate and (*current)->shallowest > candidate[2], because at that point
+   * forward no new occluder could possibly be a better occludee.
    */
   class Iterator {
    public:
-    // epsilon is not used in this class, but other grids with the same interface may need an epsilon
+    // epsilon is not used in this class, but other grids with the same interface may need an
+    // epsilon
     explicit Iterator(BoxGrid &grid, Vec3r &center, real epsilon = 1.0e-06);
     ~Iterator();
     void initBeforeTarget();
@@ -122,7 +125,7 @@ class BoxGrid {
     Vec3r _target;
     bool _foundOccludee;
     real _occludeeDepth;
-    //deque<OccluderData*>::iterator _current, _occludeeCandidate;
+    // deque<OccluderData*>::iterator _current, _occludeeCandidate;
     vector<OccluderData *>::iterator _current, _occludeeCandidate;
 
 #ifdef WITH_CXX_GUARDEDALLOC
@@ -171,7 +174,7 @@ class BoxGrid {
   void getCellCoordinates(const Vec3r &point, unsigned &x, unsigned &y);
 
   typedef PointerSequence<vector<Cell *>, Cell *> cellContainer;
-  //typedef PointerSequence<deque<OccluderData*>, OccluderData*> occluderContainer;
+  // typedef PointerSequence<deque<OccluderData*>, OccluderData*> occluderContainer;
   typedef PointerSequence<vector<OccluderData *>, OccluderData *> occluderContainer;
   unsigned _cellsX, _cellsY;
   float _cellSize;
@@ -222,8 +225,8 @@ inline bool BoxGrid::Iterator::testOccluder(bool wantOccludee)
 {
   // End-of-list is not even a valid iterator position
   if (_current == _cell->faces.end()) {
-    // Returning true seems strange, but it will break us out of whatever loop is calling testOccluder,
-    // and _current = _cell->face.end() will make the calling routine give up.
+    // Returning true seems strange, but it will break us out of whatever loop is calling
+    // testOccluder, and _current = _cell->face.end() will make the calling routine give up.
     return true;
   }
 #if BOX_GRID_LOGGING
index 2148520..8e10d06 100644 (file)
@@ -35,8 +35,8 @@ CulledOccluderSource::CulledOccluderSource(const GridHelpers::Transform &t,
 {
   cullViewEdges(viewMap, extensiveFEdgeSearch);
 
-  // If we have not found any visible FEdges during our cull, then there is nothing to iterate over.
-  // Short-circuit everything.
+  // If we have not found any visible FEdges during our cull, then there is nothing to iterate
+  // over. Short-circuit everything.
   valid = gridSpaceOccluderProsceniumInitialized;
 
   if (valid && !testCurrent()) {
@@ -107,8 +107,8 @@ void CulledOccluderSource::cullViewEdges(ViewMap &viewMap, bool extensiveFEdgeSe
 
   // Non-displayable view edges will be skipped over during visibility calculation.
 
-  // View edges will be culled according to their position w.r.t. the viewport proscenium (viewport + 5% border,
-  // or some such).
+  // View edges will be culled according to their position w.r.t. the viewport proscenium (viewport
+  // + 5% border, or some such).
 
   // Get proscenium boundary for culling
   real viewProscenium[4];
@@ -123,17 +123,16 @@ void CulledOccluderSource::cullViewEdges(ViewMap &viewMap, bool extensiveFEdgeSe
     cout << "Origin: [" << prosceniumOrigin[0] << ", " << prosceniumOrigin[1] << "]" << endl;
   }
 
-  // A separate occluder proscenium will also be maintained, starting out the same as the viewport proscenium, and
-  // expanding as necessary so that it encompasses the center point of at least one feature edge in each
-  // retained view edge.
-  // The occluder proscenium will be used later to cull occluding triangles before they are inserted into the Grid.
-  // The occluder proscenium starts out the same size as the view proscenium
+  // A separate occluder proscenium will also be maintained, starting out the same as the viewport
+  // proscenium, and expanding as necessary so that it encompasses the center point of at least one
+  // feature edge in each retained view edge. The occluder proscenium will be used later to cull
+  // occluding triangles before they are inserted into the Grid. The occluder proscenium starts out
+  // the same size as the view proscenium
   GridHelpers::getDefaultViewProscenium(occluderProscenium);
 
-  // XXX Freestyle is inconsistent in its use of ViewMap::viewedges_container and vector<ViewEdge*>::iterator.
-  // Probably all occurences of vector<ViewEdge*>::iterator should be replaced ViewMap::viewedges_container
-  // throughout the code.
-  // For each view edge
+  // XXX Freestyle is inconsistent in its use of ViewMap::viewedges_container and
+  // vector<ViewEdge*>::iterator. Probably all occurences of vector<ViewEdge*>::iterator should be
+  // replaced ViewMap::viewedges_container throughout the code. For each view edge
   ViewMap::viewedges_container::iterator ve, veend;
 
   for (ve = viewMap.ViewEdges().begin(), veend = viewMap.ViewEdges().end(); ve != veend; ve++) {
@@ -154,8 +153,8 @@ void CulledOccluderSource::cullViewEdges(ViewMap &viewMap, bool extensiveFEdgeSe
     // All ViewEdges start culled
     (*ve)->setIsInImage(false);
 
-    // For simple visibility calculation: mark a feature edge that is known to have a center point inside
-    // the occluder proscenium. Cull all other feature edges.
+    // For simple visibility calculation: mark a feature edge that is known to have a center point
+    // inside the occluder proscenium. Cull all other feature edges.
     do {
       // All FEdges start culled
       fe->setIsInImage(false);
@@ -190,8 +189,8 @@ void CulledOccluderSource::cullViewEdges(ViewMap &viewMap, bool extensiveFEdgeSe
       fe = fe->nextEdge();
     } while (fe != NULL && fe != festart && !(bestOccluderTargetFound && (*ve)->isInImage()));
 
-    // Either we have run out of FEdges, or we already have the one edge we need to determine visibility
-    // Cull all remaining edges.
+    // Either we have run out of FEdges, or we already have the one edge we need to determine
+    // visibility Cull all remaining edges.
     while (fe != NULL && fe != festart) {
       fe->setIsInImage(false);
       fe = fe->nextEdge();
@@ -229,14 +228,14 @@ void CulledOccluderSource::cullViewEdges(ViewMap &viewMap, bool extensiveFEdgeSe
 
   // For "Normal" or "Fast" style visibility computation only:
 
-  // For more detailed visibility calculation, make a second pass through the view map, marking all feature edges
-  // with center points inside the final occluder proscenium. All of these feature edges can be considered during
-  // visibility calculation.
+  // For more detailed visibility calculation, make a second pass through the view map, marking all
+  // feature edges with center points inside the final occluder proscenium. All of these feature
+  // edges can be considered during visibility calculation.
 
-  // So far we have only found one FEdge per ViewEdge. The "Normal" and "Fast" styles of visibility computation
-  // want to consider many FEdges for each ViewEdge.
-  // Here we re-scan the view map to find any usable FEdges that we skipped on the first pass, or that have become
-  // usable because the occluder proscenium has been expanded since the edge was visited on the first pass.
+  // So far we have only found one FEdge per ViewEdge. The "Normal" and "Fast" styles of visibility
+  // computation want to consider many FEdges for each ViewEdge. Here we re-scan the view map to
+  // find any usable FEdges that we skipped on the first pass, or that have become usable because
+  // the occluder proscenium has been expanded since the edge was visited on the first pass.
   if (extensiveFEdgeSearch) {
     // For each view edge,
     for (ve = viewMap.ViewEdges().begin(), veend = viewMap.ViewEdges().end(); ve != veend; ve++) {
@@ -259,9 +258,9 @@ void CulledOccluderSource::cullViewEdges(ViewMap &viewMap, bool extensiveFEdgeSe
   }
 
   // Up until now, all calculations have been done in camera space.
-  // However, the occluder source's iteration and the grid that consumes the occluders both work in gridspace,
-  // so we need a version of the occluder proscenium in gridspace.
-  // Set the gridspace occlude proscenium
+  // However, the occluder source's iteration and the grid that consumes the occluders both work in
+  // gridspace, so we need a version of the occluder proscenium in gridspace. Set the gridspace
+  // occlude proscenium
 }
 
 void CulledOccluderSource::expandGridSpaceOccluderProscenium(FEdge *fe)
index 1de4a87..6c14480 100644 (file)
@@ -184,7 +184,7 @@ void FEdgeXDetector::computeCurvatures(WXVertex *vertex)
   // CURVATURE LAYER
   // store all the curvature datas for each vertex
 
-  //soc unused - real K1, K2
+  // soc unused - real K1, K2
   real cos2theta, sin2theta;
   Vec3r e1, n, v;
   // one vertex curvature info :
@@ -206,8 +206,8 @@ void FEdgeXDetector::computeCurvatures(WXVertex *vertex)
     ncycle.end();
     C->K1 = ncycle.kmin();
     C->K2 = ncycle.kmax();
-    C->e1 = ncycle.Kmax();  //ncycle.kmin() * ncycle.Kmax();
-    C->e2 = ncycle.Kmin();  //ncycle.kmax() * ncycle.Kmin();
+    C->e1 = ncycle.Kmax();  // ncycle.kmin() * ncycle.Kmax();
+    C->e2 = ncycle.Kmin();  // ncycle.kmax() * ncycle.Kmin();
 
     real absK1 = fabs(C->K1);
     _meanK1 += absK1;
@@ -320,8 +320,8 @@ void FEdgeXDetector::ProcessSilhouetteEdge(WXEdge *iEdge)
 
   if ((fA->front()) ^
       (fB->front())) {  // fA->visible XOR fB->visible (true if one is 0 and the other is 1)
-    // The only edges we want to set as silhouette edges in this way are the ones with 2 different normals
-    // for 1 vertex for these two faces
+    // The only edges we want to set as silhouette edges in this way are the ones with 2 different
+    // normals for 1 vertex for these two faces
     //--------------------
     // In reality we only test the normals for 1 of the 2 vertices.
     if (fA->GetVertexNormal(iEdge->GetaVertex()) == fB->GetVertexNormal(iEdge->GetaVertex()))
@@ -392,7 +392,7 @@ void FEdgeXDetector::ProcessCreaseEdge(WXEdge *iEdge)
 void FEdgeXDetector::processRidgesAndValleysShape(WXShape *iWShape)
 {
   // Don't forget to add the built layer to the face at the end of the ProcessFace:
-  //iFace->AddSmoothLayer(faceLayer);
+  // iFace->AddSmoothLayer(faceLayer);
 
   if (!_computeViewIndependent)
     return;
@@ -671,7 +671,8 @@ void FEdgeXDetector::postProcessSuggestiveContourFace(WXFace *iFace)
   }
 
   // At that point, we have the derivatives for each vertex of iFace.
-  // All we have to do now is to use linear interpolation to compute the values at the extremities of the smooth edge.
+  // All we have to do now is to use linear interpolation to compute the values at the extremities
+  // of the smooth edge.
   WXSmoothEdge *sc_edge = sc_layer->getSmoothEdge();
   WOEdge *sc_oedge = sc_edge->woea();
   t = sc_edge->ta();
index fafc391..9df0b4b 100644 (file)
@@ -89,8 +89,9 @@ class FEdgeXDetector {
 
   /*! Sets the minimum angle for detecting crease edges
    *  \param angle:
-   *    The angular threshold in degrees (between 0 and 180) for detecting crease edges. An edge is considered
-   *    a crease edge if the angle between two faces sharing the edge is smaller than the given threshold.
+   *    The angular threshold in degrees (between 0 and 180) for detecting crease edges. An edge is
+   * considered a crease edge if the angle between two faces sharing the edge is smaller than the
+   * given threshold.
    */
   // XXX angle should be in radian...
   inline void setCreaseAngle(float angle)
@@ -211,7 +212,7 @@ class FEdgeXDetector {
 #if 0
   real _bbox_diagonal;  // diagonal of the current processed shape bbox
 #endif
-  //oldtmp values
+  // oldtmp values
   bool _computeViewIndependent;
   real _meanK1;
   real _meanKr;
index 5b04b66..2a9a654 100644 (file)
@@ -343,7 +343,7 @@ int GetOccludersF0D::operator()(Interface0DIterator &iter)
   set<ViewShape *> occluders;
   getOccludersF0D(iter, occluders);
   result.clear();
-  //vsOccluders.insert(vsOccluders.begin(), occluders.begin(), occluders.end());
+  // vsOccluders.insert(vsOccluders.begin(), occluders.begin(), occluders.end());
   for (set<ViewShape *>::iterator it = occluders.begin(), itend = occluders.end(); it != itend;
        ++it) {
     result.push_back((*it));
index ecf94b2..7149c19 100644 (file)
@@ -55,9 +55,9 @@ using namespace Geometry;
 
 /*! Base class for Unary Functions (functors) working on Interface0DIterator.
  *  A unary function will be used by calling its operator() on an Interface0DIterator.
- * \attention In the scripting language, there exists several prototypes depending on the returned value type.
- *  For example, you would inherit from a UnaryFunction0DDouble if you wish to define a function that returns a double.
- *  The different existing prototypes are:
+ * \attention In the scripting language, there exists several prototypes depending on the returned
+ * value type. For example, you would inherit from a UnaryFunction0DDouble if you wish to define a
+ * function that returns a double. The different existing prototypes are:
  *    - UnaryFunction0DDouble
  *    - UnaryFunction0DEdgeNature
  *    - UnaryFunction0DFloat
@@ -284,8 +284,9 @@ class GetParameterF0D : public UnaryFunction0D<float> {
 };
 
 // VertexOrientation2DF0D
-/*! Returns a Vec2r giving the 2D oriented tangent to the 1D element to which the Interface0DIterator& belongs to and
- *  evaluated at the Interface0D pointed by this Interface0DIterator&.
+/*! Returns a Vec2r giving the 2D oriented tangent to the 1D element to which the
+ * Interface0DIterator& belongs to and evaluated at the Interface0D pointed by this
+ * Interface0DIterator&.
  */
 class VertexOrientation2DF0D : public UnaryFunction0D<Vec2f> {
  public:
@@ -300,8 +301,9 @@ class VertexOrientation2DF0D : public UnaryFunction0D<Vec2f> {
 };
 
 // VertexOrientation3DF0D
-/*! Returns a Vec3r giving the 3D oriented tangent to the 1D element to which the Interface0DIterator& belongs to and
- *  evaluated at the Interface0D pointed by this Interface0DIterator&.
+/*! Returns a Vec3r giving the 3D oriented tangent to the 1D element to which the
+ * Interface0DIterator& belongs to and evaluated at the Interface0D pointed by this
+ * Interface0DIterator&.
  */
 class VertexOrientation3DF0D : public UnaryFunction0D<Vec3f> {
  public:
@@ -316,8 +318,9 @@ class VertexOrientation3DF0D : public UnaryFunction0D<Vec3f> {
 };
 
 // Curvature2DAngleF0D
-/*! Returns a real giving the 2D curvature (as an angle) of the 1D element to which the Interface0DIterator&
- *  belongs to and evaluated at the Interface0D pointed by this Interface0DIterator&.
+/*! Returns a real giving the 2D curvature (as an angle) of the 1D element to which the
+ * Interface0DIterator& belongs to and evaluated at the Interface0D pointed by this
+ * Interface0DIterator&.
  */
 class Curvature2DAngleF0D : public UnaryFunction0D<double> {
  public:
@@ -332,9 +335,10 @@ class Curvature2DAngleF0D : public UnaryFunction0D<double> {
 };
 
 // ZDiscontinuity
-/*! Returns a real giving the distance between and Interface0D and the shape that lies behind (occludee).
- *  This distance is evaluated in the camera space and normalized between 0 and 1. Therefore, if no object is occluded
- *  by the shape to which the Interface0D belongs to, 1 is returned.
+/*! Returns a real giving the distance between and Interface0D and the shape that lies behind
+ * (occludee). This distance is evaluated in the camera space and normalized between 0 and 1.
+ * Therefore, if no object is occluded by the shape to which the Interface0D belongs to, 1 is
+ * returned.
  */
 class ZDiscontinuityF0D : public UnaryFunction0D<double> {
  public:
@@ -349,8 +353,9 @@ class ZDiscontinuityF0D : public UnaryFunction0D<double> {
 };
 
 // Normal2DF0D
-/*! Returns a Vec2f giving the normalized 2D normal to the 1D element to which the Interface0DIterator& belongs to and
- *  evaluated at the Interface0D pointed by this Interface0DIterator&.
+/*! Returns a Vec2f giving the normalized 2D normal to the 1D element to which the
+ * Interface0DIterator& belongs to and evaluated at the Interface0D pointed by this
+ * Interface0DIterator&.
  */
 class Normal2DF0D : public UnaryFunction0D<Vec2f> {
  public:
@@ -367,11 +372,11 @@ class Normal2DF0D : public UnaryFunction0D<Vec2f> {
 // MaterialF0D
 /*! Returns the material of the object evaluated at the Interface0D.
  *  This evaluation can be ambiguous (in the case of a TVertex for example.
- *  This functor tries to remove this ambiguity using the context offered by the 1D element to which the
- *  Interface0DIterator& belongs to and by arbitrary choosing the material of the face that lies on its left when
- *  following the 1D element if there are two different materials on each side of the point.
- *  However, there still can be problematic cases, and the user willing to deal with this cases in a specific way
- *  should implement its own getMaterial functor.
+ *  This functor tries to remove this ambiguity using the context offered by the 1D element to
+ * which the Interface0DIterator& belongs to and by arbitrary choosing the material of the face
+ * that lies on its left when following the 1D element if there are two different materials on each
+ * side of the point. However, there still can be problematic cases, and the user willing to deal
+ * with this cases in a specific way should implement its own getMaterial functor.
  */
 class MaterialF0D : public UnaryFunction0D<FrsMaterial> {
  public:
@@ -388,10 +393,10 @@ class MaterialF0D : public UnaryFunction0D<FrsMaterial> {
 // ShapeIdF0D
 /*! Returns the Id of the Shape the Interface0D belongs to.
  *  This evaluation can be ambiguous (in the case of a TVertex for example).
- *  This functor tries to remove this ambiguity using the context offered by the 1D element to which the
- *  Interface0DIterator& belongs to.
- *  However, there still can be problematic cases, and the user willing to deal with this cases in a specific way
- *  should implement its own getShapeIdF0D functor.
+ *  This functor tries to remove this ambiguity using the context offered by the 1D element to
+ * which the Interface0DIterator& belongs to. However, there still can be problematic cases, and
+ * the user willing to deal with this cases in a specific way should implement its own
+ * getShapeIdF0D functor.
  */
 class ShapeIdF0D : public UnaryFunction0D<Id> {
  public:
@@ -408,10 +413,10 @@ class ShapeIdF0D : public UnaryFunction0D<Id> {
 // QiF0D
 /*! Returns the quantitative invisibility of this Interface0D.
  *  This evaluation can be ambiguous (in the case of a TVertex for example).
- *  This functor tries to remove this ambiguity using the context offered by the 1D element to which the
- *  Interface0DIterator& belongs to.
- *  However, there still can be problematic cases, and the user willing to deal with this cases in a specific way
- *  should implement its own getQIF0D functor.
+ *  This functor tries to remove this ambiguity using the context offered by the 1D element to
+ * which the Interface0DIterator& belongs to. However, there still can be problematic cases, and
+ * the user willing to deal with this cases in a specific way should implement its own getQIF0D
+ * functor.
  */
 class QuantitativeInvisibilityF0D : public UnaryFunction0D<unsigned int> {
  public:
index 581ab9c..20aa9f2 100644 (file)
@@ -45,9 +45,9 @@ namespace Freestyle {
 
 /*! Base class for Unary Functions (functors) working on Interface1D.
  *  A unary function will be used by calling its operator() on an Interface1D.
- * \attention In the scripting language, there exists several prototypes depending on the returned value type.
- *  For example, you would inherit from a UnaryFunction1DDouble if you wish to define a function that returns a double.
- *  The different existing prototypes are:
+ * \attention In the scripting language, there exists several prototypes depending on the returned
+ * value type. For example, you would inherit from a UnaryFunction1DDouble if you wish to define a
+ * function that returns a double. The different existing prototypes are:
  *    - UnaryFunction1DDouble
  *    - UnaryFunction1DEdgeNature
  *    - UnaryFunction1DFloat
@@ -73,8 +73,8 @@ template<class T> class UnaryFunction1D {
 
   /*! Builds a UnaryFunction1D from an integration type.
    *  \param iType:
-   *    In case the result for the Interface1D would be obtained by evaluating a 0D function over the different
-   *    Interface0D of the Interface1D, \a iType tells which integration method to use.
+   *    In case the result for the Interface1D would be obtained by evaluating a 0D function over
+   * the different Interface0D of the Interface1D, \a iType tells which integration method to use.
    *    The default integration method is the MEAN.
    */
   UnaryFunction1D(IntegrationType iType)
@@ -379,9 +379,10 @@ class Orientation3DF1D : public UnaryFunction1D<Vec3f> {
 };
 
 // ZDiscontinuityF1D
-/*! Returns a real giving the distance between and Interface1D and the shape that lies behind (occludee).
- *  This distance is evaluated in the camera space and normalized between 0 and 1. Therefore, if no object is occluded
- *  by the shape to which the Interface1D belongs to, 1 is returned.
+/*! Returns a real giving the distance between and Interface1D and the shape that lies behind
+ * (occludee). This distance is evaluated in the camera space and normalized between 0 and 1.
+ * Therefore, if no object is occluded by the shape to which the Interface1D belongs to, 1 is
+ * returned.
  */
 class ZDiscontinuityF1D : public UnaryFunction1D<double> {
  private:
@@ -408,9 +409,9 @@ class ZDiscontinuityF1D : public UnaryFunction1D<double> {
 
 // QuantitativeInvisibilityF1D
 /*! Returns the Quantitative Invisibility of an Interface1D element.
- *  If the Interface1D is a ViewEdge, then there is no ambiguity concerning the result. But, if the Interface1D
- *  results of a chaining (chain, stroke), then it might be made of several 1D elements of different
- *  Quantitative Invisibilities.
+ *  If the Interface1D is a ViewEdge, then there is no ambiguity concerning the result. But, if the
+ * Interface1D results of a chaining (chain, stroke), then it might be made of several 1D elements
+ * of different Quantitative Invisibilities.
  */
 class QuantitativeInvisibilityF1D : public UnaryFunction1D<unsigned> {
  private:
@@ -438,8 +439,9 @@ class QuantitativeInvisibilityF1D : public UnaryFunction1D<unsigned> {
 // CurveNatureF1D
 /*! Returns the nature of the Interface1D (silhouette, ridge, crease...).
  *  Except if the Interface1D is a ViewEdge, this result might be ambiguous.
- *  Indeed, the Interface1D might result from the gathering of several 1D elements, each one being of a different
- *  nature. An integration method, such as the MEAN, might give, in this case, irrelevant results.
+ *  Indeed, the Interface1D might result from the gathering of several 1D elements, each one being
+ * of a different nature. An integration method, such as the MEAN, might give, in this case,
+ * irrelevant results.
  */
 class CurveNatureF1D : public UnaryFunction1D<Nature::EdgeNature> {
  private:
index dacdb34..8d6ba52 100644 (file)
@@ -110,7 +110,8 @@ class GridDensityProvider {
     Vec3r p6 = transform(Vec3r(xM, ym, zM));
     Vec3r p7 = transform(Vec3r(xM, yM, zm));
     Vec3r p8 = transform(Vec3r(xM, yM, zM));
-    // Determine the proscenium face according to the min and max values of the transformed x and y coordinates
+    // Determine the proscenium face according to the min and max values of the transformed x and y
+    // coordinates
     proscenium[0] = std::min(std::min(std::min(p1.x(), p2.x()), std::min(p3.x(), p4.x())),
                              std::min(std::min(p5.x(), p6.x()), std::min(p7.x(), p8.x())));
     proscenium[1] = std::max(std::max(std::max(p1.x(), p2.x()), std::max(p3.x(), p4.x())),
index bab996d..3d50e97 100644 (file)
@@ -95,7 +95,8 @@ class Interface0D {
   /*! Returns the 2D point. */
   virtual Geometry::Vec2r getPoint2D() const;
 
-  /*! Returns the FEdge that lies between this Interface0D and the Interface0D given as argument. */
+  /*! Returns the FEdge that lies between this Interface0D and the Interface0D given as argument.
+   */
   virtual FEdge *getFEdge(Interface0D &);
 
   /*! Returns the Id of the point. */
@@ -175,8 +176,8 @@ class Interface0DIteratorNested : public Iterator {
 
 /*! Class defining an iterator over Interface0D elements.
  *  An instance of this iterator is always obtained from a 1D element.
- * \attention In the scripting language, you must call \code it2 = Interface0DIterator(it1) \endcode instead of
- * \code it2 = it1 \endcode where \a it1 and \a it2 are 2 Interface0DIterator.
+ * \attention In the scripting language, you must call \code it2 = Interface0DIterator(it1)
+ * \endcode instead of \code it2 = it1 \endcode where \a it1 and \a it2 are 2 Interface0DIterator.
  *  Otherwise, incrementing \a it1 will also increment \a it2.
  */
 class Interface0DIterator : public Iterator {
@@ -200,9 +201,9 @@ class Interface0DIterator : public Iterator {
   }
 
   /*! Operator =
-   *  \attention In the scripting language, you must call \code it2 = Interface0DIterator(it1) \endcode instead of
-   *  \code it2 = it1 \endcode where \a it1 and \a it2 are 2 Interface0DIterator.
-   *  Otherwise, incrementing \a it1 will also increment \a it2.
+   *  \attention In the scripting language, you must call \code it2 = Interface0DIterator(it1)
+   * \endcode instead of \code it2 = it1 \endcode where \a it1 and \a it2 are 2
+   * Interface0DIterator. Otherwise, incrementing \a it1 will also increment \a it2.
    */
   Interface0DIterator &operator=(const Interface0DIterator &it)
   {
@@ -280,16 +281,16 @@ class Interface0DIterator : public Iterator {
     return _iterator->decrement();
   }
 
-  /*! Returns true if the pointed Interface0D is the first of the 1D element containing the points over which
-   *  we're iterating.
+  /*! Returns true if the pointed Interface0D is the first of the 1D element containing the points
+   * over which we're iterating.
    */
   virtual bool isBegin() const
   {
     return _iterator->isBegin();
   }
 
-  /*! Returns true if the pointed Interface0D is after the after the last point of the 1D element we're
-   *  iterating from. */
+  /*! Returns true if the pointed Interface0D is after the after the last point of the 1D element
+   * we're iterating from. */
   virtual bool isEnd() const
   {
     return _iterator->isEnd();
index e56a580..e47a5ad 100644 (file)
@@ -42,24 +42,28 @@ using namespace std;
 namespace Freestyle {
 
 // Integration method
-/*! The different integration methods that can be invoked to integrate into a single value the set of values obtained
- *  from each 0D element of a 1D element.
+/*! The different integration methods that can be invoked to integrate into a single value the set
+ * of values obtained from each 0D element of a 1D element.
  */
 typedef enum {
-  MEAN, /*!< The value computed for the 1D element is the mean of the values obtained for the 0D elements.*/
-  MIN, /*!< The value computed for the 1D element is the minimum of the values obtained for the 0D elements.*/
-  MAX, /*!< The value computed for the 1D element is the maximum of the values obtained for the 0D elements.*/
-  FIRST, /*!< The value computed for the 1D element is the first of the values obtained for the 0D elements.*/
-  LAST, /*!< The value computed for the 1D element is the last of the values obtained for the 0D elements.*/
+  MEAN, /*!< The value computed for the 1D element is the mean of the values obtained for the 0D
+           elements.*/
+  MIN,  /*!< The value computed for the 1D element is the minimum of the values obtained for the 0D
+           elements.*/
+  MAX,  /*!< The value computed for the 1D element is the maximum of the values obtained for the 0D
+           elements.*/
+  FIRST, /*!< The value computed for the 1D element is the first of the values obtained for the 0D
+            elements.*/
+  LAST,  /*!< The value computed for the 1D element is the last of the values obtained for the 0D
+            elements.*/
 } IntegrationType;
 
 /*! Returns a single value from a set of values evaluated at each 0D element of this 1D element.
  * \param fun:
  *    The UnaryFunction0D used to compute a value at each Interface0D.
  * \param it:
- *    The Interface0DIterator used to iterate over the 0D elements of this 1D element. The integration will occur
- *    over the 0D elements starting from the one pointed by it.
- * \param it_end:
+ *    The Interface0DIterator used to iterate over the 0D elements of this 1D element. The
+ * integration will occur over the 0D elements starting from the one pointed by it. \param it_end:
  *    The Interface0DIterator pointing the end of the 0D elements of the 1D element.
  * \param integration_type:
  *    The integration method used to compute a single value from a set of values.
@@ -148,19 +152,17 @@ class Interface1D {
   /*! Returns an iterator over the Interface1D vertices, pointing after the last vertex. */
   virtual Interface0DIterator verticesEnd();
 
-  /*! Returns an iterator over the Interface1D points, pointing to the first point. The difference with
-   *  verticesBegin() is that here we can iterate over points of the 1D element at a any given sampling.
-   *  Indeed, for each iteration, a virtual point is created.
-   *  \param t:
-   *    The sampling with which we want to iterate over points of this 1D element.
+  /*! Returns an iterator over the Interface1D points, pointing to the first point. The difference
+   * with verticesBegin() is that here we can iterate over points of the 1D element at a any given
+   * sampling. Indeed, for each iteration, a virtual point is created. \param t: The sampling with
+   * which we want to iterate over points of this 1D element.
    */
   virtual Interface0DIterator pointsBegin(float t = 0.0f);
 
-  /*! Returns an iterator over the Interface1D points, pointing after the last point. The difference with
-   *  verticesEnd() is that here we can iterate over points of the 1D element at a any given sampling.
-   *  Indeed, for each iteration, a virtual point is created.
-   *  \param t:
-   *    The sampling with which we want to iterate over points of this 1D element.
+  /*! Returns an iterator over the Interface1D points, pointing after the last point. The
+   * difference with verticesEnd() is that here we can iterate over points of the 1D element at a
+   * any given sampling. Indeed, for each iteration, a virtual point is created. \param t: The
+   * sampling with which we want to iterate over points of this 1D element.
    */
   virtual Interface0DIterator pointsEnd(float t = 0.0f);
 
index af97efa..15fe558 100644 (file)
@@ -286,9 +286,9 @@ real FEdge::z_discontinuity() const
   Vec3r bbox_size_vec(box.getMax() - box.getMin());
   real bboxsize = bbox_size_vec.norm();
   if (occludee_empty()) {
-    //return FLT_MAX;
+    // return FLT_MAX;
     return 1.0;
-    //return bboxsize;
+    // return bboxsize;
   }
 
 #if 0
@@ -302,7 +302,7 @@ real FEdge::z_discontinuity() const
   real res = disc_vec.norm() / bboxsize;
 
   return res;
-  //return fabs((middle.z() - _occludeeIntersection.z()));
+  // return fabs((middle.z() - _occludeeIntersection.z()));
 }
 
 #if 0
index b9f84e7..b5bbe66 100644 (file)
@@ -303,7 +303,8 @@ class SVertex : public Interface0D {
     _Point2D = iPoint2D;
   }
 
-  /*! Adds a normal to the Svertex's set of normals. If the same normal is already in the set, nothing changes. */
+  /*! Adds a normal to the Svertex's set of normals. If the same normal is already in the set,
+   * nothing changes. */
   inline void AddNormal(const Vec3r &iNormal)
   {
     _Normals.insert(iNormal);  // if iNormal in the set already exists, nothing is done
@@ -420,7 +421,7 @@ class SVertex : public Interface0D {
     return *(_Normals.begin());
   }
 
-  //Material material() const ;
+  // Material material() const ;
   Id shape_id() const;
   const SShape *shape() const;
   float shape_importance() const;
@@ -462,13 +463,12 @@ class SVertex : public Interface0D {
 class ViewEdge;
 
 /*! Base Class for feature edges.
- *  This FEdge can represent a silhouette, a crease, a ridge/valley, a border or a suggestive contour.
- *  For silhouettes,  the FEdge is oriented such as, the visible face lies on the left of the edge.
- *  For borders, the FEdge is oriented such as, the face lies on the left of the edge.
- *  An FEdge can represent an initial edge of the mesh or runs accross a face of the initial mesh depending
- *  on the smoothness or sharpness of the mesh.
- *  This class is specialized into a smooth and a sharp version since their properties slightly vary from
- *  one to the other.
+ *  This FEdge can represent a silhouette, a crease, a ridge/valley, a border or a suggestive
+ * contour. For silhouettes,  the FEdge is oriented such as, the visible face lies on the left of
+ * the edge. For borders, the FEdge is oriented such as, the face lies on the left of the edge. An
+ * FEdge can represent an initial edge of the mesh or runs accross a face of the initial mesh
+ * depending on the smoothness or sharpness of the mesh. This class is specialized into a smooth
+ * and a sharp version since their properties slightly vary from one to the other.
  */
 class FEdge : public Interface1D {
  public:  // Implementation of Interface0D
@@ -509,13 +509,13 @@ class FEdge : public Interface1D {
   SVertex *_VertexB;
   Id _Id;
   Nature::EdgeNature _Nature;
-  //vector<Polygon3r> _Occluders; // visibility // NOT HANDLED BY THE COPY CONSTRUCTOR!!
+  // vector<Polygon3r> _Occluders; // visibility // NOT HANDLED BY THE COPY CONSTRUCTOR!!
 
   FEdge *_NextEdge;  // next edge on the chain
   FEdge *_PreviousEdge;
   ViewEdge *_ViewEdge;
-  // Sometimes we need to deport the visibility computation onto another edge. For example the exact edges use
-  // edges of the mesh to compute their visibility
+  // Sometimes we need to deport the visibility computation onto another edge. For example the
+  // exact edges use edges of the mesh to compute their visibility
 
   Polygon3r _aFace;  // The occluded face which lies on the right of a silhouette edge
   Vec3r _occludeeIntersection;
@@ -868,7 +868,7 @@ class FEdge : public Interface1D {
 
   /* Information access interface */
 
-  //Material material() const;
+  // Material material() const;
   Id shape_id() const;
   const SShape *shape() const;
   float shape_importance() const;
@@ -911,7 +911,7 @@ class FEdge : public Interface1D {
 
   int viewedge_nature() const;
 
-  //float viewedge_length() const;
+  // float viewedge_length() const;
 
   inline Vec3r orientation2d() const
   {
@@ -942,16 +942,16 @@ class FEdge : public Interface1D {
   /*! Returns an iterator over the 2 (!) SVertex pointing after the last SVertex. */
   virtual inline Interface0DIterator verticesEnd();
 
-  /*! Returns an iterator over the FEdge points, pointing to the first point. The difference with verticesBegin()
-   *  is that here we can iterate over points of the FEdge at a any given sampling.
+  /*! Returns an iterator over the FEdge points, pointing to the first point. The difference with
+   * verticesBegin() is that here we can iterate over points of the FEdge at a any given sampling.
    *  Indeed, for each iteration, a virtual point is created.
    *  \param t:
    *    The sampling with which we want to iterate over points of this FEdge.
    */
   virtual inline Interface0DIterator pointsBegin(float t = 0.0f);
 
-  /*! Returns an iterator over the FEdge points, pointing after the last point. The difference with verticesEnd()
-   * is that here we can iterate over points of the FEdge at a any given sampling.
+  /*! Returns an iterator over the FEdge points, pointing after the last point. The difference with
+   * verticesEnd() is that here we can iterate over points of the FEdge at a any given sampling.
    *  Indeed, for each iteration, a virtual point is created.
    *  \param t:
    *    The sampling with which we want to iterate over points of this FEdge.
@@ -1277,8 +1277,8 @@ class FEdgeSharp : public FEdge {
 #endif
 };
 
-/*! Class defining a smooth edge. This kind of edge typically runs across a face of the input mesh. It can be
- *  a silhouette, a ridge or valley, a suggestive contour.
+/*! Class defining a smooth edge. This kind of edge typically runs across a face of the input mesh.
+ * It can be a silhouette, a ridge or valley, a suggestive contour.
  */
 class FEdgeSmooth : public FEdge {
  protected:
@@ -1402,7 +1402,8 @@ class FEdgeSmooth : public FEdge {
 /*                                */
 /**********************************/
 
-/*! Class to define a feature shape. It is the gathering of feature elements from an identified input shape */
+/*! Class to define a feature shape. It is the gathering of feature elements from an identified
+ * input shape */
 class SShape {
  private:
   vector<FEdge *> _chains;          // list of fedges that are chains starting points.
@@ -1578,10 +1579,10 @@ class SShape {
   }
 
   /*! Splits an edge into several edges.
-   *  The edge's vertices are passed rather than the edge itself. This way, all feature edges (SILHOUETTE,
-   *  CREASE, BORDER) are splitted in the same time.
-   *  The processed edges are flagged as done (using the userdata flag).One single new vertex is created whereas
-   *  several splitted edges might created for the different kinds of edges. These new elements are added to the lists
+   *  The edge's vertices are passed rather than the edge itself. This way, all feature edges
+   * (SILHOUETTE, CREASE, BORDER) are splitted in the same time. The processed edges are flagged as
+   * done (using the userdata flag).One single new vertex is created whereas several splitted edges
+   * might created for the different kinds of edges. These new elements are added to the lists
    *  maintained by the shape.
    *  New chains are also created.
    *    ioA
@@ -1589,12 +1590,11 @@ class SShape {
    *    ioB
    *      The second vertex for the edge that gets splitted
    *    iParameters
-   *      A vector containing 2D real vectors indicating the parameters giving the intersections coordinates in
-   *      3D and in 2D. These intersections points must be sorted from B to A.
-   *      Each parameter defines the intersection point I as I=A+T*AB. T<0 and T>1 are then incorrect insofar as
-   *      they give intersections points that lie outside the segment.
-   *    ioNewEdges
-   *      The edges that are newly created (the initial edges are not included) are added to this list.
+   *      A vector containing 2D real vectors indicating the parameters giving the intersections
+   * coordinates in 3D and in 2D. These intersections points must be sorted from B to A. Each
+   * parameter defines the intersection point I as I=A+T*AB. T<0 and T>1 are then incorrect insofar
+   * as they give intersections points that lie outside the segment. ioNewEdges The edges that are
+   * newly created (the initial edges are not included) are added to this list.
    */
   inline void SplitEdge(FEdge *fe, const vector<Vec2r> &iParameters, vector<FEdge *> &ioNewEdges)
   {
@@ -1637,7 +1637,7 @@ class SShape {
     for (vector<SVertex *>::iterator sv = intersections.begin(), svend = intersections.end();
          sv != svend;
          sv++) {
-      //SVertex *svA = fe->vertexA();
+      // SVertex *svA = fe->vertexA();
       SVertex *svB = fe->vertexB();
 
       // We split edge AB into AA' and A'B. A' and A'B are created.
@@ -1678,7 +1678,7 @@ class SShape {
       fe->setId(id);
 
       // update edge AA' for the next pointing edge
-      //ioEdge->setNextEdge(newEdge);
+      // ioEdge->setNextEdge(newEdge);
       (fe)->setNextEdge(NULL);
 
       // update vertex pointing edges list:
@@ -1690,17 +1690,13 @@ class SShape {
     }
   }
 
-  /* splits an edge into 2 edges. The new vertex and edge are added to the sshape list of vertices and edges
-   *  a new chain is also created.
-   *  returns the new edge.
-   *    ioEdge
-   *      The edge that gets splitted
-   *    newpoint
-   *      x,y,z coordinates of the new point.
+  /* splits an edge into 2 edges. The new vertex and edge are added to the sshape list of vertices
+   * and edges a new chain is also created. returns the new edge. ioEdge The edge that gets
+   * splitted newpoint x,y,z coordinates of the new point.
    */
   inline FEdge *SplitEdgeIn2(FEdge *ioEdge, SVertex *ioNewVertex)
   {
-    //soc unused - SVertex *A = ioEdge->vertexA();
+    // soc unused - SVertex *A = ioEdge->vertexA();
     SVertex *B = ioEdge->vertexB();
 
     // We split edge AB into AA' and A'B. A' and A'B are created.
index eeec347..1d0ac86 100644 (file)
@@ -16,8 +16,8 @@
 
 /** \file
  * \ingroup freestyle
- * \brief Class to perform all geometric operations dedicated to silhouette. That, for example, implies that
- *         this geom engine has as member data the viewpoint, transformations, projections...
+ * \brief Class to perform all geometric operations dedicated to silhouette. That, for example,
+ * implies that this geom engine has as member data the viewpoint, transformations, projections...
  */
 
 #include <cstring>
@@ -150,7 +150,8 @@ real SilhouetteGeomEngine::ImageToWorldParameter(FEdge *fe, real t)
   if (_isOrthographicProjection)
     return t;
 
-  // we need to compute for each parameter t the corresponding parameter T which gives the intersection in 3D.
+  // we need to compute for each parameter t the corresponding parameter T which gives the
+  // intersection in 3D.
   real T;
 
   // suffix w for world, c for camera, r for retina, i for image
index 306eb3a..79d863e 100644 (file)
@@ -19,8 +19,8 @@
 
 /** \file
  * \ingroup freestyle
- * \brief Class to perform all geometric operations dedicated to silhouette. That, for example, implies that
- *         this geom engine has as member data the viewpoint, transformations, projections...
+ * \brief Class to perform all geometric operations dedicated to silhouette. That, for example,
+ * implies that this geom engine has as member data the viewpoint, transformations, projections...
  */
 
 #include <vector>
index 1a7f01d..0c6e974 100644 (file)
@@ -187,9 +187,9 @@ void SphericalGrid::distributePolygons(OccluderSource &source)
       }
     }
     catch (...) {
-      // If an exception was thrown, _faces.push_back() cannot have succeeded. Occluder is not owned by anyone,
-      // and must be deleted. If the exception was thrown before or during new OccluderData(), then
-      // occluder is NULL, and this delete is harmless.
+      // If an exception was thrown, _faces.push_back() cannot have succeeded. Occluder is not
+      // owned by anyone, and must be deleted. If the exception was thrown before or during new
+      // OccluderData(), then occluder is NULL, and this delete is harmless.
       delete occluder;
       throw;
     }
index ae00c27..c32ceb0 100644 (file)
@@ -24,8 +24,9 @@
 
 #define SPHERICAL_GRID_LOGGING 0
 
-// I would like to avoid using deque because including ViewMap.h and <deque> or <vector> separately results in
-// redefinitions of identifiers. ViewMap.h already includes <vector> so it should be a safe fall-back.
+// I would like to avoid using deque because including ViewMap.h and <deque> or <vector> separately
+// results in redefinitions of identifiers. ViewMap.h already includes <vector> so it should be a
+// safe fall-back.
 //#include <vector>
 //#include <deque>
 
@@ -57,9 +58,9 @@ class SphericalGrid {
     Polygon3r poly;
     Polygon3r cameraSpacePolygon;
     real shallowest, deepest;
-    // N.B. We could, of course, store face in poly's userdata member, like the old ViewMapBuilder code does.
-    // However, code comments make it clear that userdata is deprecated, so we avoid the temptation to save
-    // 4 or 8 bytes.
+    // N.B. We could, of course, store face in poly's userdata member, like the old ViewMapBuilder
+    // code does. However, code comments make it clear that userdata is deprecated, so we avoid the
+    // temptation to save 4 or 8 bytes.
     WFace *face;
 
 #ifdef WITH_CXX_GUARDEDALLOC
@@ -70,8 +71,8 @@ class SphericalGrid {
  private:
   struct Cell {
     // Can't store Cell in a vector without copy and assign
-    //Cell(const Cell& other);
-    //Cell& operator=(const Cell& other);
+    // Cell(const Cell& other);
+    // Cell& operator=(const Cell& other);
 
     explicit Cell();
     ~Cell();
@@ -83,25 +84,28 @@ class SphericalGrid {
     void indexPolygons();
 
     real boundary[4];
-    //deque<OccluderData*> faces;
+    // deque<OccluderData*> faces;
     vector<OccluderData *> faces;
   };
 
  public:
   /*! Iterator needs to allow the user to avoid full 3D comparison in two cases:
    *
-   *  (1) Where (*current)->deepest < target[2], where the occluder is unambiguously in front of the target point.
+   *  (1) Where (*current)->deepest < target[2], where the occluder is unambiguously in front of
+   * the target point.
    *
-   *  (2) Where (*current)->shallowest > target[2], where the occluder is unambiguously in back of the target point.
+   *  (2) Where (*current)->shallowest > target[2], where the occluder is unambiguously in back of
+   * the target point.
    *
-   *  In addition, when used by OptimizedFindOccludee, Iterator should stop iterating as soon as it has an occludee
-   *  candidate and (*current)->shallowest > candidate[2], because at that point forward no new occluder could
-   *  possibly be a better occludee.
+   *  In addition, when used by OptimizedFindOccludee, Iterator should stop iterating as soon as it
+   * has an occludee candidate and (*current)->shallowest > candidate[2], because at that point
+   * forward no new occluder could possibly be a better occludee.
    */
 
   class Iterator {
    public:
-    // epsilon is not used in this class, but other grids with the same interface may need an epsilon
+    // epsilon is not used in this class, but other grids with the same interface may need an
+    // epsilon
     explicit Iterator(SphericalGrid &grid, Vec3r &center, real epsilon = 1.0e-06);
     ~Iterator();
     void initBeforeTarget();
@@ -122,7 +126,7 @@ class SphericalGrid {
     Vec3r _target;
     bool _foundOccludee;
     real _occludeeDepth;
-    //deque<OccluderData*>::iterator _current, _occludeeCandidate;
+    // deque<OccluderData*>::iterator _current, _occludeeCandidate;
     vector<OccluderData *>::iterator _current, _occludeeCandidate;
 
 #ifdef WITH_CXX_GUARDEDALLOC
@@ -171,7 +175,7 @@ class SphericalGrid {
   void getCellCoordinates(const Vec3r &point, unsigned &x, unsigned &y);
 
   typedef PointerSequence<vector<Cell *>, Cell *> cellContainer;
-  //typedef PointerSequence<deque<OccluderData*>, OccluderData*> occluderContainer;
+  // typedef PointerSequence<deque<OccluderData*>, OccluderData*> occluderContainer;
   typedef PointerSequence<vector<OccluderData *>, OccluderData *> occluderContainer;
   unsigned _cellsX, _cellsY;
   float _cellSize;
@@ -222,8 +226,8 @@ inline bool SphericalGrid::Iterator::testOccluder(bool wantOccludee)
 {
   // End-of-list is not even a valid iterator position
   if (_current == _cell->faces.end()) {
-    // Returning true seems strange, but it will break us out of whatever loop is calling testOccluder, and
-    // _current=_cell->face.end() will make the calling routine give up.
+    // Returning true seems strange, but it will break us out of whatever loop is calling
+    // testOccluder, and _current=_cell->face.end() will make the calling routine give up.
     return true;
   }
 #if SPHERICAL_GRID_LOGGING
@@ -286,15 +290,17 @@ inline bool SphericalGrid::Iterator::testOccluder(bool wantOccludee)
     return false;
   }
 
-  // We've done all the corner cutting we can. Let the caller work out whether or not the geometry is correct.
+  // We've done all the corner cutting we can. Let the caller work out whether or not the geometry
+  // is correct.
   return true;
 }
 
 inline void SphericalGrid::Iterator::reportDepth(Vec3r origin, Vec3r u, real t)
 {
-  // The reported depth is the length of a ray in camera space. We need to convert it into the distance from viewpoint
-  // If origin is the viewpoint, depth == t. A future optimization could allow the caller to tell us if origin is
-  // viewponit or target, at the cost of changing the OptimizedGrid API.
+  // The reported depth is the length of a ray in camera space. We need to convert it into the
+  // distance from viewpoint If origin is the viewpoint, depth == t. A future optimization could
+  // allow the caller to tell us if origin is viewponit or target, at the cost of changing the
+  // OptimizedGrid API.
   real depth = (origin + u * t).norm();
 #if SPHERICAL_GRID_LOGGING
   if (G.debug & G_DEBUG_FREESTYLE) {
index d9258a0..d1f9a5b 100644 (file)
@@ -16,7 +16,8 @@
 
 /** \file
  * \ingroup freestyle
- * \brief Convenient access to the steerable ViewMap to which any element of the ViewMap belongs to.
+ * \brief Convenient access to the steerable ViewMap to which any element of the ViewMap belongs
+ * to.
  */
 
 #include <sstream>
@@ -146,7 +147,7 @@ double *SteerableViewMap::AddFEdge(FEdge *iFEdge)
 unsigned SteerableViewMap::getSVMNumber(const Vec2f &orient)
 {
   Vec2f dir(orient);
-  //soc unsigned res = 0;
+  // soc unsigned res = 0;
   real norm = dir.norm();
   if (norm < 1.0e-6) {
     return _nbOrientations + 1;
@@ -211,11 +212,11 @@ float SteerableViewMap::readSteerableViewMapPixel(unsigned iOrientation, int iLe
   }
   if ((x < 0) || (x >= pyramid->width()) || (y < 0) || (y >= pyramid->height()))
     return 0;
-  //float v = pyramid->pixel(x, pyramid->height() - 1 - y, iLevel) * 255.0f;
-  // We encode both the directionality and the lines counting on 8 bits (because of frame buffer). Thus, we allow
-  // until 8 lines to pass through the same pixel, so that we can discretize the Pi/_nbOrientations angle into
-  // 32 slices. Therefore, for example, in the vertical direction, a vertical line will have the value 32 on
-  // each pixel it passes through.
+  // float v = pyramid->pixel(x, pyramid->height() - 1 - y, iLevel) * 255.0f;
+  // We encode both the directionality and the lines counting on 8 bits (because of frame buffer).
+  // Thus, we allow until 8 lines to pass through the same pixel, so that we can discretize the
+  // Pi/_nbOrientations angle into 32 slices. Therefore, for example, in the vertical direction, a
+  // vertical line will have the value 32 on each pixel it passes through.
   float v = pyramid->pixel(x, pyramid->height() - 1 - y, iLevel) / 32.0f;
   return v;
 }
@@ -243,31 +244,31 @@ void SteerableViewMap::saveSteerableViewMap() const
     int ow = _imagesPyramids[i]->width(0);
     int oh = _imagesPyramids[i]->height(0);
 
-    //soc QString base("SteerableViewMap");
+    // soc QString base("SteerableViewMap");
     string base("SteerableViewMap");
     stringstream filename;
 
-    for (int j = 0; j < _imagesPyramids[i]->getNumberOfLevels(); ++j) {  //soc
+    for (int j = 0; j < _imagesPyramids[i]->getNumberOfLevels(); ++j) {  // soc
       float coeff = 1.0f;  // 1 / 255.0f; // 100 * 255; // * pow(2, j);
-      //soc QImage qtmp(ow, oh, QImage::Format_RGB32);
+      // soc QImage qtmp(ow, oh, QImage::Format_RGB32);
       ImBuf *ibuf = IMB_allocImBuf(ow, oh, 32, IB_rect);
       int rowbytes = ow * 4;
       char *pix;
 
-      for (int y = 0; y < oh; ++y) {    //soc
-        for (int x = 0; x < ow; ++x) {  //soc
+      for (int y = 0; y < oh; ++y) {    // soc
+        for (int x = 0; x < ow; ++x) {  // soc
           int c = (int)(coeff * _imagesPyramids[i]->pixel(x, y, j));
           if (c > 255)
             c = 255;
-          //int c = (int)(_imagesPyramids[i]->pixel(x, y, j));
+          // int c = (int)(_imagesPyramids[i]->pixel(x, y, j));
 
-          //soc qtmp.setPixel(x, y, qRgb(c, c, c));
+          // soc qtmp.setPixel(x, y, qRgb(c, c, c));
           pix = (char *)ibuf->rect + y * rowbytes + x * 4;
           pix[0] = pix[1] = pix[2] = c;
         }
       }
 
-      //soc qtmp.save(base+QString::number(i)+"-"+QString::number(j)+".png", "PNG");
+      // soc qtmp.save(base+QString::number(i)+"-"+QString::number(j)+".png", "PNG");
       filename << base;
       filename << i << "-" << j << ".png";
       ibuf->ftype = IMB_FTYPE_PNG;
index 16f57f3..27a2754 100644 (file)
@@ -19,7 +19,8 @@
 
 /** \file
  * \ingroup freestyle
- * \brief Convenient access to the steerable ViewMap to which any element of the ViewMap belongs to.
+ * \brief Convenient access to the steerable ViewMap to which any element of the ViewMap belongs
+ * to.
  */
 
 #include <map>
@@ -42,8 +43,8 @@ class FEdge;
 class ImagePyramid;
 class GrayImage;
 
-/*! This class checks for every FEdge in which steerable it belongs and stores the mapping allowing to retrieve
- *  this information from the FEdge Id.
+/*! This class checks for every FEdge in which steerable it belongs and stores the mapping allowing
+ * to retrieve this information from the FEdge Id.
  */
 class SteerableViewMap {
  protected:
@@ -66,8 +67,8 @@ class SteerableViewMap {
   virtual void Reset();
 
   /*! Adds a FEdge to steerable VM.
-   *  Returns the nbOrientations weights corresponding to the FEdge contributions to the nbOrientations
-   *  directional maps.
+   *  Returns the nbOrientations weights corresponding to the FEdge contributions to the
+   * nbOrientations directional maps.
    */
   double *AddFEdge(FEdge *iFEdge);
 
@@ -86,17 +87,13 @@ class SteerableViewMap {
    */
   unsigned getSVMNumber(unsigned id);
 
-  /*! Builds _nbOrientations+1 pyramids of images from the _nbOrientations+1 base images of the steerable viewmap.
-   *  \param steerableBases:
-   *    The _nbOrientations+1 images constituting the basis for the steerable pyramid.
-   *  \param copy:
-   *    If false, the data is not duplicated, and Canvas deals with the memory management of these
-   *    _nbOrientations+1 images. If true, data is copied, and it's up to the caller to delete the images.
-   *  \param iNbLevels:
-   *    The number of levels desired for each pyramid.
-   *    If iNbLevels == 0, the complete pyramid is built.
-   *  \param iSigma:
-   *    The sigma that will be used for the gaussian blur
+  /*! Builds _nbOrientations+1 pyramids of images from the _nbOrientations+1 base images of the
+   * steerable viewmap. \param steerableBases: The _nbOrientations+1 images constituting the basis
+   * for the steerable pyramid. \param copy: If false, the data is not duplicated, and Canvas deals
+   * with the memory management of these _nbOrientations+1 images. If true, data is copied, and
+   * it's up to the caller to delete the images. \param iNbLevels: The number of levels desired for
+   * each pyramid. If iNbLevels == 0, the complete pyramid is built. \param iSigma: The sigma that
+   * will be used for the gaussian blur
    */
   void buildImagesPyramids(GrayImage **steerableBases,
                            bool copy = false,
@@ -116,15 +113,15 @@ class SteerableViewMap {
    *  \param iLevel:
    *    The level of the pyramid we want to read
    *  \param x:
-   *    The abscissa of the desired pixel specified in level0 coordinate system. The origin is the lower left corner.
-   *  \param y:
-   *    The ordinate of the desired pixel specified in level0 coordinate system. The origin is the lower left corner.
+   *    The abscissa of the desired pixel specified in level0 coordinate system. The origin is the
+   * lower left corner. \param y: The ordinate of the desired pixel specified in level0 coordinate
+   * system. The origin is the lower left corner.
    */
   float readSteerableViewMapPixel(unsigned iOrientation, int iLevel, int x, int y);
 
-  /*! Reads a pixel in the one of the level of the pyramid containing the images of the complete ViewMap.
-   *  Returns a value between 0 and 1.
-   *  Equivalent to : readSteerableViewMapPixel(nbOrientations, x, y)
+  /*! Reads a pixel in the one of the level of the pyramid containing the images of the complete
+   * ViewMap. Returns a value between 0 and 1. Equivalent to :
+   * readSteerableViewMapPixel(nbOrientations, x, y)
    */
   float readCompleteViewMapPixel(int iLevel, int x, int y);
 
index 629ec3d..8715f4f 100644 (file)
@@ -79,8 +79,8 @@ void ViewEdgeXBuilder::BuildViewEdges(WXShape *iWShape,
         continue;
       if (stopSmoothViewEdge((*sl)))  // has it been parsed already ?
         continue;
-      // here we know that we're dealing with a face layer that has not been processed yet and that contains
-      // a smooth edge.
+      // here we know that we're dealing with a face layer that has not been processed yet and that
+      // contains a smooth edge.
       /* vedge =*//* UNUSED */ BuildSmoothViewEdge(OWXFaceLayer(*sl, true));
     }
   }
@@ -89,7 +89,7 @@ void ViewEdgeXBuilder::BuildViewEdges(WXShape *iWShape,
   //----------------------------------
   // Reset all userdata for WXEdge structure
   //----------------------------------------
-  //iWShape->ResetUserData();
+  // iWShape->ResetUserData();
 
   WXEdge *wxe;
   vector<WEdge *> &wedges = iWShape->getEdgeList();
@@ -339,7 +339,8 @@ OWXFaceLayer ViewEdgeXBuilder::FindNextFaceLayer(const OWXFaceLayer &iFaceLayer)
     nextFace = dynamic_cast<WXFace *>(iFaceLayer.fl->getFace()->GetBordingFace(woeend));
     if (!nextFace)
       return OWXFaceLayer(NULL, true);
-    // if the next face layer has either no smooth edge or no smooth edge of same nature, no next face
+    // if the next face layer has either no smooth edge or no smooth edge of same nature, no next
+    // face
     if (!nextFace->hasSmoothEdges())
       return OWXFaceLayer(NULL, true);
     vector<WXFaceLayer *> sameNatureLayers;
@@ -411,7 +412,8 @@ OWXFaceLayer ViewEdgeXBuilder::FindPreviousFaceLayer(const OWXFaceLayer &iFaceLa
     previousFace = dynamic_cast<WXFace *>(iFaceLayer.fl->getFace()->GetBordingFace(woebegin));
     if (0 == previousFace)
       return OWXFaceLayer(NULL, true);
-    // if the next face layer has either no smooth edge or no smooth edge of same nature, no next face
+    // if the next face layer has either no smooth edge or no smooth edge of same nature, no next
+    // face
     if (!previousFace->hasSmoothEdges())
       return OWXFaceLayer(NULL, true);
     vector<WXFaceLayer *> sameNatureLayers;
@@ -688,7 +690,7 @@ FEdge *ViewEdgeXBuilder::BuildSharpFEdge(FEdge *feprevious, const OWXEdge &iwe)
   _pCurrentSShape->AddEdge(fe);
   va->AddFEdge(fe);
   vb->AddFEdge(fe);
-  //Add normals:
+  // Add normals:
   va->AddNormal(normalA);
   va->AddNormal(normalB);
   vb->AddNormal(normalA);
index 6f3604a..26f1144 100644 (file)
@@ -28,7 +28,8 @@
 
 #if 0  // soc
 #  if defined(__GNUC__) && (__GNUC__ >= 3)
-//hash_map is not part of the C++ standard anymore; hash_map.h has been kept though for backward compatibility
+/* hash_map is not part of the C++ standard anymore;
+ * hash_map.h has been kept though for backward compatibility */
 #    include <hash_map.h>
 #  else
 #    include <hash_map>
@@ -278,9 +279,9 @@ class ViewEdgeXBuilder {
   /*! instanciate a ViewVertex from a SVertex, if it doesn't exist yet */
   ViewVertex *MakeViewVertex(SVertex *iSVertex);
 
-  //oldtmp values
-  //IdHashTable _hashtable;
-  //VVIdHashTable _multivertexHashTable;
+  // oldtmp values
+  // IdHashTable _hashtable;
+  // VVIdHashTable _multivertexHashTable;
   SVertexMap _SVertexMap;
   SShape *_pCurrentSShape;
   ViewShape *_pCurrentVShape;
index d859f83..0b352be 100644 (file)
@@ -155,8 +155,8 @@ TVertex *ViewMap::CreateTVertex(const Vec3r &iA3D,
   SVertex *Ia = shapeA->CreateSVertex(iA3D, iA2D, iFEdgeA->vertexA()->getId());
   SVertex *Ib = shapeB->CreateSVertex(iB3D, iB2D, iFEdgeB->vertexA()->getId());
 
-  // depending on which of these 2 svertices is the nearest from the viewpoint, we're going to build the TVertex
-  // by giving them in an order or another (the first one must be the nearest)
+  // depending on which of these 2 svertices is the nearest from the viewpoint, we're going to
+  // build the TVertex by giving them in an order or another (the first one must be the nearest)
   real dista = Ia->point2D()[2];
   real distb = Ib->point2D()[2];
 
@@ -185,8 +185,8 @@ ViewVertex *ViewMap::InsertViewVertex(SVertex *iVertex, vector<ViewEdge *> &newV
   NonTVertex *vva = dynamic_cast<NonTVertex *>(iVertex->viewvertex());
   if (vva)
     return vva;
-  // because it is not already a ViewVertex, this SVertex must have only 2 FEdges. The incoming one still belongs
-  // to ioEdge, the outgoing one now belongs to newVEdge
+  // because it is not already a ViewVertex, this SVertex must have only 2 FEdges. The incoming one
+  // still belongs to ioEdge, the outgoing one now belongs to newVEdge
   const vector<FEdge *> &fedges = iVertex->fedges();
   if (fedges.size() != 2) {
     cerr << "ViewMap warning: Can't split the ViewEdge" << endl;
@@ -235,7 +235,7 @@ ViewVertex *ViewMap::InsertViewVertex(SVertex *iVertex, vector<ViewEdge *> &newV
     ViewEdge *newVEdge = new ViewEdge(vva, ioEdge->B(), fbegin, ioEdge->fedgeB(), vshape);
     newVEdge->setId(Id(ioEdge->getId().getFirst(), ioEdge->getId().getSecond() + 1));
     newVEdge->setNature(ioEdge->getNature());
-    //newVEdge->UpdateFEdges(); // done in the ViewEdge constructor
+    // newVEdge->UpdateFEdges(); // done in the ViewEdge constructor
     // Update old ViewEdge