Merge remote-tracking branch 'origin2/master' into documentation

Author: VibekeSkytt

Doxyfile

@@ -150,6 +150,7 @@ STRIP_FROM_INC_PATH    = gotools-core/include \
                          qualitymodule/include \
                          isogeometric_model/include \
                          lrsplines2D/include \
+                         lrsplines3D/include \
                          topology/include \
                          viewlib/include
 

gotools-core/include/GoTools/geometry/streamable_doxymain.h

@@ -86,6 +86,7 @@ g2-format:
 \arg \c \em CylinderVolume, entity code = 722,
 \arg \c \em ConeVolume, entity code = 723,
 \arg \c \em TorusVolume, entity code = 724
+\arg \c \em LRSplineVolume, entity code = 793
 
 In the following the file format corresponding to  most of the entities listed 
 above will be described. Note that the g2-file format is a simple format that

gotools-core/include/GoTools/utils/gotools-doxymain.h

@@ -88,6 +88,7 @@ on the model
 \li \ref qualitymodule. A set of tools to check the quality of CAD models
 \li \ref isogeometric_model. A set of tools related to isogeometric analysis
 \li \ref lrsplines2d. LR spline surfaces
+\li \ref lrsplines3d. LR spline volumes
 
 GoTools depends on:
 \li <a href="http://www.sintef.no/SISL">SISL</a> (available with

lrsplines2D/include/GoTools/lrsplines2D/LRBSpline2D.h

@@ -79,7 +79,7 @@ class LRBSpline2D : public Streamable
   /// \param c_g coefficient
   /// \param weight rational weight (1 if non-rational surface)
   /// \param bspline_u univariate B-spline in first parameter direction
-  /// \param bspline_v univariate B-spline in first second direction
+  /// \param bspline_v univariate B-spline in second parameter direction
   /// \param gamma scaling factor
   /// \param rational indicates rational surface
   LRBSpline2D(const Point& c_g, double weight,
@@ -156,7 +156,7 @@ class LRBSpline2D : public Streamable
   /// Evaluate the LRBSpline2D or its derivative in (u, v), looking
   /// up the knot values from the arrays pointed to by 'kvals_u' and
   /// 'kvals_v' (the actual indices to the relevant knots are already
-  /// stored in the LRBSpline2D). If u_deriv = n and v_deriv = m,
+  /// stored in the associated BSplineUniLR). If u_deriv = n and v_deriv = m,
   /// the partial derivative d^(n+m) B / du^n dv^m will be computed. If
   /// the basis function is positioned at the upper boundary of the
   /// domain in either the u or v direction, the consideration of

lrsplines2D/include/GoTools/lrsplines2D/LRSplineEvalGrid.h

@@ -66,25 +66,30 @@ namespace Go
 typedef Element2D simpleElement;
 
 
+  /// Grid evaluation of the elements of an LR B-spline surface.
 // =============================================================================
 class LRSplineEvalGrid
 // =============================================================================
 {
 public:
 
+  // Constructor
   LRSplineEvalGrid();
 
   typedef double param_float_type;
 
 //    LRSplineEvalGrid(int numElements);
 
+  /// Constructor given an LR B-spline surface
   LRSplineEvalGrid(LRSplineSurface& lr_spline);
 
+  /// Iterator to the first element of the LR B-spline surface
   std::vector<Element2D>::iterator elements_begin()// const
     {
       return elements_.begin();
     }
 
+  /// Iterator past the last element of the LR B-spline surface
   std::vector<Element2D>::iterator elements_end()// const
     {
       return elements_.end();
@@ -150,16 +155,19 @@ class LRSplineEvalGrid
       return 3; // If dim is 1 we use the parameter domain as the first two dimensions.
     }
 
+  /// Order (polynomial degree + 1) of the surface in the first parameter direction
   int orderU() const
     {
       return order_u_;
     }
 
+  /// Order (polynomial degree + 1) of the surface in the second parameter direction
   int orderV() const
     {
       return order_v_;
     }
 
+  /// Lower left corner of element
   void low(const Element2D &e, double &u, double &v)
     {
       u = e.umin();
@@ -170,6 +178,7 @@ class LRSplineEvalGrid
 	  v /= orig_dom_.vmax()-orig_dom_.vmin();
     }
 
+  /// Upper right corner of element
   void high(const Element2D &e, double &u, double &v)
     {
       u = e.umax();
@@ -183,6 +192,9 @@ class LRSplineEvalGrid
     // Copy and paste from code in r2gl.
     void testCoefComputation();
 
+  /// Compute Bezier coefficients of element based on a grid of sample points obtained
+  /// by evaluating the surface in the element. The number of sample points depends on
+  /// the polynomial degree
     inline void computeBezCoefs(int dim, const double *points, int orderU, int orderV, double *coefs)
 	{
 	    if ((orderU != 3 && orderU != 4) || (orderV != 3 && orderV != 4)) {

lrsplines2D/include/GoTools/lrsplines2D/LRSplineMBA.h

@@ -64,11 +64,11 @@ namespace Go
     /// Compute distances between points stored with the surface and
     /// update LRSplineSurface according to data points stored in the surface elements
     /// using the MBA algorithm
+    /// Parallel version
     /// \param srf surface to update
     /// \param significant_factor multiplicator for weight on significant points
     /// \param sgn  indicates if only points with a given signed distance is
     /// to be included in the computations. Only for 1D surfaces
-    /// Parallel version
     void MBADistAndUpdate_omp(LRSplineSurface *srf,  
 			      double significant_factor = 1.0,
 			      int sgn=0);
@@ -85,11 +85,11 @@ namespace Go
 
     /// Update LRSplineSurface according to data points stored in the surface elements
     /// using the MBA algorithm
+    /// Parallel version
     /// \param srf surface to update
     /// \param significant_factor multiplicator for weight on significant points
     /// \param sgn  indicates if only points with a given signed distance is
     /// to be included in the computations. Only for 1D surfaces
-    /// Parallel version
    void MBAUpdate_omp(LRSplineSurface *srf,  
 		       double significant_factor = 1.0,
 		       int sgn=0);

lrsplines2D/include/GoTools/lrsplines2D/LRSplineSurface.h

@@ -250,8 +250,7 @@ namespace Go
 
     /// Return the spline surface represented by this surface, if any
     /// The user may get the spline surface lying in the (refined)
-    /// regular grid by calling the function
-    /// expandToFullTensorProduct().
+    /// regular grid by calling the function expandToFullTensorProduct().
     virtual SplineSurface* asSplineSurface(); 
 
   // inherited from GeomObject
@@ -318,7 +317,7 @@ namespace Go
   /// \param upar parameter value in first parameter direction
   /// \param vpar parameter value in second parameter direction
   /// \param derivs number of derivatives to compute (0 = only point)
-     /// Output: Partial derivatives up to order derivs (pts[0]=S(u,v),
+     /// \param Output: Partial derivatives up to order derivs (pts[0]=S(u,v),
     /// pts[1]=dS/du=S_u, pts[2]=S_v, pts[3]=S_uu, pts[4]=S_uv, pts[5]=S_vv, ...)
     /// inherited from ParamSurface
     virtual void point(std::vector<Point>& pts, 

lrsplines2D/src/LRSurfApprox.C

@@ -799,16 +799,16 @@ void LRSurfApprox::getClassifiedPts(vector<double>& outliers, int& nmb_outliers,
        // Update surface
       if (useMBA_ || ki >= toMBA_)
       {
-#ifdef DEBUG
+	//#ifdef DEBUG
 	std::cout << "Using MBA" << std::endl;
-#endif
+	//#endif
 	runMBAUpdate(true);
       }
       else
 	{
-#ifdef DEBUG
+	  //#ifdef DEBUG
 	  std::cout << "Using LS" << std::endl;
-#endif
+	  //#endif
 	  try {
 	    LSapprox.updateLocals();
 	    performSmooth(&LSapprox);

lrsplines3D/include/GoTools/lrsplines3D/Direction3D.h

@@ -19,6 +19,8 @@
 namespace Go
 {
 
+  /// Specifies parameter direction of volume (along first (x) parameter: d = XDIR;
+  /// along second (y) parameter: YDIR; along third (z) parameter: ZDIR)
     enum Direction3D {XDIR=0, YDIR=1, ZDIR=2};
 
 }; // end namespace Go

lrsplines3D/include/GoTools/lrsplines3D/Element3D.h

@@ -24,6 +24,10 @@ namespace Go {
 class LRBSpline3D;
 
 
+  /// Storage for data points situated in this element,  and accuracy information derived from 
+  /// these points with relation to the LR B-spline volume where the element belongs.
+  /// This volume is expected to approximate the point cloud where the points
+  /// of this element make up a sub set
 struct Approx3DData
 {
   Approx3DData()
@@ -196,34 +200,56 @@ struct Approx3DData
 };
 
 
+  /// An element (or a mesh cell) in an LR B-spline volume description. The
+  /// elements contain information about the LRBSpline3D having this element
+  /// in its support and has the potential of storing data points corresponding
+  /// to this element with derived accuracy information.
 
 
 class Element3D  
 {
  public:
+   /// Constructor for an empty element
   Element3D();
+   /// Constructor giving element boundaries
   Element3D(double start_u, double start_v, double start_w, double stop_u, double stop_v, double stop_w);
+   /// Remove a B-spline with this element in its support from the vector maintained in the element
   void removeSupportFunction(LRBSpline3D *f);
+   /// Add a B-spline with this element in its support from the vector maintained in the elemen
   void addSupportFunction(LRBSpline3D *f);
+   /// Split element in the given direction and value. Called from volume refinement.
   Element3D *split(Direction3D split_dir, double par_value);
   Element3D* copy();
   // get/set methods
+   /// Start parameter in the first parameter direction
   double umin() const         { return start_u_; }
+   /// Start parameter in the second parameter direction
   double vmin() const         { return start_v_; }
+   /// Start parameter in the third parameter direction
   double wmin() const         { return start_w_; }
+   /// End parameter in the first parameter direction
   double umax() const         { return stop_u_;  }
+   /// End parameter in the second parameter direction
   double vmax() const         { return stop_v_;  }
+   /// End parameter in the third parameter direction
   double wmax() const         { return stop_w_;  }
+  /// Volume of element domain
   double volume() const         { return (stop_w_-start_w_)*(stop_v_-start_v_)*(stop_u_-start_u_);  }
+   /// Start iterator to B-splines with this element in their support
   std::vector<LRBSpline3D*>::iterator supportBegin() { return support_.begin(); }
+   /// End iterator to B-splines with this element in their support
   std::vector<LRBSpline3D*>::iterator supportEnd()   { return support_.end();   }
+   /// Start iterator to B-splines with this element in their support
   std::vector<LRBSpline3D*>::const_iterator supportBegin()const { return support_.begin(); }
+   /// End iterator to B-splines with this element in their support
   std::vector<LRBSpline3D*>::const_iterator supportEnd() const  { return support_.end();   }
+   /// Return a reference to the vector of B-splines with this element in their support
   const std::vector<LRBSpline3D*>& getSupport() const
   {
     return support_;
   }
 
+   /// Check if the parameter pair is contained in the element domain
   bool contains(double upar, double vpar, double wpar)
   {
     return (upar >= start_u_ && upar <= stop_u_ &&
@@ -232,13 +258,21 @@ class Element3D
   }
 
 
+   /// Accsess one specified B-spline with this element in the support
   LRBSpline3D* supportFunction(int i) { return support_[i];   }
+   /// Number of B-splines having this element in their support
   int nmbBasisFunctions() const       { return (int)support_.size(); }
+   /// Modify the start of the element domain in the first parameter direction
   void setUmin(double u)                           { start_u_ = u; }
+   /// Modify the start of the element domain in the second parameter direction
   void setVmin(double v)                           { start_v_ = v; }
+   /// Modify the start of the element domain in the third parameter direction
   void setWmin(double w)                           { start_w_ = w; }
+   /// Modify the end of the element domain in the first parameter direction
   void setUmax(double u)                           { stop_u_  = u; }
+   /// Modify the end of the element domain in the second parameter direction
   void setVmax(double v)                           { stop_v_  = v; }
+   /// Modify the end of the element domain in the third parameter direction
   void setWmax(double w)                           { stop_w_  = w; }
 
   bool isOverloaded() const;
@@ -424,8 +458,8 @@ class Element3D
       approx_data_->resetAccuracyInfo();
   }
 
-  // Update accuracy statistics in points. Number of outside
-  // points is NOT changed
+  /// Update accuracy statistics in points. 
+  /// Number of outside points is NOT changed
   void updateAccuracyInfo();
 
   /// Check if the element has been modified lately