Added documentation and fix to coding style.

(bzr r13645.1.66)

1 files changed, 96 insertions, 89 deletions

diff --git a/src/helper/geom-pointwise.cpp b/src/helper/geom-pointwise.cpp
index 9e65685ae..cfe93311c 100644
--- a/src/helper/geom-pointwise.cpp
+++ b/src/helper/geom-pointwise.cpp
@@ -1,23 +1,22 @@
 /**
  * \file
  * \brief Pointwise a class to manage a vector of satellites per piecewise curve
- *//*
- * Authors:
- * 2015 Jabier Arraiza Cenoz<jabier.arraiza@marker.es>
- *
- * This code is in public domain
- */
+ */ /*
+    * Authors:
+    * 2015 Jabier Arraiza Cenoz<jabier.arraiza@marker.es>
+    *
+    * This code is in public domain
+    */
 
 #include <helper/geom-pointwise.h>
 
-
 namespace Geom {
 
 /**
  * @brief Pointwise a class to manage a vector of satellites per piecewise curve
  *
  * For the moment is a per curve satellite holder not per node. This is ok for
- * much cases but not a real node satellite on open paths 
+ * much cases but not a real node satellite on open paths
  * To implement this we can:
  * add extra satellite in open paths, and take notice of current open paths
  * or put extra satellites on back for each open subpath
@@ -26,35 +25,34 @@ namespace Geom {
  * optional satellites, and remove the active variable in satellites.
  *
  */
-Pointwise::Pointwise(Piecewise<D2<SBasis> > pwd2, std::vector<Satellite> satellites)
-        : _pwd2(pwd2), _satellites(satellites), _pathInfo(pwd2)
+Pointwise::Pointwise(Piecewise<D2<SBasis> > pwd2,
+                     std::vector<Satellite> satellites)
+    : _pwd2(pwd2), _satellites(satellites), _path_info(pwd2)
 {
     setStart();
-};
+}
+;
 
-Pointwise::~Pointwise(){};
+Pointwise::~Pointwise() {}
+;
 
-Piecewise<D2<SBasis> >
-Pointwise::getPwd2() const
+Piecewise<D2<SBasis> > Pointwise::getPwd2() const
 {
     return _pwd2;
 }
 
-void
-Pointwise::setPwd2(Piecewise<D2<SBasis> > pwd2_in)
+void Pointwise::setPwd2(Piecewise<D2<SBasis> > pwd2_in)
 {
     _pwd2 = pwd2_in;
-    _pathInfo.setPwd2(_pwd2);
+    _path_info.setPwd2(_pwd2);
 }
 
-std::vector<Satellite>
-Pointwise::getSatellites() const
+std::vector<Satellite> Pointwise::getSatellites() const
 {
     return _satellites;
 }
 
-void
-Pointwise::setSatellites(std::vector<Satellite> sats)
+void Pointwise::setSatellites(std::vector<Satellite> sats)
 {
     _satellites = sats;
     setStart();
@@ -62,14 +60,13 @@ Pointwise::setSatellites(std::vector<Satellite> sats)
 
 /** Update the start satellite on ope/closed paths.
  */
-void
-Pointwise::setStart()
+void Pointwise::setStart()
 {
-    std::vector<std::pair<size_t, bool> > pathInfo = _pathInfo.getPathInfo();
-    for(size_t i = 0; i < pathInfo.size(); i++){
-        size_t firstNode = _pathInfo.getFirst(pathInfo[i].first);
-        size_t lastNode = _pathInfo.getLast(pathInfo[i].first);
-        if(!_pathInfo.getIsClosed(lastNode)){
+    std::vector<std::pair<size_t, bool> > path_info = _path_info.data;
+    for (size_t i = 0; i < path_info.size(); i++) {
+        size_t firstNode = _path_info.first(path_info[i].first);
+        size_t lastNode = _path_info.last(path_info[i].first);
+        if (!_path_info.isClosed(lastNode)) {
             _satellites[firstNode].hidden = true;
             _satellites[firstNode].active = false;
         } else {
@@ -81,30 +78,29 @@ Pointwise::setStart()
 
 /** Fired when a path is modified.
  */
-void
-Pointwise::recalculate_for_new_pwd2(Piecewise<D2<SBasis> > A)
+void Pointwise::recalculateForNewPwd2(Piecewise<D2<SBasis> > A)
 {
-    if( _pwd2.size() > A.size()){
-        pwd2_sustract(A);
-    } else if (_pwd2.size() < A.size()){
-        pwd2_append(A);
+    if (_pwd2.size() > A.size()) {
+        pwd2Sustract(A);
+    } else if (_pwd2.size() < A.size()) {
+        pwd2Append(A);
     }
 }
 
 /** Some nodes/subpaths are removed.
  */
-void
-Pointwise::pwd2_sustract(Piecewise<D2<SBasis> > A)
+void Pointwise::pwd2Sustract(Piecewise<D2<SBasis> > A)
 {
     size_t counter = 0;
     std::vector<Satellite> sats;
     Piecewise<D2<SBasis> > pwd2 = _pwd2;
     setPwd2(A);
-    for(size_t i = 0; i < _satellites.size(); i++){
-        if(_pathInfo.getLast(i-counter) < i-counter || !are_near(pwd2[i].at0(),A[i-counter].at0(),0.001)){
+    for (size_t i = 0; i < _satellites.size(); i++) {
+        if (_path_info.last(i - counter) < i - counter ||
+                !are_near(pwd2[i].at0(), A[i - counter].at0(), 0.001)) {
             counter++;
         } else {
-            sats.push_back(_satellites[i-counter]);
+            sats.push_back(_satellites[i - counter]);
         }
     }
     setSatellites(sats);
@@ -112,76 +108,83 @@ Pointwise::pwd2_sustract(Piecewise<D2<SBasis> > A)
 
 /** Append nodes/subpaths to current pointwise
  */
-void 
-Pointwise::pwd2_append(Piecewise<D2<SBasis> > A)
+void Pointwise::pwd2Append(Piecewise<D2<SBasis> > A)
 {
     size_t counter = 0;
     std::vector<Satellite> sats;
     bool reversed = false;
     bool reorder = false;
-    for(size_t i = 0; i < A.size(); i++){
-        size_t first = _pathInfo.getFirst(i-counter);
-        size_t last = _pathInfo.getLast(i-counter);
-        //Check for subpath closed. If a subpath is closed, is not reversed or moved to back
-        _pathInfo.setPwd2(A);
-        size_t subpathAIndex = _pathInfo.getSubPathIndex(i);
-        _pathInfo.setPwd2(_pwd2);
-        bool changedSubpath = false;
-        if(_pwd2.size() <= i-counter){
-            changedSubpath = false;
+    for (size_t i = 0; i < A.size(); i++) {
+        size_t first = _path_info.first(i - counter);
+        size_t last = _path_info.last(i - counter);
+        //Check for subpath closed. If a subpath is closed, is not reversed or moved
+        //to back
+        _path_info.setPwd2(A);
+        size_t new_subpath_index = _path_info.subPathIndex(i);
+        _path_info.setPwd2(_pwd2);
+        bool subpath_is_changed = false;
+        if (_pwd2.size() <= i - counter) {
+            subpath_is_changed = false;
         } else {
-            changedSubpath = subpathAIndex != _pathInfo.getSubPathIndex(i-counter);
+            subpath_is_changed = new_subpath_index != _path_info.subPathIndex(i - counter);
         }
-        if(!reorder && first == i-counter && !are_near(_pwd2[i-counter].at0(),A[i].at0(),0.001) && !changedSubpath){
+        if (!reorder && first == i - counter &&
+                !are_near(_pwd2[i - counter].at0(), A[i].at0(), 0.001) &&
+                !subpath_is_changed) {
             //Send the modified subpath to back
-            subpath_to_back(_pathInfo.getSubPathIndex(first));
+            subpathToBack(_path_info.subPathIndex(first));
             reorder = true;
             i--;
             continue;
         }
-        if(!reversed && first == i-counter && !are_near(_pwd2[i-counter].at0(),A[i].at0(),0.001) && !changedSubpath){
-            subpath_reverse(first, last);
+        if (!reversed && first == i - counter &&
+                !are_near(_pwd2[i - counter].at0(), A[i].at0(), 0.001) &&
+                !subpath_is_changed) {
+            subpathReverse(first, last);
             reversed = true;
         }
-        if(_pwd2.size() <= i-counter || !are_near(_pwd2[i-counter].at0(),A[i].at0(),0.001)){
+        if (_pwd2.size() <= i - counter ||
+                !are_near(_pwd2[i - counter].at0(), A[i].at0(), 0.001)) {
             counter++;
             bool active = true;
             bool hidden = false;
-            bool isTime = _satellites[0].isTime;
+            bool is_time = _satellites[0].isTime;
             bool mirror_knots = _satellites[0].hasMirror;
             double amount = 0.0;
             double degrees = 0.0;
             int steps = 0;
-            Satellite sat(_satellites[0].satelliteType, isTime, active, mirror_knots, hidden, amount, degrees, steps);
+            Satellite sat(_satellites[0].satelliteType, is_time, active, mirror_knots,
+                          hidden, amount, degrees, steps);
             sats.push_back(sat);
         } else {
-            sats.push_back(_satellites[i-counter]);
+            sats.push_back(_satellites[i - counter]);
         }
     }
     setPwd2(A);
     setSatellites(sats);
 }
 
-
-void
-Pointwise::subpath_to_back(size_t subpath){
-    std::vector<Geom::Path> path_in = path_from_piecewise(remove_short_cuts(_pwd2,0.1), 0.001);
-    size_t nSubpath = 0;
+void Pointwise::subpathToBack(size_t subpath)
+{
+    std::vector<Geom::Path> path_in =
+        path_from_piecewise(remove_short_cuts(_pwd2, 0.1), 0.001);
+    size_t subpath_counter = 0;
     size_t counter = 0;
     std::vector<Geom::Path> tmp_path;
-    Geom::Path rev;
-    for (PathVector::const_iterator path_it = path_in.begin(); path_it != path_in.end(); ++path_it) {
-        if (path_it->empty()){
+    Geom::Path to_back;
+    for (PathVector::const_iterator path_it = path_in.begin();
+            path_it != path_in.end(); ++path_it) {
+        if (path_it->empty()) {
             continue;
         }
         Geom::Path::const_iterator curve_it1 = path_it->begin();
         Geom::Path::const_iterator curve_endit = path_it->end_default();
-        const Curve &closingline = path_it->back_closed(); 
+        const Curve &closingline = path_it->back_closed();
         if (are_near(closingline.initialPoint(), closingline.finalPoint())) {
             curve_endit = path_it->end_open();
         }
         while (curve_it1 != curve_endit) {
-            if(nSubpath == subpath){
+            if (subpath_counter == subpath) {
                 _satellites.push_back(_satellites[counter]);
                 _satellites.erase(_satellites.begin() + counter);
             } else {
@@ -189,43 +192,45 @@ Pointwise::subpath_to_back(size_t subpath){
             }
             ++curve_it1;
         }
-        if(nSubpath == subpath){
-            rev = *path_it;
+        if (subpath_counter == subpath) {
+            to_back = *path_it;
         } else {
             tmp_path.push_back(*path_it);
         }
-        nSubpath++;
+        subpath_counter++;
     }
-    tmp_path.push_back(rev);
-    setPwd2(remove_short_cuts(paths_to_pw(tmp_path),0.01));
+    tmp_path.push_back(to_back);
+    setPwd2(remove_short_cuts(paths_to_pw(tmp_path), 0.01));
 }
 
-void
-Pointwise::subpath_reverse(size_t start,size_t end){
-    start ++;
-    for(size_t i = end; i >= start; i--){
+void Pointwise::subpathReverse(size_t start, size_t end)
+{
+    start++;
+    for (size_t i = end; i >= start; i--) {
         _satellites.push_back(_satellites[i]);
         _satellites.erase(_satellites.begin() + i);
     }
-    std::vector<Geom::Path> path_in = path_from_piecewise(remove_short_cuts(_pwd2,0.1), 0.001);
+    std::vector<Geom::Path> path_in =
+        path_from_piecewise(remove_short_cuts(_pwd2, 0.1), 0.001);
     size_t counter = 0;
-    size_t nSubpath = 0;
-    size_t subpath = _pathInfo.getSubPathIndex(start);
+    size_t subpath_counter = 0;
+    size_t subpath = _path_info.subPathIndex(start);
     std::vector<Geom::Path> tmp_path;
     Geom::Path rev;
-    for (PathVector::const_iterator path_it = path_in.begin(); path_it != path_in.end(); ++path_it) {
-        if (path_it->empty()){
+    for (PathVector::const_iterator path_it = path_in.begin();
+            path_it != path_in.end(); ++path_it) {
+        if (path_it->empty()) {
             continue;
         }
-        counter ++;
-        if(nSubpath == subpath){
+        counter++;
+        if (subpath_counter == subpath) {
             tmp_path.push_back(path_it->reverse());
         } else {
             tmp_path.push_back(*path_it);
         }
-        nSubpath++;
+        subpath_counter++;
     }
-    setPwd2(remove_short_cuts(paths_to_pw(tmp_path),0.01));
+    setPwd2(remove_short_cuts(paths_to_pw(tmp_path), 0.01));
 }
 
 } // namespace Geom
@@ -238,4 +243,6 @@ Pointwise::subpath_reverse(size_t start,size_t end){
   fill-column:99
   End:
 */
-// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:fileencoding=utf-8:textwidth=99 :
+// vim:
+// filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:fileencoding=utf-8:textwidth=99
+// :