Extern :

- C3d aggiornamento delle librerie ( 117941).

C3d/Include/action_analysis.h

@@ -384,6 +384,40 @@ MATH_FUNC( void ) SurfaceMaxCurvatureDirection( const MbSurface &   surf,
                                                       MbVector &    dir );
 
 
+//------------------------------------------------------------------------------
+// Вычисление приращения параметров по заданному направлению
+// ---
+inline
+bool ParamsDirectData( const MbVector3D & direct,
+                       const MbVector3D & derU, double & x,
+                       const MbVector3D & derV, double & y )
+{
+  double eps = PARAM_REGION;
+  double g11 = derU * derU;
+  double g22 = derV * derV;
+
+  if ( g11 > eps && g22 > eps && g11 > g22*eps && g22 > g11*eps ) { // проецируем производную на поверхность
+    double g12 = derU * derV;
+    double g = g11*g22 - g12*g12;
+    double cosAngle = PARAM_NEAR; // DELTA_MOD;
+    if ( g > eps && g > cosAngle*g11*g22 ) { // не сильно косоугольная система 
+      double du = direct * derU;
+      double dv = direct * derV;
+      if ( ::fabs( g12 ) > PARAM_EPSILON ) { // не ортогональная система
+        x = (g22*du - g12*dv) / g;
+        y = (g11*dv - g12*du) / g;
+      }
+      else {
+        x = du / g11;
+        y = dv / g22;
+      }
+      return true;
+    }
+  }
+  return false;
+}
+
+
 //------------------------------------------------------------------------------
 /** \brief \ru Входные параметры функции поиска минимальных и максимальных отклонений параметров поверхностей вдоль их кривой пересечения.
            \en Input parameters of the search function for minimum and maximum deviations of surfaces parameters along their intersection curve. \~

C3d/Include/action_curve3d.h

@@ -38,6 +38,7 @@ class  MATH_CLASS  MbSweptData;
 class  MATH_CLASS  MbSNameMaker;
 class  MATH_CLASS  MbContourChamferParams;
 class  MATH_CLASS  MbNurbsCopyCurveResult;
+class  MATH_CLASS  MbCurvesWrappingParams;
 
 struct MATH_CLASS  EvolutionValues;
 
@@ -1567,4 +1568,22 @@ MATH_FUNC( MbResultType ) ExtendCurve( const MbCurve3D &                    sour
 MATH_FUNC (MbResultType) CreateContourChamfer( const MbContourChamferParams & paramList,
                                                      MbCurve3D *&             resultChamferContour );
 
+
+//-------------------------------------------------------------------------------
+/** \brief \ru Построить развертку кривых на плоскость.
+           \en Construct unwrapped curves. \~
+  \details \ru Построение развертки кривых на плоскость. См. также #CurvesUnwrapping.\n
+           \en Construct unwrapped curves on a plane. Also check out #CurvesUnwrapping.\n \~
+  \param[in] params - \ru Параметры разворачивания.
+                      \en Unwrapping parameters. \~
+  \param[in] resFrame - \ru Развёрнутые 3д-кривые на присланной плоскости.
+                        \en Unwrapped 3d-curves on the input plane. \~
+  \return \ru Возвращает код результата операции.
+          \en Returns operation result code. \~
+\ingroup Curve3D_Modeling
+*/
+// ---
+MATH_FUNC (MbResultType) UnwrapCurve( const MbCurvesWrappingParams & parameters,
+                                            c3d::WireFrameSPtr &     resFrame );
+
 #endif // __ACTION_CURVE3D_H

C3d/Include/action_general.h

@@ -639,6 +639,26 @@ MATH_FUNC (void) GetRangeToCubeOrSurface( const MbCurve3D &           curve,
                                                 MbResultType &        resType );
 
 
+//------------------------------------------------------------------------------
+/** \brief \ru Найти ближайшие тела при выдавливании с опцией "до ближайшего объекта".
+           \en Find the nearest solids while extruding with option 'up to the nearest object'. \~
+  \details \ru Найти ближайшие тела при выдавливании с опцией "до ближайшего объекта". \n
+    возвращает номерa ближайших тел ближайших тел в прямом и обратном направлении.
+           \en Find the nearest solids while extruding with option 'up to the nearest object'. \n
+    returns numbers of the nearest solids in the forward and the backward direction. \~
+  \param[in]  params - \ru Параметры операции.
+                       \en Operation parameters. \~
+  \param[out] result - \ru Результат операции с номерами ближайших тел.
+                       \en The result of the operation with the numbers of the nearest solids. \~
+  \return \ru Возвращает true, если найдено тело хотя бы в одном из направлений.
+          \en Returns 'true' if a solid is found in at least one of directions. \~
+  \ingroup Algorithms_3D
+*/
+// ---
+MATH_FUNC (bool) GetNearestSolid( const MbNearestSolidParams & params,
+                                        MbNearestSolidResult & result ); 
+
+
 //------------------------------------------------------------------------------
 /** \brief \ru Найти ближайшие тела при выдавливании с опцией "до ближайшего объекта".
            \en Find the nearest solids while extruding with option 'up to the nearest object'. \~
@@ -663,6 +683,7 @@ MATH_FUNC (void) GetRangeToCubeOrSurface( const MbCurve3D &           curve,
   \ingroup Algorithms_3D
 */
 // ---
+// DEPRECATE_DECLARE_REPLACE( GetNearestSolid with MbNearestSolidParams )
 MATH_FUNC (bool) GetNearestSolid( const MbPlacement3D &          pl, 
                                         RPArray<MbContour> &     c,
                                         MbSweptLayout::Direction direction, 
@@ -670,7 +691,7 @@ MATH_FUNC (bool) GetNearestSolid( const MbPlacement3D &          pl,
                                         size_t &                 nPlus, 
                                         size_t &                 nMinus );
 
-                    
+
 //------------------------------------------------------------------------------
 /** \brief \ru Найти ближайшие тела при выдавливании с опцией "до ближайшего объекта".
            \en Find the nearest solids while extruding with option 'up to the nearest object'. \~
@@ -695,6 +716,7 @@ MATH_FUNC (bool) GetNearestSolid( const MbPlacement3D &          pl,
   \ingroup Algorithms_3D
 */
 // ---
+// DEPRECATE_DECLARE_REPLACE( GetNearestSolid with MbNearestSolidParams )
 MATH_FUNC (bool) GetNearestSolid(       RPArray<MbCurve3D> &     curves,
                                   const MbVector3D &             direction,
                                         MbSweptLayout::Direction operationDirection, 

C3d/Include/action_mesh.h

@@ -12,7 +12,6 @@
 #ifndef __ACTION_MESH_H
 #define __ACTION_MESH_H
 
-
 #include <mb_cart_point.h>
 #include <mb_cart_point3d.h>
 #include <mesh.h>
@@ -21,7 +20,6 @@
 #include <curve3d.h>
 #include <vector>
 
-
 class  MATH_CLASS  MbPlacement3D;
 class  MATH_CLASS  MbMesh;
 class  MATH_CLASS  MbSurface;
@@ -36,7 +34,7 @@ struct MATH_CLASS  MbConvexHullResults;
 class  MATH_CLASS  MbConvexHullParams3D;
 class  MATH_CLASS  MbMeshToInstanceParams;
 class  MATH_CLASS  MbMeshToInstanceResults;
-
+class  MATH_CLASS  MbOrientedBox;
 
 //------------------------------------------------------------------------------
 /** \brief \ru Данные диагностики полигонального объекта.
@@ -147,7 +145,6 @@ MATH_FUNC (void) CalculateWire( const MbPlaneItem &   obj,
                                       double          sag, 
                                       MbMesh &        mesh );
 
-
 //------------------------------------------------------------------------------
 /** \brief \ru Построить икосаэдр в виде полигональной модели.
            \en Construct an icosahedron mesh. \~
@@ -631,6 +628,17 @@ MATH_FUNC (MbResultType) CalculateBallPivotingGrid( const MbCollection & collect
                                                           double         angle,
                                                           MbMesh *&      result );
 
+//------------------------------------------------------------------------------
+/** \brief  \ru Рассчитать минимизированный по объему параллелепипед (OBB), включающий полигональный объект.
+            \en Calculate a volume-minimized oriented bounding box (OBB) containing a polygonal object. \~
+            \param[in] mesh \ru Полигональная сетка, для которой рассчитывается ограничивающий объем.
+                            \en A polygonal mesh for witch the bounding volume is calculated. \~            
+            \return \ru Ограничивающий параллелепипед с ориентацией, выбранной в пользу минимального объема. \~
+                    \en Bounding box with orientation chosen for minimum bounding volume.
+            \ingroup Polygonal_Objects
+*/
+// ---
+MATH_FUNC(MbOrientedBox) CalculateBoundingBox( const MbMesh & mesh );
 
 //------------------------------------------------------------------------------
 /** \brief \ru Исправить несовместную ориентацию полигонов сетки по отношению друг к другу.
@@ -750,4 +758,5 @@ MATH_FUNC( MbResultType ) SimplifyTriangularMesh( const MbMesh & mesh, const MbM
   \ingroup Polygonal_Objects
 */ // ---
 MATH_FUNC( MbResultType ) SimplifyTriangularMesh( const MbMeshSimplificationParams & params, MbMesh & mesh );
+
 #endif // __ACTION_MESH_H

C3d/Include/action_solid.h

@@ -614,7 +614,7 @@ MATH_FUNC (MbResultType) RevolutionSolid( const MbSweptData &           sweptDat
   \ingroup Solid_Modeling
 */
 // ---
-//DEPRECATE_DECLARE_REPLACE( EvolutionSolid with 'MbEvolutionSolidParams' argument )
+//DEPRECATE_DECLARE_REPLACE( EvolutionShell with 'MbEvolutionShellParams' argument )
 MATH_FUNC (MbResultType) EvolutionSolid( const MbSweptData &           sweptData, 
                                          const MbCurve3D &             spine,
                                          const EvolutionValues &       params, 
@@ -648,7 +648,7 @@ MATH_FUNC (MbResultType) EvolutionSolid( const MbSweptData &           sweptData
   \ingroup Solid_Modeling
 */
 // ---
-//DEPRECATE_DECLARE_REPLACE( EvolutionSolid with 'MbEvolutionSolidParams' argument )
+//DEPRECATE_DECLARE_REPLACE( EvolutionShell with 'MbEvolutionShellParams' argument )
 MATH_FUNC (MbResultType) EvolutionSolid( const MbSweptData &           sweptData, 
                                          const MbSpine &               spine,
                                          const EvolutionValues &       params, 
@@ -663,7 +663,7 @@ MATH_FUNC (MbResultType) EvolutionSolid( const MbSweptData &           sweptData
            \en Create a sweeping solid. \~
   \details \ru Создать кинематическое тело путем движения образующей кривой вдоль направляющей кривой c дополнительной информацией. \n
            \en Create a sweeping solid by moving the generating curve along the guide curve with additional data. \n \~
-  \param[in] evolSolidParams  - \ru Исходные данные для выполнения операции.
+  \param[in] evolShellParams  - \ru Исходные данные для выполнения операции.
                                 \en The source data to make the operation. \~
   \param[out] result - \ru Построенная оболочка (тело).
                        \en The resultant shell (solid). \~
@@ -672,7 +672,7 @@ MATH_FUNC (MbResultType) EvolutionSolid( const MbSweptData &           sweptData
   \ingroup Solid_Modeling
 */
 // ---
-MATH_FUNC (MbResultType) EvolutionSolid( const MbEvolutionSolidParams & evolSolidParams,
+MATH_FUNC (MbResultType) EvolutionShell( const MbEvolutionShellParams & evolShellParams,
                                                c3d::SolidSPtr &         result );
 
 
@@ -1010,7 +1010,7 @@ MATH_FUNC (MbCurve3D *) TrimClosedSpine( const MbCurve3D & curve,
   \ingroup Solid_Modeling
 */
 // ---
-//DEPRECATE_DECLARE_REPLACE( EvolutionResult with 'MbEvolutionSolidParams' argument )
+//DEPRECATE_DECLARE_REPLACE( EvolutionResult with 'MbEvolutionShellParams' argument )
 MATH_FUNC(MbResultType) EvolutionResult(       MbSolid &               solid, 
                                                MbeCopyMode             sameShell,
                                          const MbSweptData &           sweptData,
@@ -1040,7 +1040,9 @@ MATH_FUNC(MbResultType) EvolutionResult(       MbSolid &               solid,
                         \en The first solid for a boolean operation. \~
   \param[in] copyMode - \ru Режим копирования тела.
                         \en Whether to copy the solid. \~
-  \param[in] evolSolParams - \ru Исходные данные для создания кинематического тела.
+  \param[in] oType    - \ru Тип булевой операции.
+                        \en A boolean operation type. \~
+  \param[in] evShellParams - \ru Исходные данные для создания кинематического тела.
                              \en The source data for making evolution solid. \~
   \param[out] result  - \ru Построенное тело.
                         \en The resultant solid. \~
@@ -1052,7 +1054,7 @@ MATH_FUNC(MbResultType) EvolutionResult(       MbSolid &               solid,
 MATH_FUNC( MbResultType ) EvolutionResult( const c3d::SolidSPtr &         srcSolid,
                                            const MbeCopyMode              copyMode,
                                                  OperationType            oType,
-                                           const MbEvolutionSolidParams & evolSolParams,
+                                           const MbEvolutionShellParams & evShellParams,
                                                  c3d::SolidSPtr &         result );
 
 

C3d/Include/cr_evolution_solid.h

@@ -15,7 +15,7 @@
 #include <cr_swept_solid.h>
 
 
-class MATH_CLASS MbEvolutionSolidParams;
+class MATH_CLASS MbEvolutionShellParams;
 
 
 //------------------------------------------------------------------------------
@@ -190,7 +190,7 @@ IMPL_PERSISTENT_OPS( MbCurveEvolutionSolid )
                         \en The method of copying faces. \~
   \param[in] oType    - \ru Тип операции дополнения построения.
                         \en Type of operation of construction complement. \~
-  \param[in] evolSolParams - \ru Исходные данные для создания оболочки кинематического тела.
+  \param[in] evShellParams - \ru Исходные данные для создания оболочки кинематического тела.
                              \en The source data for making a shell of evolution solid. \~
   \param[out] res - \ru Код результата операции.
                     \en Operation result code. \~
@@ -204,7 +204,7 @@ IMPL_PERSISTENT_OPS( MbCurveEvolutionSolid )
 MATH_FUNC (c3d::CreatorSPtr) CreateCurveEvolution(       c3d::ShellSPtr &         srcSolid,
                                                          MbeCopyMode              copyMode,
                                                          OperationType            oType,
-                                                   const MbEvolutionSolidParams & evolSolParams,
+                                                   const MbEvolutionShellParams & evShellParams,
                                                          MbResultType &           res,
                                                          c3d::ShellSPtr &         resShell );
 
@@ -245,7 +245,7 @@ MATH_FUNC (c3d::CreatorSPtr) CreateCurveEvolution(       c3d::ShellSPtr &
   \ingroup Model_Creators
 */
 // ---
-//DEPRECATE_DECLARE_REPLACE( CreateCurveEvolution with 'MbEvolutionSolidParams' argument )
+//DEPRECATE_DECLARE_REPLACE( CreateCurveEvolution with 'MbEvolutionShellParams' argument )
 MATH_FUNC (MbCreator *) CreateCurveEvolution(       MbFaceShell *           solid,
                                                     MbeCopyMode             sameShell,
                                               const MbSweptData &           sweptData,
@@ -294,7 +294,7 @@ MATH_FUNC (MbCreator *) CreateCurveEvolution(       MbFaceShell *           soli
   \ingroup Model_Creators
 */
 // ---
-//DEPRECATE_DECLARE_REPLACE( CreateCurveEvolution with 'MbEvolutionSolidParams' argument )
+//DEPRECATE_DECLARE_REPLACE( CreateCurveEvolution with 'MbEvolutionShellParams' argument )
 MATH_FUNC (MbCreator *) CreateCurveEvolution(       MbFaceShell *           solid,
                                                     MbeCopyMode             sameShell,
                                               const MbSweptData &           sweptData,

C3d/Include/cr_unwrap_curve.h

@@ -0,0 +1,95 @@
+////////////////////////////////////////////////////////////////////////////////
+/** 
+  \file
+  \brief \ru Строитель развёрнутой кривой.
+         \en Unwrapped curve creator.
+*/
+////////////////////////////////////////////////////////////////////////////////
+  
+#ifndef __CR_UNWRAP_CURVE_H
+#define __CR_UNWRAP_CURVE_H
+
+#include <creator.h>
+#include <op_curve_parameter.h>
+
+//------------------------------------------------------------------------------
+/** \brief \ru Строитель развёрнутой кривой.
+           \en Unwrapped curve creator. \~
+  \details \ru Строитель развёрнутой кривой.\n
+           \en Unwrapped curve creator.\n \~
+  \ingroup Model_Creators
+*/
+// ---
+class MATH_CLASS MbUnwrapCurveCreator : public MbCreator {
+  /// \ru Параметры разворачивания. \en Parameters of the unwrapping.
+  MbCurvesWrappingParams _params;
+
+protected:
+  /// \ru Конструктор копирования. \en Copy-constructor.
+  MbUnwrapCurveCreator( const MbUnwrapCurveCreator & other, MbRegDuplicate * iReg );
+
+public:
+  /// \ru Конструктор по параметрам. \en Constructor by parameters.
+  MbUnwrapCurveCreator( const MbCurvesWrappingParams & params );
+
+public:
+  virtual ~MbUnwrapCurveCreator() {};
+
+  // \ru Общие функции строителя. \en The common functions of the creator.
+  MbeCreatorType  IsA()                                       const override; // \ru Тип элемента \en A type of element 
+  MbCreator & Duplicate( MbRegDuplicate * iReg = nullptr )    const override; // \ru Сделать копию \en Create a copy
+
+  bool        IsSame   ( const MbCreator &, double accuracy ) const override; // \ru Являются ли объекты равными? \en Determine whether an object is equal?
+  bool        IsSimilar( const MbCreator & )                  const override; // \ru Являются ли объекты подобными \en Whether the objects are similar 
+  bool        SetEqual ( const MbCreator & )                        override; // \ru Сделать равным \en Make equal
+
+  void        Transform( const MbMatrix3D &, MbRegTransform * = nullptr ) override; // \ru Преобразовать элемент согласно матрице \en Transform element according to the matrix
+  void        Move     ( const MbVector3D &, MbRegTransform * = nullptr ) override; // \ru Сдвиг \en Translation
+  void        Rotate   ( const MbAxis3D &, double angle, MbRegTransform * = nullptr ) override; // \ru Повернуть вокруг оси \en Rotate about an axis
+
+  MbePrompt   GetPropertyName()                          override; // \ru Дать имя свойства объекта \en Get the object property name  
+  void        GetProperties  ( MbProperties & )          override; // \ru Выдать свойства объекта \en Get properties of the object 
+  void        SetProperties  ( const MbProperties & )    override; // \ru Записать свойства объекта \en Set properties of the object 
+
+  // \ru Построить кривую по журналу построения \en Create a curve from the history tree 
+  bool        CreateWireFrame( MbWireFrame *&, MbeCopyMode, RPArray<MbSpaceItem> * items = nullptr ) override;
+
+private:
+  MbUnwrapCurveCreator(); // \ru Не реализовано \en Not implemented 
+  OBVIOUS_PRIVATE_COPY ( MbUnwrapCurveCreator );
+  DECLARE_PERSISTENT_CLASS_NEW_DEL( MbUnwrapCurveCreator );
+}; // MbUnwrapCurveCreator
+
+IMPL_PERSISTENT_OPS( MbUnwrapCurveCreator )
+
+
+////////////////////////////////////////////////////////////////////////////////
+//
+//                            Неклассные функции
+//
+////////////////////////////////////////////////////////////////////////////////
+
+
+//------------------------------------------------------------------------------
+/** \brief \ru Создание строителя развёрнутой кривой.
+           \en Create a constructor of unwrapped curve. \~
+  \details \ru Создание строителя развёрнутой кривой. Ожидется, что на вход будет подана одна кривая, или набор связных кривых.
+               Иначе корректное разворачивание не гарантируется. \n
+           \en Create a constructor of unwrapped curve. It is expected to receive as input 1 curve or an array of connected curves.
+               Otherwise the correct unwrapping is not guaranteed. \n \~
+  \param[in] parameters - \ru Параметры операции.
+                          \en Parameters of the operation. \~
+  \param[out] res       - \ru Код результата операции.
+                          \en Operation result code. \~
+  \param[out] resWire   - \ru Возвращаемая развёрнутая кривая. Может быть nullptr.
+                          \en The unwrapped curve. Can be nullptr. \~
+  \result \ru Возвращает строитель.
+          \en Returns the creator. \~
+  \ingroup Curve3D_Modeling
+*/
+// ---
+MATH_FUNC( c3d::CreatorSPtr ) CreateUnwrappedCurve( const MbCurvesWrappingParams & parameters,
+                                                          MbResultType &           res,
+                                                          c3d::WireFrameSPtr &     resWire );
+
+#endif // __CR_UNWRAP_CURVE_H

C3d/Include/creator.h

@@ -90,6 +90,8 @@ enum MbeCreatorType {
   ct_FairFilletCreator        = 211,  ///< \ru Строитель изменения плавной кривой по ломаной. \en Constructor of changing a fair curve by a polyline. \n
   ct_FairClothoidCreator      = 212,  ///< \ru Строитель изменения плавной кривой по ломаной. \en Constructor of changing a fair curve by a polyline. \n
   ct_FairChangeCreator        = 213,  ///< \ru Строитель изменения плавной кривой по ломаной. \en Constructor of changing a fair curve by a polyline. \n
+  ct_UnwrapCurveCreator       = 214,  ///< \ru Строитель развёрнутой кривой. \en Constructor of the unwrapped curve. \n
+  ct_WrapCurveCreator         = 215,  ///< \ru Строитель cвёрнутой кривой. \en Constructor of the wrapped curve. \n
 
   // \ru Строители полигональных объектов. \en Creators of polygonal objects. 
   ct_SimpleMeshCreator        = 400,  ///< \ru Строитель полигонального объекта без истории. \en Constructor of a polygonal object without history. 

C3d/Include/cur_nurbs3d.h

@@ -91,7 +91,7 @@ private:
     MbNurbs3DAuxiliaryData( const MbNurbs3DAuxiliaryData & init );
     virtual ~MbNurbs3DAuxiliaryData();
     void FreeMemory();
-    bool CatchMemory(  ptrdiff_t, bool );
+    bool CatchMemory( const ptrdiff_t &, bool );
   }; // MbNurbs3DAuxiliaryData
 
   mutable CacheManager<MbNurbs3DAuxiliaryData> cache;

C3d/Include/curve.h

@@ -786,30 +786,35 @@ public :
 
   /** \brief \ru Найти проекцию точки на кривую.
              \en Find the point projection to the curve. \~
-    \details \ru Найти ближайшую проекцию точки на кривую или ее продолжение по заданному начальному приближению. 
-      Если задан диапазон изменения параметра tRange - то надо найти проекцию в заданном диапазоне.
-      Диапазон параметра может выходить за область определения параметра кривой.
-      Используется метод Ньютона.
-             \en Find the nearest point projection to the curve or its by the given initial approximation. 
-      If the range of parameter changing 'tRange' is set, then find a projection in the given range.
-      A range of parameter may not belong to the domain of a curve.
-      The Newton method is used. \~
+    \details \ru Найти ближайшую проекцию точки на кривую (в диапазоне кривой) или на ее продолжение по заданному начальному приближению.
+              Если параметр ext = true, то также выполняется поиск проекции на продолжение кривой.
+              Если задан диапазон изменения параметра 'tRange', то нужно найти проекцию в заданном диапазоне.
+              Диапазон параметра может выходить за область определения параметра кривой.
+              Используется метод Ньютона.
+             \en Find the nearest projection of a point on a curve (in the range of the curve) or on its continuation
+              by the given initial approximation.
+              If the parameter ext = true, then also search for a projection on the continuation of the curve.
+              If the range of change of the 'tRange' parameter is specified, then find the projection in the specified range.
+              A range of parameter may not belong to the domain of a curve.
+              The Newton method is used. \~
     \note    \ru Математическое ядро обеспечивает потокобезопасную реализацию функции для своих объектов. 
              \en Mathematical kernel provides a thread-safe function implementation for its objects. \~
-    \param[in] pnt - \ru Заданная точка.
-                     \en A given point. \~
+    \param[in] pnt -      \ru Заданная точка.
+                          \en A given point. \~
     \param[in] xEpsilon - \ru Точность определения проекции по оси x.
                           \en A tolerance of detection of the projection by x axis. \~
     \param[in] yEpsilon - \ru Точность определения проекции по оси y.
                           \en A tolerance of detection of the projection by y axis. \~
-    \param[in,out] t - \ru На входе - начальное приближение, на выходе - параметр кривой, соответствующий ближайшей проекции.
-                       \en Input - initial approximation, output - parameter of a curve corresponding to the nearest projection. \~
-    \param[in] ext - \ru Флаг, определяющий, искать ли проекцию на продолжении кривой (если true, то искать).
-                     \en A flag defining whether to seek projection on the extension of the curve. \~ 
-    \param[in] tRange - \ru Диапазон изменения параметра, в котором надо найти решение.
-                        \en A range of parameter changing in which the solution should be found. \~
-    \result \ru true - если найдена проекция, удовлетворяющая всем входным условиям.
-            \en True - if there is found a projection which satisfies to all input conditions. \~
+    \param[in,out] t -    \ru На входе - начальное приближение, на выходе - параметр кривой, соответствующий ближайшей проекции.
+                          \en Input - initial approximation, output - parameter of a curve corresponding to the nearest projection. \~
+    \param[in] ext -      \ru Флаг, определяющий, искать ли проекцию на продолжении кривой (если true, то искать).
+                          \en A flag defining whether to seek projection on the extension of the curve. \~ 
+    \param[in] tRange -   \ru Диапазон изменения параметра, в котором надо найти решение.
+                          \en A range of parameter changing in which the solution should be found. \~
+    \return \ru Возвращает true, если найденный параметр находится в допустимом диапазоне (в соответствии с заданными параметрами ext, tRange),
+            или false - в противном случае.
+            \en Returns true if the found parameter is in a valid range (according to the given ext, tRange parameters),
+            or false - otherwise. \~
   */
   virtual bool        NearPointProjection( const MbCartPoint & pnt, double xEpsilon, double yEpsilon, 
                                            double & t, bool ext, MbRect1D * tRange = nullptr ) const;

C3d/Include/curve3d.h

@@ -641,24 +641,29 @@ public :
   // \ru Ближайшая проекция точки на кривую. \en The nearest projection of a point onto the curve. 
     /** \brief \ru Найти проекцию точки на кривую.
                \en Find the point projection to the curve. \~
-    \details \ru Найти ближайшую проекцию точки на кривую или ее продолжение по заданному начальному приближению. 
-      Если задан диапазон изменения параметра tRange - то надо найти проекцию в заданном диапазоне.
-      Диапазон параметра может выходить за область определения параметра кривой.
-      Используется метод Ньютона.
-             \en Find the nearest point projection to the curve or its by the given initial approximation. 
-      If the range of parameter changing 'tRange' is set, then find a projection in the given range.
-      A range of parameter may not belong to the domain of a curve.
-      The Newton method is used. \~
-    \param[in] pnt - \ru Заданная точка.
-                     \en A given point. \~
-    \param[in,out] t - \ru На входе - начальное приближение, на выходе - параметр кривой, соответствующий ближайшей проекции.
-                       \en Input - initial approximation, output - parameter of a curve corresponding to the nearest projection. \~
-    \param[in] ext - \ru Флаг, определяющий, искать ли проекцию на продолжении кривой (если true, то искать).
-                     \en A flag defining whether to seek projection on the extension of the curve. \~ 
+    \details \ru Найти ближайшую проекцию точки на кривую (в диапазоне кривой) или на ее продолжение по заданному начальному приближению.
+              Если параметр ext = true, то также выполняется поиск проекции на продолжение кривой.
+              Если задан диапазон изменения параметра 'tRange', то нужно найти проекцию в заданном диапазоне.
+              Диапазон параметра может выходить за область определения параметра кривой.
+              Используется метод Ньютона.
+             \en Find the nearest projection of a point on a curve (in the range of the curve) or on its continuation
+              by the given initial approximation.
+              If the parameter ext = true, then also search for a projection on the continuation of the curve.
+              If the range of change of the 'tRange' parameter is specified, then find the projection in the specified range.
+              A range of parameter may not belong to the domain of a curve.
+              The Newton method is used. \~
+    \param[in] pnt -    \ru Заданная точка.
+                        \en A given point. \~
+    \param[in,out] t -  \ru На входе - начальное приближение, на выходе - параметр кривой, соответствующий ближайшей проекции.
+                        \en Input - initial approximation, output - parameter of a curve corresponding to the nearest projection. \~
+    \param[in] ext -    \ru Флаг, определяющий, искать ли проекцию на продолжении кривой (если true, то искать).
+                        \en A flag defining whether to seek projection on the extension of the curve. \~ 
     \param[in] tRange - \ru Диапазон изменения параметра, в котором надо найти решение.
                         \en A range of parameter changing in which the solution should be found. \~
-    \result \ru true - если найдена проекция, удовлетворяющая всем входным условиям.
-            \en True - if there is found a projection which satisfies to all input conditions. \~
+    \return \ru Возвращает true, если найденный параметр находится в допустимом диапазоне (в соответствии с заданными параметрами ext, tRange),
+            или false - в противном случае.
+            \en Returns true if the found parameter is in a valid range (according to the given ext, tRange parameters),
+            or false - otherwise. \~
     \ingroup Curves_3D
   */
   virtual bool        NearPointProjection  ( const MbCartPoint3D &pnt, double & t, bool ext, MbRect1D * tRange = nullptr ) const;

C3d/Include/func_nurbs_function.h

@@ -15,7 +15,7 @@
 #include <templ_s_array.h>
 #include <mb_nurbs_function.h>
 #include <cur_nurbs_vector.h>
-
+#include <tool_multithreading.h>
 
 //------------------------------------------------------------------------------
 /** \brief \ru NURBS функция.
@@ -38,6 +38,29 @@ protected:
   ptrdiff_t      uppKnotsIndex; ///< \ru Последний индекс узлового вектора. \en Last index of knot vector. 
   bool           closed;        ///< \ru Признак замкнутости кривой. \en An attribute of curve closedness. 
 
+
+  //------------------------------------------------------------------------------
+/** \brief \ru Вспомогательные данные.
+           \en Auxiliary data. \~
+  \details \ru Вспомогательные данные служат для ускорения работы объекта.
+           \en Auxiliary data are used for fast calculations. \n \~
+*/
+// ---
+  class MbNurbsFunctionAuxiliaryData : public AuxiliaryData {
+  public:
+    Array2<double>  values;
+    SArray<double>  pointsM;
+    SArray<double>  weightM;
+
+  public:
+    MbNurbsFunctionAuxiliaryData() : values(), pointsM(), weightM() {}
+    MbNurbsFunctionAuxiliaryData( const MbNurbsFunctionAuxiliaryData & ) : values(), pointsM(), weightM() {}
+    virtual ~MbNurbsFunctionAuxiliaryData() {}
+  };
+
+  mutable CacheManager<MbNurbsFunctionAuxiliaryData> cache;
+
+
 public :
   /// \ru Конструктор по точкам и признаку замкнутости. \en Constructor by points and an attribute of closedness. 
   MbNurbsFunction( size_t d, const SArray<double> & values, bool cls );

C3d/Include/math_x.h

@@ -10,7 +10,7 @@
 #ifndef __MATHX_H
 #define __MATHX_H
 
-#include <math_cfg.h>
+#include <system_cpp_standard.h>
 
 #if !defined ( C3D_WINDOWS )  //_MSC_VER
 
@@ -31,9 +31,6 @@
   #ifndef __SIZEOF_WCHAR_T__ 
     #define __SIZEOF_WCHAR_T__  4
   #endif
-   
-  #define  DEPRECATE_DECLARE __attribute__((deprecated))
-  #define  DEPRECATE_DECLARE_REPLACE(func) DEPRECATE_DECLARE
 
 #else // C3D_WINDOWS
 
@@ -88,6 +85,8 @@ namespace c3d {
   #endif //__INTEL_COMPILER
 
 
+#endif //C3D_WINDOWS   
+
 //------------------------------------------------------------------------------
 
 
@@ -102,10 +101,18 @@ namespace c3d {
 // \ru Макросы для объявления устаревшего интерфейса.
 // \en Macros for deprecated API declaration.
 // ---
+#ifdef C3D_STANDARD_CXX_14
+#define DEPRECATE_DECLARE               [[deprecated( DEPR_MSG )]]
+#define DEPRECATE_DECLARE_REPLACE(func) [[deprecated( DEPR_MSG_EX(func) )]]
+#else
+#if !defined ( C3D_WINDOWS )  //_MSC_VER
+#define  DEPRECATE_DECLARE __attribute__((deprecated))
+#define  DEPRECATE_DECLARE_REPLACE(func) DEPRECATE_DECLARE
+#else
 #define DEPRECATE_DECLARE               __declspec( deprecated( DEPR_MSG ) )
 #define DEPRECATE_DECLARE_REPLACE(func) __declspec( deprecated( DEPR_MSG_EX(func) ) )
-
-#endif //C3D_WINDOWS   
+#endif //_MSC_VER
+#endif // C3D_STANDARD_CXX_14
 
 
 namespace c3d {

C3d/Include/mb_cart_point.h

@@ -301,6 +301,8 @@ public :
   MbCartPoint operator + ( const MbVector & vector ) const;
   /// \ru Вычесть вектор из точки. \en Subtract a vector from a point. 
   MbCartPoint operator - ( const MbVector & vector ) const;
+  /// \ru Присвоить точке значения другой точки. \en Assign the value of another point to the point. 
+  MbCartPoint & operator = ( const MbCartPoint & );
   /// \ru Присвоить точке значения компонент вектора. \en Assign values of vector components to the point. 
   void        operator = ( const MbVector     & );
   /// \ru Присвоить точке значения компонент вектора. \en Assign values of vector components to the point. 
@@ -746,6 +748,15 @@ inline void MbCartPoint::operator -= ( MbVector & v )
 }
 
 
+//------------------------------------------------------------------------------
+// \ru Присвоить точке значения другой точки. \en Assign the value of another point to the point. 
+// ---
+inline MbCartPoint & MbCartPoint::operator = ( const MbCartPoint & fp ) {
+  x = fp.x;
+  y = fp.y;
+  return *this;
+}
+
 //------------------------------------------------------------------------------
 // \ru Присвоение точки значений вектора. \en The assignment of vector values to the point. 
 // ---

C3d/Include/mb_oriented_box.h

@@ -0,0 +1,235 @@
+//////////////////////////////////////////////////////////////////////////////////////////
+/** 
+  \file
+  \brief \ru Ограничивающий параллелепипед с произвольной ориентацией в пространстве.
+         \en Arbitrarily oriented bounding box (OBB). \~
+*/
+//////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef __MB_ORIENTED_BOX_H
+#define __MB_ORIENTED_BOX_H
+
+#include <array>
+#include <mb_cart_point3d.h>
+#include <mb_matrix3d.h>
+
+//----------------------------------------------------------------------------------------
+/**  \brief \ru Ограничивающий параллелепипед с произвольной ориентацией в пространстве.
+            \en An arbitrarily oriented bounding box (OBB) that includes some geometric object within box boundaries.\~
+
+  \details \ru Ограничивающий параллелепипед определяет область 3D-пространства, более или менее плотно 
+    обволакивающую некоторый геометрический объект.\n
+    Используется для быстрой оценки близости или непересечения трёхмерных объектов,
+    содержащихся в параллелепипеде.
+           \en A bounding box (parallelepiped, PE) specifies a domain of 3D-space that more or 
+    less tightly packs some geometric object.\n
+    It is used for quick estimation of the proximity or non-intersection of three-dimensional objects 
+    which are contained in the "box". \~
+  \ingroup Mathematic_Base_3D
+*/
+//---
+class MATH_CLASS MbOrientedBox
+{
+private:
+  static constexpr size_t vertNb = 8;       ///< \ru Количество вершин параллелепипеда. \en. Number of vertices of the box.\~
+  MbCartPoint3D m_center;                   ///< \ru Центр параллелепипеда. \en Center of the parallelepiped.\~
+  MbVector3D    m_xAxis, m_yAxis, m_zAxis;  ///< \ru Ортогонормированная тройка векторов ориентации. \en The orthogonormal triplet of orientation vectors.\~
+
+  /** \brief  \ru Границы векторного интервала ограничивающего объема, заданного по осям ящика, но от начала мировой СК.
+              \en Lower and upper bounds of the OBB intervals. Specified on the box axies but via WCS origin.\~
+  */
+  MbVector3D    m_lBnd, m_uBnd;               
+  double        m_xDim, m_yDim, m_zDim;     ///< \ru Половина длины, ширины, высоты. \en Half the box dimension values.
+  std::array<MbCartPoint3D,vertNb> m_verts; ///< \ru Все восемь вершин. \en Eight vertices of the PE.\~
+
+public:
+  /// \ru Конструктор пустого пустого объема. \en Construct an empty box.
+  MbOrientedBox();
+  MbOrientedBox( const MbOrientedBox & );
+  /// \ru Оператор присвоения. \en Assignment operator. \~
+  MbOrientedBox & operator = ( const MbOrientedBox & );
+
+public: /*  Functions of the box coordinate system. The bounding box has
+            its proper orienting LCS that provides corresponding functions like #MbPlacement3D.
+        */
+  const MbCartPoint3D & GetOrigin() const { return m_center; }
+  const MbVector3D &    GetAxisX() const { return m_xAxis; }
+  const MbVector3D &    GetAxisY() const { return m_yAxis; }
+  const MbVector3D &    GetAxisZ() const { return m_zAxis; }
+  const MbVector3D &    GetAxis( size_t i ) const { return i == 0 ? m_xAxis : (i==1 ? m_yAxis : m_zAxis); }
+
+public: /*  Properties of the oriented parallelepiped.
+        */
+        /** \brief \ru Геометрический центр ограничивающего объема находится в середине 
+                       главной диагонали параллелепипеда.
+                   \en Geometric center of the bounding box is in the middle of the main diagonal of PE.\~
+        */
+  const MbCartPoint3D & Centre() const { return m_center; }  
+
+        /** \brief  \ru Вершина параллелепипеда по индексу от 0 до 7.
+                    \en One of the eight vertices by 0-based index.\~
+            \note   \ru Правило нумерации вершин приведено в "mb_oriented_box.h" ниже объявления функции.
+                    \en The rule of numbering vertices is given in "mb_oriented_box.h" below the function declaration. \~
+        */
+  const MbCartPoint3D & Vertex( size_t i ) const { return m_verts[i]; }        
+        /*
+          The rule of the numbering is not equal to MbCube.
+                 Z
+                 |
+                 4--------------6   
+                /|             /|
+               / |            / |
+              /  |           /  |
+             5---+----------7   |
+             |   |          |   |
+             |   0----------+---2 - Y
+             |  /           |  /
+             | /            | /
+             |/             |/ 
+             1--------------3 
+            /
+           X
+        */
+
+        /// \ru Половина наибольшей диагонали параллелепипеда в собственной ЛСК. \en Half of the longest diagonal of the parallelepiped in the proper coordinate system. 
+        MbVector3D      SemiDiagonal() const { return MbVector3D( m_xDim, m_yDim, m_zDim ); }
+        /// \ru Размер ящика, равный наибольшему из размеров по трем осям. \en The size of the box is equal to the maximum of the dimensions along its axes.
+        double          SizeMax() const; 
+
+public: /*  Set-theoretic functions. Теоретико-множественные функции.
+        */
+
+  /** \brief \ru Проверка на пустоту. \en The check for emptiness.\~
+      \details \ru Параллелепипед считается пустым, если он не содержит ни одной точки 3D-пространства.
+               \en A bounding box is empty if it doesn't contain any points of 3D-space. \~
+  */
+  bool  IsEmpty() const { return ( m_lBnd.x > m_uBnd.x ) || ( m_lBnd.y > m_uBnd.y ) || ( m_lBnd.z > m_uBnd.z ); }
+
+  /** \brief \ru Пересекается ли параллелепипед с другим параллелепипедом. \en Whether the box intersects another box or not.\~
+      \return \ru true, если пересекается.
+              \en Returns true if it intersects. \~
+  */  
+  bool  Intersect( const MbOrientedBox & ) const;
+
+  /// \ru Включить в подмножество ящика точку с сохранением ориентации. \en Include a point in the box subset with orientation preserved.\~
+  void  Include( const MbCartPoint3D & ); 
+
+public: /* Setting and transforming functions.
+        */
+  /** \brief \ru Задать положение и ориентацию параллелепипеда. \en Set the position and orientation of PE.\~
+      \details \ru Функция задает положение и ориентацию, а именно координаты центра и векторную пару осей (X,Y).
+               \en The func sets the position and orientation, namely coordinates of center and vector pair of (X,Y)-axies.\~
+  */
+  MbOrientedBox &   SetOXY( const MbCartPoint3D & centre, const MbVector3D &, const MbVector3D & );
+
+  /// \ru Задать полу-размеры параллелепипеда по трем осям (X,Y,Z). \en Sets the semi-dimensions of the parallelepiped by the axies (X,Y,Z).\~
+  MbOrientedBox &   SetSize( double wx, double wy, double wz ) { m_xDim = wx; m_yDim = wy; m_zDim = wz; return InitData(); }
+
+  /// \ru Сделать параллелепипед пустым. \en Set the box empty.\~
+  MbOrientedBox &   SetEmpty();
+
+  /** \brief \ru Преобразовать согласно матрице. \en Transform according to the matrix.\~
+      \note \ru Корректный результат гарантируется только для изометрических преобразований 
+                (поворот,перенос,отражение) или при равномерных масштабированиях.
+            \en The correct result is only guaranteed for isometric transformations 
+                (rotations,translations and reflections) or uniform scalings.  \~
+  */
+  MbOrientedBox &   Transform( const MbMatrix3D & );
+
+  /** \brief \ru Перенести на заданный вектор. \en Translate to the given vector.\~
+  */
+  MbOrientedBox &   Move( const MbVector3D & );
+
+  /** \brief  \ru Нижняя граница интервального радиус-вектора, охватывающая область ящика (по проекциям осей, но через начало МСК).
+              \en The lower bound of the interval radius-vector covering the box range (projections on the box axies but via the world origin).\~
+  */
+  const MbVector3D  LowerBnd() const { return m_lBnd; }
+
+  /** \brief  \ru Верхняя граница интервального радиус-вектора, охватывающая область ящика (в глобальной СК).
+              \en The upper bound of the interval radius-vector covering the box range (in the local CS).\~
+  */
+  const MbVector3D  UpperBnd() const { return m_uBnd; }
+
+private: // Interval functions.
+  double  LowerBnd( size_t i ) const { return m_lBnd[i]; }
+  double  UpperBnd( size_t i ) const { return m_uBnd[i]; }
+
+  /** \brief  \ru Инициализация внутреннего представления: интервальный вектор и вершины.
+              \en Initializing internal representation: the interval vector and vertices. \~
+  */
+  MbOrientedBox & InitData() { return InitBounds().InitVertices(); }
+
+  /** \brief  \ru Переинициализировать интервальный вектор.
+              \en Re-initialize the interval vector. \~
+  */
+  MbOrientedBox & InitBounds();
+
+  /** \brief  \ru Переинициализировать вершины всем остальным данным (вершины - зависимые).
+              \en Re-initialize vertices as dependent data. \~
+  */
+  MbOrientedBox & InitVertices();
+};
+
+
+//---------------------------------------------------------------------------------------
+/** \brief  \ru Матрица получения ограничивающего параллелепипеда из единичного куба. 
+            \en Transformation matrix yielding bounding parallelepiped from the unit cube. \~
+*/
+//---
+inline MbMatrix3D & GetMatrixFromUCube( const MbOrientedBox & bBox, MbMatrix3D & m )
+{
+  m = MbMatrix3D::identity;
+  const MbVector3D & hDiag = bBox.SemiDiagonal();
+  m.SetOrigin() = bBox.GetOrigin();
+  m.SetAxisZ() = 2.0 * bBox.GetAxisZ() * hDiag.z;
+  m.SetAxisX() = 2.0 * bBox.GetAxisX() * hDiag.x;
+  m.SetAxisY() = 2.0 * bBox.GetAxisY() * hDiag.y;
+  return m;
+}
+
+//------------------------------------------------------------------------------
+//
+//---
+inline MbOrientedBox & MbOrientedBox::operator = ( const MbOrientedBox & box )
+{
+  m_center = box.m_center;
+  m_xAxis  = box.m_xAxis;
+  m_yAxis  = box.m_yAxis;
+  m_zAxis  = box.m_zAxis;
+  m_xDim = box.m_xDim;
+  m_yDim = box.m_yDim;
+  m_zDim = box.m_zDim;
+
+  m_verts = box.m_verts;
+  m_lBnd = box.m_lBnd;
+  m_uBnd = box.m_uBnd;
+
+  return *this;
+}
+
+//-----------------------------------------------------------------------------
+// \ru Сделать параллелепипед пустым. \en Set the box empty.\~
+//---
+inline MbOrientedBox & MbOrientedBox::SetEmpty()
+{
+  m_center = MbCartPoint3D::origin;
+  m_xAxis  = MbVector3D::xAxis;
+  m_yAxis  = MbVector3D::yAxis;
+  m_zAxis  = MbVector3D::zAxis;
+  m_xDim = m_yDim = m_zDim = 0;
+
+  m_verts.fill( m_center );
+  m_lBnd.x = m_lBnd.y = m_lBnd.z =  MB_MAXDOUBLE;
+  m_uBnd.x = m_uBnd.y = m_uBnd.z = -MB_MAXDOUBLE;
+  return *this;
+}
+
+//-----------------------------------------------------------------------------
+// Размер ящика, равный наибольшему размеру по трем осям.
+//---
+inline double MbOrientedBox::SizeMax() const
+{
+  return 2.0 * (std::max)( m_xDim, (std::max)(m_yDim,m_zDim) );
+}
+
+#endif // __MB_ORIENTED_BOX_H

C3d/Include/mb_property_title.h

@@ -166,6 +166,9 @@ enum MbePrompt
   IDS_ITEM_0266,     ///< \ru Измененная плавная кривая. \en Modified Fair curve.
   IDS_ITEM_0267,     ///< \ru Плавная кривая сопряжения. \en Fair Fillet curve.
   IDS_ITEM_0268,     ///< \ru Клотоида. \en Clothoid.
+  IDS_ITEM_0269,     ///< \ru Развернутая кривая. \en Unwrapped curve.
+  IDS_ITEM_0270,     ///< \ru Свёрнутая кривая. \en Wrapped curve.
+
 
 // \ru Типы параметрических поверхностей. \en Types of parametric surfaces. 
 

C3d/Include/mb_rect.h

@@ -277,6 +277,8 @@ public:
   void        Move( double dx, double dy );
   /// \ru Масштабировать относительно 0. \en Scale relative to 0. 
   void        Scale( double scale );
+  /// \ru Масштабировать относительно точки. \en Scale relative to point. 
+  void        Scale( const MbCartPoint & point, double scale );
 
   /// \ru Расширить прямоугольник. \en Extend rectangle. 
   void        Enlarge( double x, double y );

C3d/Include/mb_smooth_nurbs_fit_curve.h

@@ -409,11 +409,11 @@ public:
                            \en Array of constraints for points and derivatives. First - index of fixed point. Second - derivative vector constraint,
                                if nullptr - derivative is unconstrained for this point. \~
 */
-  void        InitConstraints( const std::vector<Point> &                       aPt,
-                               size_t                                           order,
-                               double                                           tolerance,
-                               bool                                             bClosed,
-                               const std::vector<std::pair<size_t, Vector *>> & constraints )
+  void        InitConstraints( const std::vector<Point> &                             aPt,
+                                     size_t                                           order,
+                                     double                                           tolerance,
+                                     bool                                             bClosed,
+                               const std::vector<std::pair<size_t, const Vector *>> & constraints )
   {
     _bClosed = bClosed;
     _order = order;

C3d/Include/mb_vector.h

@@ -132,6 +132,8 @@ public :
   MbVector &  Perpendicular();
   /// \ru Выдать перпендикуляр к вектору, а именно вектор (-y, x). \en Returns a vector orthogonal to this vector, namely the vector (-y, x).
   MbVector    operator ~ () const;
+  /// \ru Присвоить вектору значения другого вектора. \en Assign the value of another vector to the vector. 
+  MbVector & operator = ( const MbVector & );
   /// \ru Присвоить вектору значения координат точки. \en Assign point coordinate values to vector. 
   MbVector &  operator = ( const MbCartPoint & );
   /// \ru Присвоить вектору значения однородных координат точки. \en Assign uniform point coordinate values to vector. 
@@ -743,6 +745,17 @@ inline MbVector::MbVector( const MbDirection & dir )
 }
 
 
+//------------------------------------------------------------------------------
+// \ru Присвоить вектору значения другого вектора. \en Assign the value of another vector to the vector. 
+// ---
+inline MbVector & MbVector::operator = ( const MbVector & v )
+{
+  x = v.x;
+  y = v.y;
+  return *this;
+}
+
+
 //------------------------------------------------------------------------------
 // \ru Присвоение вектору значений нормализованного вектора \en Assign normalized vector values to vector 
 // ---

C3d/Include/mb_vector3d.h

@@ -180,6 +180,8 @@ public :
   MbVector3D & operator = ( const MbHomogeneous3D & );
   /// \ru Присвоить вектору координаты другого вектора. \en Assign coordinates of another vector to the vector. 
   MbVector3D & operator = ( const MbFloatVector3D & );
+  /// \ru Присвоить вектору значения другого вектора. \en Assign the value of another vector to the vector. 
+  MbVector3D & operator = ( const MbVector3D & );
 
   /// \ru Получить доступ к координате по индексу. \en Access to coordinate by an index. 
   double &    operator [] ( size_t i )       { return i ? (--i ? z : y) : x; };
@@ -373,6 +375,18 @@ inline bool MbVector3D::operator == ( const MbVector3D & with ) const
 }
 
 
+//------------------------------------------------------------------------------
+// \ru Присвоить вектору значения другого вектора. \en Assign the value of another vector to the vector. 
+// ---
+inline MbVector3D & MbVector3D::operator = ( const MbVector3D & v )
+{
+  x = v.x;
+  y = v.y;
+  z = v.z;
+  return *this;
+}
+
+
 //------------------------------------------------------------------------------
 // \ru Проверить на неравенство. \en Check for inequality. 
 // ---

C3d/Include/mesh_primitive.h

@@ -1,4 +1,4 @@
-////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
 /** 
   \file
   \brief \ru Базовый класс для структур данных сетки (#MbMesh). Вершина. Полигон.
@@ -686,24 +686,24 @@ private :
 ////////////////////////////////////////////////////////////////////////////////
 class MATH_CLASS MbGrid : public MbPrimitive {
 protected:
-  std::vector<MbTriangle>      triangles;   ///< \ru Индексное множество треугольных пластин содержит номера элементов множества params и/или множеств points и normals. \en Set of triangular plates contains numbers of elements of 'params' set and/or of 'points' and 'normals' sets. 
-  std::vector<MbQuadrangle>    quadrangles; ///< \ru Индексное множество четырёхугольных пластин содержит номера элементов множества params и/или множеств points и normals. \en Set of quadrangular plates contains numbers of elements of 'params' set and/or of 'points' and 'normals' sets. 
-  std::vector<MbGridLoop *>    loops;       ///< \ru Индексное множество граничных циклов триангуляции содержит номера элементов множества points и/или params. Объект владеет элементами множества. \en Set of bounding loops contains numbers of elements of 'points' set and/or of 'params' set. Ownership of elements of set.
-  MbStepData                   stepData;    ///< \ru Параметр расчета триангуляции. \en Parameter of triangulation calculation.
-  /** \brief \ru Габаритный куб объекта. 
+  std::vector<MbTriangle>       triangles;   ///< \ru Индексное множество треугольных пластин содержит номера элементов множества params и/или множеств points и normals. \en Set of triangular plates contains numbers of elements of 'params' set and/or of 'points' and 'normals' sets. 
+  std::vector<MbQuadrangle>     quadrangles; ///< \ru Индексное множество четырёхугольных пластин содержит номера элементов множества params и/или множеств points и normals. \en Set of quadrangular plates contains numbers of elements of 'params' set and/or of 'points' and 'normals' sets. 
+  std::vector<MbGridLoop *>     loops;       ///< \ru Индексное множество граничных циклов триангуляции содержит номера элементов множества points и/или params. Объект владеет элементами множества. \en Set of bounding loops contains numbers of elements of 'points' set and/or of 'params' set. Ownership of elements of set.
+  MbStepData                    stepData;    ///< \ru Параметр расчета триангуляции. \en Parameter of triangulation calculation.
+  /** \brief \ru Габаритный куб объекта.
              \en Bounding box of object. \~
       \details \ru Габаритный куб объекта рассчитывается только при запросе габарита объекта. Габаритный куб в конструкторе объекта и после модификации объекта принимает неопределенное значение.
                \en Bounding box of object is calculated only at the request. Bounding box of object is undefined after object constructor and after object modifications \n \~
   */
-  mutable MbCube               cube;
-  mutable MbGridSearchTree *   searchTree;  ///< \ru Дерево поиска элементов. \en Elements search tree.
-  mutable c3d::GridTopologyPtr topo;        ///< \ru Дополнительная информация о топологии триангуляции. \en Additional information about a topology of the triangulation.
+  mutable MbCube                cube;
+  mutable MbGridSearchTree *    searchTree;  ///< \ru Дерево поиска элементов. \en Elements search tree.
+  mutable c3d::GridTopologyPtr  topo;        ///< \ru Дополнительная информация о топологии триангуляции. \en Additional information about a topology of the triangulation.
 
 protected:
   // \ru Объявление конструктора копирования без реализации, чтобы не было копирования по умолчанию. \en The copy constructor without implementation prevents from copying by default. 
   MbGrid( const MbGrid & );
   /// \ru Конструктор копирования с регистратором. \en Copy-constructor with the registrator. 
-  explicit MbGrid( const MbGrid &, MbRegDuplicate * ); 
+  explicit MbGrid( const MbGrid &, MbRegDuplicate * );
   /// \ru Конструктор без параметров. \en Constructor without parameters. 
   MbGrid();
 public:
@@ -730,9 +730,9 @@ public:
   /** \} */
   /** \ru \name Функции триангуляции.
       \en \name Functions of triangulation.
-      \{ */  
+      \{ */
   /// \ru Проверить наличие данных. \en Check data availability. 
-          bool    IsComplete() const { return (triangles.size() > 0) || (quadrangles.size() > 0) || (loops.size() > 0); } 
+          bool    IsComplete() const { return (triangles.size() > 0) || (quadrangles.size() > 0) || (loops.size() > 0); }
   /// \ru Выдать количество точек. \en Get the number of points. 
   virtual size_t  PointsCount()  const = 0;
   /// \ru Выдать количество нормалей. \en Get the number of normals. 
@@ -748,42 +748,42 @@ public:
   /// \ru Выдать количество параметров минус 1 (максимальный индекс). \en Get the number of parameters minus one (maximal index). 
   virtual ptrdiff_t ParamsMaxIndex()  const = 0;
 
-          // \ru Выдать количество треугольников. \en Get the number of triangles. 
+          /// \ru Выдать количество треугольников. \en Get the number of triangles. 
           size_t  TrianglesCount() const { return triangles.size(); }
-          // \ru Выдать количество четырёхугольников. \en Get the number of quadrangles. 
+          /// \ru Выдать количество четырёхугольников. \en Get the number of quadrangles. 
           size_t  QuadranglesCount() const { return quadrangles.size(); }
-          // \ru Выдать количество полигонов. \en Get the number of loops. 
+          /// \ru Выдать количество полигонов. \en Get the number of loops. 
           size_t  LoopsCount() const { return loops.size(); }
 
   /// \ru Добавить в триангуляцию параметры, точку и нормаль триангулируемой поверхности в точке. \en Add parameters, point and normal of triangulated surface at point to triangulation. 
-  virtual void    AddPoint ( const MbCartPoint   & p2D, const MbCartPoint3D & p3D, const MbVector3D & n3D ) = 0;
+  virtual void    AddPoint( const MbCartPoint & p2D, const MbCartPoint3D & p3D, const MbVector3D & n3D ) = 0;
   /// \ru Добавить в триангуляцию параметры и точку. \en Add parameters and a point to triangulation. 
-  virtual void    AddPoint ( const MbCartPoint   & p2D, const MbCartPoint3D & p3D ) = 0;
+  virtual void    AddPoint( const MbCartPoint & p2D, const MbCartPoint3D & p3D ) = 0;
   /// \ru Добавить в триангуляцию точку и нормаль в точке. \en Add a point and normal at the point to triangulation. 
-  virtual void    AddPoint ( const MbCartPoint3D & p3D, const MbVector3D & n3D ) = 0;
+  virtual void    AddPoint( const MbCartPoint3D & p3D, const MbVector3D & n3D ) = 0;
   /// \ru Добавить в триангуляцию точку. \en Add a point to triangulation. 
-  virtual void    AddPoint ( const MbCartPoint3D & p3D ) = 0;
+  virtual void    AddPoint( const MbCartPoint3D & p3D ) = 0;
   /// \ru Добавить в триангуляцию нормаль. \en Add a normal to triangulation. 
-  virtual void    AddNormal( const MbVector3D    & n3D ) = 0;
+  virtual void    AddNormal( const MbVector3D & n3D ) = 0;
   /// \ru Добавить в триангуляцию параметры триангулируемой поверхности. \en Add parameters of triangulated surface to triangulation. 
-  virtual void    AddParam ( const MbCartPoint   & p2D ) = 0;
+  virtual void    AddParam( const MbCartPoint & p2D ) = 0;
 
   /// \ru Добавить в триангуляцию параметры, точку и нормаль триангулируемой поверхности в точке. \en Add parameters, point and normal of triangulated surface at point to triangulation. 
-  virtual void    AddPoint ( const MbFloatPoint  & p2D, const MbFloatPoint3D & p3D, const MbFloatVector3D & n3D ) = 0;
+  virtual void    AddPoint( const MbFloatPoint & p2D, const MbFloatPoint3D & p3D, const MbFloatVector3D & n3D ) = 0;
   /// \ru Добавить в триангуляцию параметры и точку. \en Add parameters and a point to triangulation. 
-  virtual void    AddPoint ( const MbFloatPoint  & p2D, const MbFloatPoint3D & p3D ) = 0;
+  virtual void    AddPoint( const MbFloatPoint & p2D, const MbFloatPoint3D & p3D ) = 0;
   /// \ru Добавить в триангуляцию точку и нормаль в точке. \en Add a point and normal at the point to triangulation. 
-  virtual void    AddPoint ( const MbFloatPoint3D & p3D, const MbFloatVector3D & n3D ) = 0;
+  virtual void    AddPoint( const MbFloatPoint3D & p3D, const MbFloatVector3D & n3D ) = 0;
   /// \ru Добавить в триангуляцию точку. \en Add a point to triangulation. 
   virtual void    AddPoint( const MbFloatPoint3D & p3D ) = 0;
   /// \ru Добавить в триангуляцию нормаль. \en Add a normal to triangulation. 
   virtual void    AddNormal( const MbFloatVector3D & n3D ) = 0;
   /// \ru Добавить в триангуляцию параметры триангулируемой поверхности. \en Add parameters of triangulated surface to triangulation. 
-  virtual void    AddParam( const MbFloatPoint   & p2D ) = 0;
+  virtual void    AddParam( const MbFloatPoint & p2D ) = 0;
 
           /// \ru Добавить в триангуляцию точки. \en Add points to triangulation. 
           template <class PointsVector>
-          void    AddPoints ( const PointsVector & pnts )
+          void    AddPoints( const PointsVector & pnts )
           {
             size_t addCnt = pnts.size();
             PointsReserve( addCnt );
@@ -816,8 +816,8 @@ public:
           }
           /// \ru Добавить в триангуляцию объекты. \en Add objects to triangulation.
           template <class TrianglesVector>
-          void    AddTriangles ( const TrianglesVector & trngs )
-          { 
+          void    AddTriangles( const TrianglesVector & trngs )
+          {
             size_t addCnt = trngs.size();
             triangles.reserve( triangles.size() + addCnt );
             for ( size_t k = 0; k < addCnt; ++k )
@@ -827,8 +827,8 @@ public:
           }
           /// \ru Добавить в триангуляцию объекты. \en Add objects to triangulation.
           template <class QuadranglesVector>
-          void    AddQuadrangles ( const QuadranglesVector & qrngs )
-          { 
+          void    AddQuadrangles( const QuadranglesVector & qrngs )
+          {
             size_t addCnt = qrngs.size();
             quadrangles.reserve( quadrangles.size() + addCnt );
             for ( size_t k = 0; k < addCnt; ++k )
@@ -849,42 +849,42 @@ public:
   virtual void    AddColor( float r, float g, float b, float a ) = 0;
 
   /// \ru Выдать точку по её номеру. \en Get point by its index. 
-  virtual void    GetPoint ( size_t i, MbCartPoint3D  & p ) const = 0;
+  virtual void    GetPoint( size_t i, MbCartPoint3D & p ) const = 0;
   /// \ru Выдать нормаль по её номеру. \en Get normal by its index. 
-  virtual void    GetNormal( size_t i, MbVector3D     & n ) const = 0;
+  virtual void    GetNormal( size_t i, MbVector3D & n ) const = 0;
   /// \ru Выдать параметр по его номеру. \en Get parameter by its index. 
-  virtual void    GetParam ( size_t i, MbCartPoint    & p ) const = 0;
+  virtual void    GetParam( size_t i, MbCartPoint & p ) const = 0;
   /// \ru Выдать дополнительную информацию по её номеру. \en Get additional information by its index. 
   virtual const   uint32 & GetEscort( size_t i ) const = 0;
 
   /// \ru Выдать точку по её номеру. \en Get point by its index. 
-  virtual void    GetPoint ( size_t i, MbFloatPoint3D  & p ) const = 0;
+  virtual void    GetPoint( size_t i, MbFloatPoint3D & p ) const = 0;
   /// \ru Выдать нормаль по её номеру. \en Get normal by its index. 
   virtual void    GetNormal( size_t i, MbFloatVector3D & n ) const = 0;
   /// \ru Выдать параметр по его номеру. \en Get parameter by its index. 
-  virtual void    GetParam ( size_t i, MbFloatPoint    & p ) const = 0;
+  virtual void    GetParam( size_t i, MbFloatPoint & p ) const = 0;
 
   /// \ru Установить точку с заданным номером. \en Set point by the given index. 
-  virtual void    SetPoint ( size_t i, const MbCartPoint3D & p ) = 0;
+  virtual void    SetPoint( size_t i, const MbCartPoint3D & p ) = 0;
   /// \ru Установить нормаль с заданным номером. \en Set normal by the given index. 
-  virtual void    SetNormal( size_t i, const MbVector3D    & n ) = 0;
+  virtual void    SetNormal( size_t i, const MbVector3D & n ) = 0;
   /// \ru Установить параметр с заданным номером. \en Set parameter by the given index. 
-  virtual void    SetParam ( size_t i, const MbCartPoint   & p ) = 0;
+  virtual void    SetParam( size_t i, const MbCartPoint & p ) = 0;
   /// \ru Установить дополнительную информацию по её номеру. \en Set additional information by its index. 
   virtual void    SetEscort( size_t i, const uint32 & e ) = 0;
 
   /// \ru Удалить точку с заданным номером. \en Delete point by the given index. 
-  virtual void    PointRemove ( size_t i ) = 0;
+  virtual void    PointRemove( size_t i ) = 0;
   /// \ru Удалить нормаль с заданным номером. \en Delete normal by the given index. 
   virtual void    NormalRemove( size_t i ) = 0;
   /// \ru Удалить параметры поверхности с заданным номером. \en Delete parameters of surface by the given index. 
-  virtual void    ParamRemove ( size_t i ) = 0;
+  virtual void    ParamRemove( size_t i ) = 0;
           /// \ru Удалить треугольник по его индексу. \en Delete triangle by its index. 
-          void    TriangleRemove  ( size_t k );
+          void    TriangleRemove( size_t k );
           /// \ru Удалить четырёхугольник по его индексу. \en Delete quadrangle by its index. 
           void    QuadrangleRemove( size_t k );
           /// \ru Удалить полигон по его индексу. \en Delete polygon by its index. 
-          void    LoopRemove   ( size_t k );
+          void    LoopRemove( size_t k );
 
   /// \ru Удалить точки. \en Delete points. 
   virtual void    PointsDelete() = 0;
@@ -901,73 +901,72 @@ public:
           /// \ru Удалить все полигоны. \en Delete all polygons. 
           void    LoopsDelete();
 
-          /// \ru Инвертировать нормали. \en Invert normals. 
+  /// \ru Инвертировать нормали. \en Invert normals. 
   virtual void    NormalsInvert() = 0;
 
-          // \ru Добавить треугольник. \en Add a triangle. 
-          void    AddTriangle  ( const MbTriangle & triangle )   { triangles.push_back( triangle ); DeleteSearchTree(); ResetGridTopology(); }
-          // \ru Добавить треугольник с заданными номерами вершин. \en Add a triangle by the given indices of vertices 
-          void    AddTriangle  ( uint j0, uint j1, uint j2, bool o ) { MbTriangle t(j0,j1,j2,o); triangles.push_back( t ); DeleteSearchTree(); ResetGridTopology(); }
-
-          // \ru Добавить четырёхугольник. \en Add a quadrangle. 
+          /// \ru Добавить треугольник. \en Add a triangle. 
+          void    AddTriangle( const MbTriangle & triangle ) { triangles.push_back( triangle ); DeleteSearchTree(); ResetGridTopology(); }
+          /// \ru Добавить треугольник с заданными номерами вершин. \en Add a triangle by the given indices of vertices 
+          void    AddTriangle( uint j0, uint j1, uint j2, bool o ) { MbTriangle t( j0, j1, j2, o ); triangles.push_back( t ); DeleteSearchTree(); ResetGridTopology(); }
+          /// \ru Добавить четырёхугольник. \en Add a quadrangle. 
           void    AddQuadrangle( const MbQuadrangle & quadrangle ) { quadrangles.push_back( quadrangle ); DeleteSearchTree(); ResetGridTopology(); }
-          // \ru Добавить четырёхугольник с заданными номерами вершин. \en Add a quadrangle by the given indices of vertices. 
-          void    AddQuadrangle( uint j0, uint j1, uint j2, uint j3, bool o ) { MbQuadrangle t(j0,j1,j2,j3,o); quadrangles.push_back( t ); DeleteSearchTree(); ResetGridTopology(); }
+          /// \ru Добавить четырёхугольник с заданными номерами вершин. \en Add a quadrangle by the given indices of vertices. 
+          void    AddQuadrangle( uint j0, uint j1, uint j2, uint j3, bool o ) { MbQuadrangle t( j0, j1, j2, j3, o ); quadrangles.push_back( t ); DeleteSearchTree(); ResetGridTopology(); }
 
-          // \ru Добавить полигон. \en Add a polygon. 
-          void    AddGridLoop ( MbGridLoop & poly ) { loops.push_back( &poly ); }
-          // \ru Собрать внешние полигоны. \en Collect outer loops. 
+          /// \ru Добавить полигон. \en Add a polygon. 
+          void    AddGridLoop( MbGridLoop & poly ) { loops.push_back( &poly ); }
+          /// \ru Собрать внешние полигоны. \en Collect outer loops. 
           void    CollectEdges( std::vector<c3d::UintPair> & edges ) const;
 
           /// \ru Выдать индексы точек в массиве points для i-го треугольника (связанного или несвязанного). \en Get indices of points in 'points' array for i-th triangle (adjacent or non-adjacent). 
-          bool    GetTrianglePointIndex  ( size_t i, uint & ind0, uint & ind1, uint & ind2 ) const;
+          bool    GetTrianglePointIndex( size_t i, uint & ind0, uint & ind1, uint & ind2 ) const;
           /// \ru Выдать индексы точек в массиве points для i-го четырехугольника (связанного или несвязанного). \en Get indices of points in 'points' array for i-th quadrangle (adjacent or non-adjacent). 
           bool    GetQuadranglePointIndex( size_t i, uint & ind0, uint & ind1, uint & ind2, uint & ind3 ) const;
 
   // \ru Выдать для треугольника с номером i в общей нумерации (с полосами) параметры поверхности. \en Get parameters of surface for i-th triangle in general numbering (with strips). 
-  virtual bool    GetTriangleParams   ( size_t i, MbCartPoint & r0, MbCartPoint & r1, MbCartPoint & r2 ) const = 0;
+  virtual bool    GetTriangleParams( size_t i, MbCartPoint & r0, MbCartPoint & r1, MbCartPoint & r2 ) const = 0;
   // \ru Выдать для треугольника с номером i в общей нумерации (с полосами) точки вершин. \en Get points of vertices for i-th triangle in general numbering (with strips). 
-  virtual bool    GetTrianglePoints   ( size_t i, MbCartPoint3D & p0, MbCartPoint3D & p1, MbCartPoint3D & p2 ) const = 0;
+  virtual bool    GetTrianglePoints( size_t i, MbCartPoint3D & p0, MbCartPoint3D & p1, MbCartPoint3D & p2 ) const = 0;
   // \ru Выдать для треугольника с номером i в общей нумерации (с полосами) точки вершин. \en Get points of vertices for i-th triangle in general numbering (with strips). 
-  virtual bool    GetTrianglePoints   ( size_t i, MbFloatPoint3D & p0, MbFloatPoint3D & p1, MbFloatPoint3D & p2 ) const = 0;
+  virtual bool    GetTrianglePoints( size_t i, MbFloatPoint3D & p0, MbFloatPoint3D & p1, MbFloatPoint3D & p2 ) const = 0;
   // \ru Выдать для треугольника с номером i в общей нумерации (с полосами) нормали в вершинах. \en Get normals at vertices for i-th triangle in general numbering (with strips). 
-  virtual bool    GetTriangleNormals  ( size_t i, MbVector3D & n0, MbVector3D & n1, MbVector3D & n2 ) const = 0;
+  virtual bool    GetTriangleNormals( size_t i, MbVector3D & n0, MbVector3D & n1, MbVector3D & n2 ) const = 0;
   // \ru Выдать для треугольника с номером i в общей нумерации (с полосами) нормали в вершинах. \en Get normals at vertices for i-th triangle in general numbering (with strips). 
-  virtual bool    GetTriangleNormals  ( size_t i, MbFloatVector3D & n0, MbFloatVector3D & n1, MbFloatVector3D & n2 ) const = 0;
+  virtual bool    GetTriangleNormals( size_t i, MbFloatVector3D & n0, MbFloatVector3D & n1, MbFloatVector3D & n2 ) const = 0;
 
   // \ru Выдать для четырёхугольника с номером i в общей нумерации (с полосами) параметры поверхности. \en Get parameters of surface for i-th quadrangle in general numbering (with strips). 
-  virtual bool    GetQuadrangleParams ( size_t i, MbCartPoint & r0, MbCartPoint & r1, MbCartPoint & r2, MbCartPoint & r3 ) const = 0;
+  virtual bool    GetQuadrangleParams( size_t i, MbCartPoint & r0, MbCartPoint & r1, MbCartPoint & r2, MbCartPoint & r3 ) const = 0;
   // \ru Выдать для четырёхугольника с номером i в общей нумерации (с полосами) точки вершин. \en Get points of vertices for i-th quadrangle in general numbering (with strips). 
-  virtual bool    GetQuadranglePoints ( size_t i, MbCartPoint3D & p0, MbCartPoint3D & p1, MbCartPoint3D & p2, MbCartPoint3D & p3 ) const = 0;
+  virtual bool    GetQuadranglePoints( size_t i, MbCartPoint3D & p0, MbCartPoint3D & p1, MbCartPoint3D & p2, MbCartPoint3D & p3 ) const = 0;
   // \ru Выдать для четырёхугольника с номером i в общей нумерации (с полосами) точки вершин. \en Get points of vertices for i-th quadrangle in general numbering (with strips). 
-  virtual bool    GetQuadranglePoints ( size_t i, MbFloatPoint3D & p0, MbFloatPoint3D & p1, MbFloatPoint3D & p2, MbFloatPoint3D & n3 ) const = 0;
+  virtual bool    GetQuadranglePoints( size_t i, MbFloatPoint3D & p0, MbFloatPoint3D & p1, MbFloatPoint3D & p2, MbFloatPoint3D & n3 ) const = 0;
   // \ru Выдать для четырёхугольника с номером i в общей нумерации (с полосами) нормали в вершинах. \en Get normals at vertices for i-th quadrangle in general numbering (with strips). 
-  virtual bool    GetQuadrangleNormals( size_t i, MbVector3D & n0, MbVector3D & n1, MbVector3D &n2, MbVector3D & n3 ) const = 0;
+  virtual bool    GetQuadrangleNormals( size_t i, MbVector3D & n0, MbVector3D & n1, MbVector3D & n2, MbVector3D & n3 ) const = 0;
   // \ru Выдать для четырёхугольника с номером i в общей нумерации (с полосами) нормали в вершинах. \en Get normals at vertices for i-th quadrangle in general numbering (with strips). 
   virtual bool    GetQuadrangleNormals( size_t i, MbFloatVector3D & n0, MbFloatVector3D & n1, MbFloatVector3D & n2, MbFloatVector3D & n3 ) const = 0;
 
   // \ru Выдать первую нормаль для плоской триангуляции, если количество точек больше количества нормалей (только для плоской триангуляции). \en Get first normal for flat triangulation if count of points is greater than count of normals (only for planar triangulation). 
-  virtual bool    GetSingleNormal   ( MbVector3D &      ) const = 0;
+  virtual bool    GetSingleNormal( MbVector3D & ) const = 0;
   // \ru Выдать первую нормаль для плоской триангуляции, если количество точек больше количества нормалей (только для плоской триангуляции). \en Get first normal for flat triangulation if count of points is greater than count of normals (only for planar triangulation). 
-  virtual bool    GetSingleNormal   ( MbFloatVector3D & ) const = 0;
+  virtual bool    GetSingleNormal( MbFloatVector3D & ) const = 0;
   /// \ru Если количество точек больше количества нормалей, то добавить недостающие нормали (только для плоской триангуляции). \en If count of points is greater than count of normals, then add missing normals (only for planar triangulation). 
   virtual void    SynchronizeNormals() = 0;
   /// \ru Нормализовать нормали. \en Normalize normals. 
-  virtual void    NormalizeNormals  () = 0;
+  virtual void    NormalizeNormals() = 0;
 
-          // \ru Выдать треугольник с номером i. \en Get i-th triangle. 
-  const   MbTriangle   &  GetTriangle  ( size_t i ) const { return triangles[i];   }
-          // \ru Выдать четырёхугольник с номером i. \en Get i-th quadrangle. 
-  const   MbQuadrangle &  GetQuadrangle( size_t i ) const { return quadrangles[i]; }
-          // \ru Выдать полигон с номером i. \en Get i-th polygon. 
-  const   MbGridLoop &    GetGridLoop  ( size_t i ) const { return *loops[i]; }
+          /// \ru Выдать треугольник с номером i. \en Get i-th triangle. 
+          const   MbTriangle & GetTriangle( size_t i ) const { return triangles[i]; }
+          /// \ru Выдать четырёхугольник с номером i. \en Get i-th quadrangle. 
+          const   MbQuadrangle & GetQuadrangle( size_t i ) const { return quadrangles[i]; }
+          /// \ru Выдать полигон с номером i. \en Get i-th polygon. 
+          const   MbGridLoop & GetGridLoop( size_t i ) const { return *loops[i]; }
 
-          // \ru Выдать для треугольника с номером i номера точек вершин. \en Get indices of vertex points for i-th triangle. 
-          bool    GetTriangleIndex ( size_t i, uint & i0, uint & i1, uint & i2 ) const;
-          // \ru Выдать для четырёхугольника с номером i номера точек вершин. \en Get indices of points of vertices for i-th quadrangle. 
-          bool    GetQuadrangleIndex ( size_t i, uint & i0, uint & i1, uint & i2, uint & i3 ) const;
+          /// \ru Выдать для треугольника с номером i номера точек вершин. \en Get indices of vertex points for i-th triangle. 
+          bool    GetTriangleIndex( size_t i, uint & i0, uint & i1, uint & i2 ) const;
+          /// \ru Выдать для четырёхугольника с номером i номера точек вершин. \en Get indices of points of vertices for i-th quadrangle. 
+          bool    GetQuadrangleIndex( size_t i, uint & i0, uint & i1, uint & i2, uint & i3 ) const;
 
-          // \ru Выдать контейнер параметров. \en Get the container of parameters. 
+          /// \ru Выдать контейнер параметров. \en Get the container of parameters. 
           template <class Param, class ParamsVector>
           void    GetParams( ParamsVector & paramsVector ) const
           {
@@ -978,7 +977,7 @@ public:
               paramsVector.push_back( param );
             }
           }
-          // \ru Выдать контейнер точек. \en Get the container of points. 
+          /// \ru Выдать контейнер точек. \en Get the container of points. 
           template <class Point, class PointsVector>
           void    GetPoints( PointsVector & pointsVector ) const
           {
@@ -989,7 +988,7 @@ public:
               pointsVector.push_back( point );
             }
           }
-          // \ru Выдать контейнер нормалей. \en Get the container of normals. 
+          /// \ru Выдать контейнер нормалей. \en Get the container of normals. 
           template <class Normal, class NormalsVector>
           void    GetNormals( NormalsVector & normalsVector ) const
           {
@@ -1000,15 +999,15 @@ public:
               normalsVector.push_back( normal );
             }
           }
-          // \ru Выдать контейнер треугольников. \en Get the container of triangles. 
+          /// \ru Выдать контейнер треугольников. \en Get the container of triangles. 
           template <class TrianglesVector>
           void    GetTriangles( TrianglesVector & tVector ) const
-          { 
+          {
             tVector.reserve( tVector.size() + triangles.size() );
             for ( size_t i = 0, iCount = triangles.size(); i < iCount; ++i )
               tVector.push_back( triangles[i] );
           }
-          // \ru Выдать контейнер четырёхугольников. \en Get the container of quadrangles. 
+          /// \ru Выдать контейнер четырёхугольников. \en Get the container of quadrangles. 
           template <class QuadranglesVector>
           void    GetQuadrangles( QuadranglesVector & qVector ) const
           {
@@ -1016,34 +1015,33 @@ public:
             for ( size_t i = 0, iCount = quadrangles.size(); i < iCount; ++i )
               qVector.push_back( quadrangles[i] );
           }
-
           /// \ru Преобразовать четырёхугольники в треугольники. \en Convert quadrangles to triangles. 
           void    ConvertQuadranglesToTriangles();
           /// \ru Преобразовать все объекты в треугольники и уравнять число точек и нормалей. \en Convert all objects to triangles and equalize count of points and count of normals. 
           void    ConvertAllToTriangles();
-
-          // \ru Вывернуть треугольник относительно заданного ребра. \en Flip triangle around given edge.     
-          bool FlipTriangle( size_t triIndex, size_t edgeIndex );
+  
+          /// \ru Вывернуть треугольник относительно заданного ребра. \en Flip triangle around given edge.     
+          bool    FlipTriangle( size_t triIndex, size_t edgeIndex );
 
   /// \ru Определить, пересекается ли проекция на глобальную плоскость XY треугольника с заданным номером с присланным прямоугольником. \en Determine whether the projection of triangle with a given index to the global XY-plane intersects the given rectangle. 
   virtual bool    TriangleIntersectRect( size_t i, MbRect & rect ) const = 0;
   /// \ru Рассчитать габаритный прямоугольник проекции на глобальную плоскость XY треугольника с заданным номером. \en Determine bounding box of the projection of triangle with given index to the global XY-plane. 
-  virtual void    TriangleGetGabRect   ( size_t i, MbRect & rect ) const = 0;
+  virtual void    TriangleGetGabRect( size_t i, MbRect & rect ) const = 0;
 
   /// \ru Определить, пересекается ли проекция на глобальную плоскость XY четырёхугольника с заданным номером с присланным прямоугольником. \en Determine whether the projection of quadrangle with given index to the global XY-plane intersects the given rectangle. 
   virtual bool    QuadrangleIntersectRect( size_t i, MbRect & rect ) const = 0;
   /// \ru Рассчитать габаритный прямоугольник проекции на глобальную плоскость XY четырёхугольника с заданным номером. \en Determine bounding box of the projection of quadrangle with given index to the global XY-plane. 
-  virtual void    QuadrangleGetGabRect   ( size_t i, MbRect & rect ) const = 0;
+  virtual void    QuadrangleGetGabRect( size_t i, MbRect & rect ) const = 0;
 
   /// \ru Расширить присланный габаритный прямоугольник так, чтобы он включал в себя проекцию данного объекта на глобальную плоскость XY. \en Extend given bounding box so that it enclose projection of this object to the global XY-plane. 
-  virtual void    AddRect( MbRect & rect ) const = 0; 
+  virtual void    AddRect( MbRect & rect ) const = 0;
   /// \ru Расширить присланный габаритный куб так, чтобы он включал в себя данный объект. \en Extend given bounding box so that it encloses the given object. 
-  virtual void    AddCube( MbCube & r ) const = 0; 
+  virtual void    AddCube( MbCube & r ) const = 0;
 
   /// \ru Удалить дублирующие с заданной точностью друг друга точки. \en Remove redundant points with a given tolerance (duplicates).
   virtual bool    RemoveRedundantPoints( bool deleteNormals, double epsilon = LENGTH_EPSILON ) = 0;
 
-  /** 
+  /**
     \brief \ru Определить положение объекта относительно плоскости.
             \en Define the object position relative to the plane. \~
     \details \ru Определить положение объекта относительно плоскости XY локальной системы координат.
@@ -1061,14 +1059,14 @@ public:
             iloc_InItem - object is located over the XY plane of a local coordinate system,\n
             iloc_OutOfItem - object is located under the XY plane of a local coordinate system. \~
   */
-  virtual MbeItemLocation GetLocation( const MbPlacement3D & pl, double eps, bool onlyInItem = false ) const = 0; 
+  virtual MbeItemLocation GetLocation( const MbPlacement3D & pl, double eps, bool onlyInItem = false ) const = 0;
 
-  /** 
+  /**
     \brief \ru Определить положение объекта относительно трубы.
             \en Determine the object position relative to the tube. \~
-    \details \ru Определить, расположен ли объект внутри трубы прямоугольного сечения, 
+    \details \ru Определить, расположен ли объект внутри трубы прямоугольного сечения,
       заданного прямоугольником в плоскости XY локальной системы координат.
-              \en Determine whether the object is inside the tube of rectangular section 
+              \en Determine whether the object is inside the tube of rectangular section
       given by a rectangle in the XY plane of a local coordinate system. \~
     \param[in] place - \ru Локальная система координат, в в плоскости XY которой лежит сечение трубы.
                         \en A local coordinate system in the XY plane of which a tube section is located. \~
@@ -1081,27 +1079,27 @@ public:
     \return \ru true, если объект расположен внутри трубы.
             \en True if the object is inside the tube. \~
   */
-  virtual bool    InsideLocation( const MbPlacement3D & place, MbRect & rect, double eps ) const = 0; 
+  virtual bool    InsideLocation( const MbPlacement3D & place, MbRect & rect, double eps ) const = 0;
   /// \ru Преобразовать триангуляцию так, чтобы её параллельная проекция выглядела как центральная проекция, наблюдаемая из заданной точки vista. \en Transform triangulation so that its parallel projection looks as the central projection observed from the given 'vista' point. 
-  virtual void    SetVista   ( const MbCartPoint3D & vista ) = 0; 
+  virtual void    SetVista( const MbCartPoint3D & vista ) = 0;
   /// \ru Отменить преобразование триангуляцию для центральной проекции, наблюдаемой из заданной точки vista. \en Undo the transformation of triangulation for central projection observed from given 'vista' point. 
-  virtual void    DeleteVista( const MbCartPoint3D & vista ) = 0; 
+  virtual void    DeleteVista( const MbCartPoint3D & vista ) = 0;
 
   /// \ru Зарезервировать память для контейнера параметров. \en Reserve memory for container of elements. 
-  virtual void    ParamsReserve     ( size_t n ) = 0;
+  virtual void    ParamsReserve( size_t n ) = 0;
   /// \ru Зарезервировать память для контейнера точек. \en Reserve memory for container of points. 
-  virtual void    PointsReserve     ( size_t n ) = 0;
+  virtual void    PointsReserve( size_t n ) = 0;
   /// \ru Зарезервировать память для контейнера нормалей. \en Reserve memory for container of normals. 
-  virtual void    NormalsReserve    ( size_t n ) = 0;
+  virtual void    NormalsReserve( size_t n ) = 0;
   /// \ru Зарезервировать память для контейнера параметров. \en Reserve memory for container of elements. 
-  virtual void    EscordsReserve    ( size_t n ) = 0;
+  virtual void    EscordsReserve( size_t n ) = 0;
 
-          /// \ru Зарезервировать память для контейнера треугольников. \en Reserve memory for container of triangles. 
-          void    TrianglesReserve  ( size_t n ) { triangles.reserve( triangles.size() + n ); }
-          /// \ru Зарезервировать память для контейнера четырёхугольников. \en Reserve memory for container of quadrangles. 
+  /// \ru Зарезервировать память для контейнера треугольников. \en Reserve memory for container of triangles. 
+          void    TrianglesReserve( size_t n ) { triangles.reserve( triangles.size() + n ); }
+  /// \ru Зарезервировать память для контейнера четырёхугольников. \en Reserve memory for container of quadrangles. 
           void    QuadranglesReserve( size_t n ) { quadrangles.reserve( quadrangles.size() + n ); }
-          /// \ru Зарезервировать память для контейнера полигонов. \en Reserve memory for container of loops. 
-          void    LoopsReserve      ( size_t n ) { loops.reserve( loops.size() + n ); }
+  /// \ru Зарезервировать память для контейнера полигонов. \en Reserve memory for container of loops. 
+          void    LoopsReserve( size_t n ) { loops.reserve( loops.size() + n ); }
 
   /// \ru Зарезервировать память для контейнеров. \en Reserve memory for some containers. 
   virtual void    ReserveParamsPoints( size_t n ) = 0;
@@ -1125,19 +1123,19 @@ public:
   virtual bool    IsSame( const MbGrid & init, double eps ) const = 0;
 
           /// \ru Выдать параметр расчета триангуляции (стрелку прогиба или угол отклонения). \en Get the parameter of triangulation calculation. 
-  const   MbStepData &  GetStepData() const { return stepData; }
+          const   MbStepData &      GetStepData() const { return stepData; }
           /// \ru Установить параметр расчета триангуляции (стрелку прогиба или угол отклонения). \en Set the parameter of triangulation calculation. 
-          void          SetStepData( const MbStepData & stData ) { stepData = stData; }
+          void                      SetStepData( const MbStepData & stData ) { stepData = stData; }
           /// \ru Вернуть габаритный куб. \en Return bounding box. 
-  const   MbCube &      Cube() const { return cube; }
+          const   MbCube &          Cube() const { return cube; }
           /// \ru Вернуть габаритный куб. \en Return bounding box. 
-  const   MbCube &      GetCube() const;
+          const   MbCube &          GetCube() const;
 
   // \ru Инициировать по другой триангуляции. \en Init by other triangulation. 
-  virtual void    Init( const MbGrid & grid ) = 0;
+  virtual void                      Init( const MbGrid & grid ) = 0;
 
           /// \ru Выдать адрес начала массива. \en Get the address of the beginning of the array. 
-          const   MbTriangle *      GetTrianglesAddr() const { return (!triangles.empty() ?  &(triangles[0]) : nullptr); }
+          const   MbTriangle *      GetTrianglesAddr() const { return (!triangles.empty() ? &(triangles[0]) : nullptr); }
           /// \ru Выдать адрес начала массива. \en Get the address of the beginning of the array. 
           const   MbQuadrangle *    GetQuadranglesAddr() const { return (!quadrangles.empty() ? &(quadrangles[0]) : nullptr); }
   /// \ru Выдать адрес начала массива. \en Get the address of the beginning of the array. 
@@ -1155,6 +1153,7 @@ public:
 
   /** \} */
 
+public:
           /** \brief \ru Вычислить расстояние до точки.
                      \en Calculate distance to point. \~
               \details \ru Вычислить расстояние от точки до ближайшей опорной точки триангуляции. \n
@@ -1166,41 +1165,78 @@ public:
               \return \ru Расстояние между заданной точкой и ближайшей опорной точкой триангуляции.
                       \en Distance between the given point and the nearest triangulation reference point. \~
           */
-          double  DistanceToPoint( const MbCartPoint3D & pnt, size_t & ind ) const;
+  double  DistanceToPoint( const MbCartPoint3D & pnt, size_t & ind ) const;
 
-          /** \brief \ru Вычислить расстояние до оси.
-                     \en Calculate the distance to an axis. \~
-              \details \ru Вычислить расстояние от оси до ближайшего треугольника или четырехугольника триангуляции. \n
-                       \en Calculate the distance from the axis to the nearest triangle or quadrangle of triangulation. \n \~
-              \param[in] axis - \ru Ось (луч).
-                                \en Axis (view ray). \~
-              \param[in] extDistance - \ru Расширение габарита триангуляции (по умолчанию можно поставить 0).
-                                       \en Triangulation bounding box extension (set it equal zero by default). \~
-              \param[in,out] t - \ru Параметр на луче, где он пересекает триангуляцию.
-                                 \en Parameter on the ray where ray intersects the triangulation. \~
-              \param[out] tqInd - \ru Индекс ближайшего треугольника или четырехугольника.
-                                  \en Index of nearest triangle or quadrangle. \~
-              \return \ru Ноль, если найдено пересечение между осью и ближайшим треугольником или четырехугольником триангуляции.
-                      \en Zero if intersection was found, between the axis and the nearest triangulation triangle or quadrangle. \~
-          */
-          double  DistanceToLine( const MbAxis3D & axis, double extDistance, double & t, c3d::IndicesPair & tqInd ) const;
+  /** \brief \ru Вычислить расстояние до оси.
+             \en Calculate the distance to an axis. \~
+      \details \ru Вычислить расстояние от оси до ближайшего треугольника или четырехугольника триангуляции. \n
+               \en Calculate the distance from the axis to the nearest triangle or quadrangle of triangulation. \n \~
+      \param[in] axis - \ru Ось (луч).
+                        \en Axis (view ray). \~
+      \param[in] extDistance - \ru Расширение габарита триангуляции (по умолчанию можно поставить 0).
+                               \en Triangulation bounding box extension (set it equal zero by default). \~
+      \param[in,out] t - \ru Параметр на луче, где он пересекает триангуляцию.
+                         \en Parameter on the ray where ray intersects the triangulation. \~
+      \param[out] tqInd - \ru Индекс ближайшего треугольника или четырехугольника.
+                          \en Index of nearest triangle or quadrangle. \~
+      \return \ru Ноль, если найдено пересечение между осью и ближайшим треугольником или четырехугольником триангуляции.
+              \en Zero if intersection was found, between the axis and the nearest triangulation triangle or quadrangle. \~
+  */
+  double  DistanceToLine( const MbAxis3D & axis, double extDistance, double & t, c3d::IndicesPair & tqInd ) const;
 
-          /// \ru Дать объекты, содержащие указанный индекс точки. \ en Get all triangles with point index ind.
-          bool    FindTrianglesByPoint( uint ind, c3d::IndicesVector & ) const;
-          /// \ru Дать объекты, содержащие указанный индекс точки. \ en Get all quadrangles with point index ind.
-          bool    FindQuadranglesByPoint( uint ind, c3d::IndicesVector & ) const;
-          /// \ru Сделать триангуляцию односвязной. \ en Make simply connected triangulation (make cuts from outer loop to inner loops with duplicated points of cuts).
-          bool    MakeSimplyConnected();
+  /// \ru Дать объекты, содержащие указанный индекс точки. \ en Get all triangles with point index ind.
+  bool    FindTrianglesByPoint( uint ind, c3d::IndicesVector & ) const;
+  /// \ru Дать объекты, содержащие указанный индекс точки. \ en Get all quadrangles with point index ind.
+  bool    FindQuadranglesByPoint( uint ind, c3d::IndicesVector & ) const;
+  /// \ru Сделать триангуляцию односвязной. \ en Make simply connected triangulation (make cuts from outer loop to inner loops with duplicated points of cuts).
+  bool    MakeSimplyConnected();
 
 public:
-          /// \ru Готово ли дерево поиска элементов. \en Whether is elements search tree ready.
-          bool    IsSearchTreeReady() const;
-          /// \ru Создать дерево поиска элементов. \en Create elements search tree.
-          bool    CreateSearchTree() const;
-          /// \ru Удалить дерево поиска элементов. \en Delete elements search tree.
-          void    DeleteSearchTree() const;
-          /// \ru Найти индексы треугольников и четырехугольников, потенциально пересекающихся с лучом. \en Find indices of triangles and quadrangles potentially intersecting with a ray.
-          bool    FindIntersectElements( const MbAxis3D & ray, c3d::IndicesVector & triIndices, c3d::IndicesVector & quadIndices, double eps = METRIC_EPSILON ) const;
+  /// \ru Готово ли дерево поиска элементов. \en Whether is elements search tree ready.
+  bool    IsSearchTreeReady() const;
+  /// \ru Создать дерево поиска элементов. \en Create elements search tree.
+  bool    CreateSearchTree() const;
+  /// \ru Удалить дерево поиска элементов. \en Delete elements search tree.
+  void    DeleteSearchTree() const;
+  /** \brief \ru Найти индексы треугольников и четырехугольников, потенциально пересекающихся с лучом.
+             \en Find indices of triangles and quadrangles potentially intersecting with a ray. \~
+      \details \ru Найти индексы треугольников и четырехугольников, потенциально пересекающихся с лучом, по дереву габаритов этих элементов. \n
+               \en Find indices of triangles and quadrangles potentially intersecting with a ray using elements cubes tree (if it can be created). \n \~
+      \param[in] ray          - \ru Луч.
+                                \en Ray. \~
+      \param[out] triIndices  - \ru Индексы треугольников.
+                                \en Triangles indices. \~
+      \param[out] quadIndices - \ru Индексы четырехугольников.
+                                \en Quadrangles indices. \~
+      \param[in] eps - \ru Точность проверки пересечения луча с габаритным кубом треугольника или четырехугольника.
+                       \en Accuracy of checking the intersection of a ray with a bounding box of a triangle or quadrangle. \~
+      \return \ru Возвращает true, если был выполнен поиск по дереву габаритов.
+              \en Returns true if a search by cubes tree was performed. \~
+  */
+  bool    FindIntersectingElementsByCubesTree( const MbAxis3D & ray, c3d::IndicesVector & triIndices, c3d::IndicesVector & quadIndices, double eps = METRIC_EPSILON ) const;
+
+  DEPRECATE_DECLARE_REPLACE( FindIntersectingElements )
+  bool    FindIntersectElements( const MbAxis3D & ray, c3d::IndicesVector & triIndices, c3d::IndicesVector & quadIndices, double eps = METRIC_EPSILON ) const
+          {
+            return FindIntersectingElements( ray, triIndices, quadIndices, eps );
+          }
+          /** \brief \ru Найти индексы треугольников и четырехугольников, пересекающихся с лучом.
+                     \en Find indices of triangles and quadrangles intersecting with a ray. \~
+              \details \ru Найти индексы треугольников и четырехугольников, пересекающихся с лучом. \n
+                       \en Find indices of triangles and quadrangles intersecting with a ray. \n \~
+              \param[in] ray          - \ru Луч.
+                                        \en Ray. \~
+              \param[out] triIndices  - \ru Индексы треугольников.
+                                        \en Triangles indices. \~
+              \param[out] quadIndices - \ru Индексы четырехугольников.
+                                        \en Quadrangles indices. \~
+              \param[in] eps - \ru Точность проверки пересечения луча с габаритным кубом треугольника или четырехугольника.
+                               \en Accuracy of checking the intersection of a ray with a bounding box of a triangle or quadrangle. \~
+              \return \ru Возвращает true, если что-то было найдено.
+                      \en Returns true if something was found. \~
+          */
+          bool    FindIntersectingElements( const MbAxis3D & ray, c3d::IndicesVector & triIndices, c3d::IndicesVector & quadIndices, double eps = METRIC_EPSILON ) const;
+public:
           /// \ru Готова ли топология триангуляции. \en Whether information about triangulation topology is ready.
           bool                   IsGridTopologyReady() const { return topo != nullptr; }
           /// \ru Создать новый временный объект информации о топологии. \en Create new temporary maintenance object information about triangulation topology. 

C3d/Include/op_binding_data.h

@@ -110,7 +110,11 @@ public:
   void        SetDeviation( double a ) { deviation = a; }
   void        SetTolerance( double a ) { tolerance = a; }
 
-  KNOWN_OBJECTS_RW_REF_OPERATORS( MbPrecision ) // \ru Для работы со ссылками и объектами класса. \en For working with references and objects of the class.
+  /// \ru Оператор чтения. \en Read operator. 
+  friend MATH_FUNC( reader & )  operator >> ( reader &, MbPrecision & );
+  /// \ru Оператор записи. \en Write operator. 
+  friend MATH_FUNC( writer & )  operator << ( writer &, const MbPrecision & );
+
   DECLARE_NEW_DELETE_CLASS( MbPrecision )
   DECLARE_NEW_DELETE_CLASS_EX( MbPrecision )
 };

C3d/Include/op_curve_parameter.h

@@ -18,7 +18,6 @@
 #include <mb_axis3d.h>
 #include <curve.h>
 #include <curve3d.h>
-#include <cur_surface_curve.h>
 #include <topology.h>
 #include <wire_frame.h>
 #include <op_binding_data.h>
@@ -1067,6 +1066,58 @@ private:
   bool          uSeamStitch; ///< \ru Нужно ли сдвинуть кривые, попавшие краем на шов umax. \en Whether to shift curves with one end on umax seam. \~
   VERSION       version;     ///< \ru Версия алгоритма. \en Algorithm version. \~
 
+private:
+  /** \brief \ru Закрытый конструктор по-умолчанию.
+             \en Default private constructor. \~
+    \details \ru Закрытый конструктор по-умолчанию.
+             \en Default private constructor. \~
+  */
+  MbCurvesWrappingParams();
+  /** \brief \ru Конструктор копирования, копирует кривые и поверхности.
+             \en Copy constructor, copies curves and surfaces.\~
+    \details \ru Конструктор копирования, копирует кривые и поверхности.
+             \en Copy constructor, copies curves and surfaces.\~
+  */
+  MbCurvesWrappingParams( const MbCurvesWrappingParams & other );
+  /** \brief \ru Конструктор без кривых.
+             \en Constructor with no curves.\~
+    \details \ru Конструктор без кривых.
+             \en Constructor  with no curves.\~
+    \param[in] place_       - \ru Локальная система координат (ЛСК) плоскости.
+                              \en The local coordinate system (LCS) of the plane. \~
+    \param[in] xy_          - \ru Точка привязки на плоскости, которая будет привязана к uv-точке на поверхности.
+                              \en The anchor point on the plane that will be aligned with the uv point on the parametric plane of the surface. \~
+    \param[in] surface_     - \ru Поверхность для сворачивания/разворачивания.
+                              \en The surface to wrap to/unwrap from. \~
+    \param[in] uv_          - \ru Точка привязки на поверхности в параметрической плоскости "UV". Будет привязана к xy-точке на плоскости.
+                              \en The anchor uv point on the parametric plane of the surface that will be aligned with the xy point on the plane.\~
+    \param[in] angle_       - \ru Угол поворота плоскости "XY" ЛСК и параметрической плоскости "UV" поверхности.
+                              \en The angle of rotation of the LSC "XY" plane and the parametric "UV" plane of the surface. \~
+    \param[in] sense_       - \ru Совпадают ли направления оси "X" ЛСК и оси "U" поверхности.
+                              \en Whether the directions of the "X" axis of the LSC and the "U" axis of the surface coincide? \~
+    \param[in] equals_      - \ru Должны ли длины кривых на другом носителе соответствовать оригиналам.
+                              \en Should the lengths of the curves on another medium match the originals?\~
+    \param[in] accuracy_    - \ru Точность построения.
+                              \en The accuracy. \~
+    \param[in] copyCurves_  - \ru Сохранить ли в этом классе параметров копии кривых.
+                              \en Whether to save the curves copies in this parameter class. \~
+    \param[in] copySurface_ - \ru Сохранить ли в классе параметров копию поверхности.
+                              \en Whether to save the surface copy in this parameter class. \~
+    \param[in] ver_         - \ru Версия алгоритма.
+                              \en The version. \~
+  */
+  MbCurvesWrappingParams( const MbPlacement3D & place_,
+                          const MbCartPoint &   xy_,
+                          const MbSurface &     surface_,
+                          const MbCartPoint &   uv_,
+                                double  angle_,
+                                bool    sense_,
+                                bool    equals_,
+                                double  accuracy_,
+                                bool    ,
+                                bool    copySurface_,
+                                VERSION ver_ );
+
 public:
   /** \brief \ru Конструктор.
              \en Constructor.\~
@@ -1115,8 +1166,8 @@ public:
              \en Constructor.\~
     \details \ru Конструктор.
              \en Constructor.\~
-    \param[in] curves_      - \ru Двумерные кривые, копии которых будут свёрнуты/развёрнуты.
-                              \en 2d curves, copies of which will be wrapped/unwrapped. \~
+    \param[in] curves_      - \ru 3d кривые, копии которых будут свёрнуты/развёрнуты. Ожидается, что внутри -- 2д кривые на поверхности.
+                              \en 3d curves, copies of which will be wrapped/unwrapped. It is expected that there are 2d curves on surface inside.\~
     \param[in] place_       - \ru Локальная система координат (ЛСК) плоскости.
                               \en The local coordinate system (LCS) of the plane. \~
     \param[in] xy_          - \ru Точка привязки на плоскости, которая будет привязана к uv-точке на поверхности.
@@ -1197,6 +1248,92 @@ public:
                                 VERSION ver_ );
 
 
+  /** \brief \ru Конструктор по 1 кривой.
+             \en Constructor by 1 curve.\~
+    \details \ru Конструктор по 1 кривой.
+             \en Constructor by 1 curve.\~
+    \param[in] curves_      - \ru 2д кривая, копия которой будет свёрнута/развёрнута.
+                              \en 2d curve, which copy will be wrapped/unwrapped. \~
+    \param[in] place_       - \ru Локальная система координат (ЛСК) плоскости.
+                              \en The local coordinate system (LCS) of the plane. \~
+    \param[in] xy_          - \ru Точка привязки на плоскости, которая будет привязана к uv-точке на поверхности.
+                              \en The anchor point on the plane that will be aligned with the uv point on the parametric plane of the surface. \~
+    \param[in] surface_     - \ru Поверхность для сворачивания/разворачивания.
+                              \en The surface to wrap to/unwrap from. \~
+    \param[in] uv_          - \ru Точка привязки на поверхности в параметрической плоскости "UV". Будет привязана к xy-точке на плоскости.
+                              \en The anchor uv point on the parametric plane of the surface that will be aligned with the xy point on the plane.\~
+    \param[in] angle_       - \ru Угол поворота плоскости "XY" ЛСК и параметрической плоскости "UV" поверхности.
+                              \en The angle of rotation of the LSC "XY" plane and the parametric "UV" plane of the surface. \~
+    \param[in] sense_       - \ru Совпадают ли направления оси "X" ЛСК и оси "U" поверхности.
+                              \en Whether the directions of the "X" axis of the LSC and the "U" axis of the surface coincide? \~
+    \param[in] equals_      - \ru Должны ли длины кривых на другом носителе соответствовать оригиналам.
+                              \en Should the lengths of the curves on another medium match the originals?\~
+    \param[in] accuracy_    - \ru Точность построения.
+                              \en The accuracy. \~
+    \param[in] copyCurves_  - \ru Сохранить ли в этом классе параметров копии кривых.
+                              \en Whether to save the curves copies in this parameter class. \~
+    \param[in] copySurface_ - \ru Сохранить ли в классе параметров копию поверхности.
+                              \en Whether to save the surface copy in this parameter class. \~
+    \param[in] ver_         - \ru Версия алгоритма.
+                              \en The version. \~
+  */
+  MbCurvesWrappingParams( const c3d::ConstPlaneCurveSPtr & curve_,
+                          const MbPlacement3D & place_,
+                          const MbCartPoint &   xy_,
+                          const MbSurface &     surface_,
+                          const MbCartPoint &   uv_,
+                                double  angle_,
+                                bool    sense_,
+                                bool    equals_,
+                                double  accuracy_,
+                                bool    copyCurves_,
+                                bool    copySurface_,
+                                VERSION ver_ );
+
+
+  /** \brief \ru Конструктор по 1 кривой.
+             \en Constructor by 1 curve.\~
+    \details \ru Конструктор по 1 кривой.
+             \en Constructor by 1 curve.\~
+    \param[in] curve_       - \ru 3д кривая, копия которой будет свёрнута/развёрнута. Ожидается, что внутри -- 2д кривая на поверхности.
+                              \en 3d curve, which copy will be wrapped/unwrapped. It is expected that there is 2d curve on surface inside.\~
+    \param[in] place_       - \ru Локальная система координат (ЛСК) плоскости.
+                              \en The local coordinate system (LCS) of the plane. \~
+    \param[in] xy_          - \ru Точка привязки на плоскости, которая будет привязана к uv-точке на поверхности.
+                              \en The anchor point on the plane that will be aligned with the uv point on the parametric plane of the surface. \~
+    \param[in] surface_     - \ru Поверхность для сворачивания/разворачивания.
+                              \en The surface to wrap to/unwrap from. \~
+    \param[in] uv_          - \ru Точка привязки на поверхности в параметрической плоскости "UV". Будет привязана к xy-точке на плоскости.
+                              \en The anchor uv point on the parametric plane of the surface that will be aligned with the xy point on the plane.\~
+    \param[in] angle_       - \ru Угол поворота плоскости "XY" ЛСК и параметрической плоскости "UV" поверхности.
+                              \en The angle of rotation of the LSC "XY" plane and the parametric "UV" plane of the surface. \~
+    \param[in] sense_       - \ru Совпадают ли направления оси "X" ЛСК и оси "U" поверхности.
+                              \en Whether the directions of the "X" axis of the LSC and the "U" axis of the surface coincide? \~
+    \param[in] equals_      - \ru Должны ли длины кривых на другом носителе соответствовать оригиналам.
+                              \en Should the lengths of the curves on another medium match the originals?\~
+    \param[in] accuracy_    - \ru Точность построения.
+                              \en The accuracy. \~
+    \param[in] copyCurves_  - \ru Сохранить ли в этом классе параметров копии кривых.
+                              \en Whether to save the curves copies in this parameter class. \~
+    \param[in] copySurface_ - \ru Сохранить ли в классе параметров копию поверхности.
+                              \en Whether to save the surface copy in this parameter class. \~
+    \param[in] ver_         - \ru Версия алгоритма.
+                              \en The version. \~
+  */
+  MbCurvesWrappingParams( const c3d::ConstSpaceCurveSPtr & curve_,
+                          const MbPlacement3D & place_,
+                          const MbCartPoint &   xy_,
+                          const MbSurface &     surface_,
+                          const MbCartPoint &   uv_,
+                                double  angle_,
+                                bool    sense_,
+                                bool    equals_,
+                                double  accuracy_,
+                                bool    copyCurves_,
+                                bool    copySurface_,
+                                VERSION ver_ );
+
+
   /** \brief \ru Конструктор копирования.
              \en Copy constructor.\~
     \details \ru Конструктор копирования.
@@ -1206,26 +1343,36 @@ public:
     \param[in] copySurface - \ru Создать копию поверхности.
                              \en Create a copy of the surface. \~
   */
-  MbCurvesWrappingParams( const MbCurvesWrappingParams & other, bool copyCurves, bool copySurface );
-
-  /** \brief \ru Конструктор копирования, копирует кривые и поверхности.
-             \en Copy constructor, copies curves and surfaces.\~
-    \details \ru Конструктор копирования, копирует кривые и поверхности.
-             \en Copy constructor, copies curves and surfaces.\~
-  */
-  MbCurvesWrappingParams( const MbCurvesWrappingParams & other )
-    : MbCurvesWrappingParams( other, true, true ) {}
-
-    /// \ru Деструктор. \ en Destructor.
+  MbCurvesWrappingParams( const MbCurvesWrappingParams & other, bool copyCurves, bool copySurface, MbRegDuplicate * iReg = nullptr );
+  /// \ru Деструктор. \ en Destructor.
   ~MbCurvesWrappingParams() {}
 
+  // Закрытые методы добавления кривых.
+private:
+  /// \ru Добавить 2d или 3d кривые с проверкой на нули. \en 2d or 3d curves with nullptr check. \~
+  template<class CurveVector>
+  void AddCurves( const CurveVector & curves, bool copyCurves, MbRegDuplicate * iReg );
+  /// \ru Добавить кривую без копирования с проверкой на nullptr. \en Add curve without copy and with nullptr check. \~ 
+  void AddCurve( const MbCurve3D * curve );
+  ///< \ru Добавить кривую без копирования с проверкой на nullptr. \en Add curve without copy and with nullptr check. \~ 
+  void AddCurve( const MbCurve *   curve );
+  ///< \ru Добавить кривую с проверкой на nullptr. \en Add curve with nullptr check. \~ 
+  void AddCurve( const MbCurve3D * curve, bool copyCurve /*= false */, MbRegDuplicate * iReg );
+  ///< \ru Добавить кривую с проверкой на nullptr. \en Add curve with nullptr check. \~ 
+  void AddCurve( const MbCurve *   curve, bool copyCurve /*= false */, MbRegDuplicate * iReg );
+
+
 public:
+  /// \ru Дать двумерную кривую. \en Get two-dimensional curve by index. \~
+  const c3d::ConstPlaneCurveSPtr & GetCurve( size_t i ) const { return curves[i]; }
+
+  /// \ru Дать двумерные кривые. \en Get two-dimensional curves. \~
+  const c3d::ConstPlaneCurvesSPtrVector & GetCurves() const { return curves; }
+
   /// \ru Дать двумерные кривые. \en Get two-dimensional curves. \~
         void                    GetCurves( c3d::ConstPlaneCurvesSPtrVector & retCurves ) const;
   /// \ru Дать количество кривых. \en Get two-dimensional curves count. \~
         size_t                  GetCurvesCount()                       const { return curves.size(); }
-  /// \ru Дать двумерную кривую. \en Get two-dimensional curve by index. \~
-  const c3d::ConstPlaneCurveSPtr &   GetCurve( size_t i )                   const { return curves[i]; }
   /// \ru Заменить двумерную кривую. \en Set two-dimensional curve by index. \~
         void                    SetCurve( size_t i, const MbCurve & c )      { if ( i < curves.size() ) curves[i].assign( const_cast<MbCurve *>(&c)); }
   /// \ru Заменить двумерную кривую. \en Set two-dimensional curve by index. \~
@@ -1258,11 +1405,11 @@ public:
         double             GetAngle()                const { return angle; }
   /// \ru Установить угол поворота плоскости "XY" ЛСК и параметрической плоскости "UV" поверхности. \en Set the angle of rotation of the LSC "XY" plane and the parametric "UV" plane of the surface. \~
         void               SetAngle( double a )            { angle = a; }
-  /// \ru Совпадают ли направления оси "X" ЛСК и оси "U" поверхности. \en Does the coincidence of the directions of the "X" axis of the LSC and the "U" axis of the surface. \~
+  /// \ru Совпадают ли ориентации осей "X-Y" ЛСК и осей "U-V" поверхности. \en Whether the orientations of LCS "X-Y" axes and the surface "U-V" axes are same. \~
         bool               IsSense()                 const { return sense; }
   /// \ru Установить флаг совпадения направления оси "X" ЛСК и оси "U" поверхности. \en Set the coincidence of the directions of the "X" axis of the LSC and the "U" axis of the surface. \~
         void               SetSense( bool s )              { sense = s; }
-  /// \ru Соответствует ли длина кривых в плоскости и на поверхности? \en Does the curves length correspond to the originals on the surface? \~
+  /// \ru Должна ли совпадать длина итоговых кривых оригинальным. \en Should the result curve length be equal to the original curve length? \~
         bool               IsEquals()                const { return equals; }
   /// \ru Установить требование совпадения длины кривых в плоскости и на поверхности? \en Set the curves length correspondence to the originals on the surface? \~
         void               SetEquals( bool e )             { equals = e; }
@@ -1275,6 +1422,14 @@ public:
   /// \ru Установить версию алгоритма. \en Set the algorithm version. \~
         void               SetVersion( VERSION ver )       { version = ver; } 
 
+  /// \ru Проверка на валидность: поверхность не null и часть кривых не null. \en The validity check: whether surface is not null and some of the curves are not null. \~
+        bool               IsValid  () const;
+
+  /// \ru Сравнение параметров. \en The comparison with other parameters. \~
+        bool               IsSame   ( const MbCurvesWrappingParams & other, double accuracy ) const;
+  /// \ru Сравнение параметров. \en The comparison with other parameters. \~
+        bool               IsSimilar( const MbCurvesWrappingParams & other )                  const;
+
   /** \brief \ru Нужно ли сдвинуть кривые, попавшие одним краем на шов Umax.
              \en Whether to shift curves with one end on Umax seam.\~
     \details \ru Нужно ли сдвинуть кривые, попавшие краем на шов Umax. Если кривая попадает одним краем на шов Umax,
@@ -1312,7 +1467,9 @@ public:
   MbCurvesWrappingParams * Duplicate( bool copyCurves, bool copySurface );
 
 private:
-  MbCurvesWrappingParams & operator = ( const MbCurvesWrappingParams & other ); // \ru Не реализовано. \en Not implemented. 
+  MbCurvesWrappingParams & operator = ( const MbCurvesWrappingParams & other ); // \ru Приравнивание. \en Equal operator.  \~
+  friend class MATH_CLASS MbUnwrapCurveCreator;
+  KNOWN_OBJECTS_RW_REF_OPERATORS( MbCurvesWrappingParams ) // \ru Для работы со ссылками и объектами класса. \en For working with references and objects of the class. \~
 };
 
 

C3d/Include/op_shell_parameter.h

@@ -4874,22 +4874,23 @@ void MbLoftedSolidParams::GetContoursNames( NamesPointers & sectionsNames ) cons
   \warning \ru В разработке. \en Under development.
 */
 // ---
-class MATH_CLASS MbEvolutionSolidParams : public MbPrecision
+class MATH_CLASS MbEvolutionShellParams : public MbPrecision
 {
 protected:
-  const MbSweptData &        _sweptData;     ///< \ru Данные об образующей. \en The generating curve data. \~
-  c3d::ConstSpineSPtr        _spine;         ///< \ru Направляющая кривая c дополнительной информацией. \en The spine curve with additional data. \~
-  c3d::SNameMakerSPtr        _operName;      ///< \ru Именователь операции. \en An object defining names generation in the operation. \~
-  c3d::SNameMakerSPtr        _spineName;     ///< \ru Именователь направляющей. \en An object defining the name of a spine curve. \~
-  c3d::SNamesMakerSPtrVector _contoursNames; ///< \ru Именователь контуров образующей. \en An object defining the names of generating curve contours. \~
-  const EvolutionValues &    _evolParams;    ///< \ru Параметры операции. \en The operation parameters. \~
+  const MbSweptData &               _sweptData;     ///< \ru Данные об образующей. \en The generating curve data. \~
+  const MbCurve3D *                 _spineCurve;    ///< \ru Направляющая кривая. \en The spine curve. \~
+  const MbSpine *                   _spine;         ///< \ru Направляющая кривая c дополнительной информацией. \en The spine curve with additional data. \~
+  const MbSNameMaker &              _operName;      ///< \ru Именователь операции. \en An object defining names generation in the operation. \~
+  const MbSNameMaker &              _spineName;     ///< \ru Именователь направляющей. \en An object defining the name of a spine curve. \~
+  std::vector<const MbSNameMaker *> _contoursNames; ///< \ru Именователь контуров образующей. \en An object defining the names of generating curve contours. \~
+  const EvolutionValues &           _evolParams;    ///< \ru Параметры операции. \en The operation parameters. \~
 
   // Данные, необходимые для построения элемента по траектории с динамической параметризацией сечения.
   const c3d::ConstFunctionSPtrVector * _funcs; ///< \ru Функции ограничений, наложенных на сегменты контуров образующей (при использовании динамической параметризации сечения). \en Functions of constraints imposed on segments of generating curve contours (when using variable section). \~
   const IVariableSectionData * _sectionData;   ///< \ru Интерфейс для получения сечений в кинематической операции с динамической параметризацией сечения. \en An interface for obtaining sections for sweeping operation with variable section. \~
 
 public:
-  mutable IProgressIndicator * _progress;    ///< \ru Индикатор прогресса выполнения операции. \en An operation progress indicator.
+  mutable IProgressIndicator * _progress; ///< \ru Индикатор прогресса выполнения операции. \en An operation progress indicator.
 
 public:
 /** \brief \ru Конструктор по параметрам операции.
@@ -4908,8 +4909,10 @@ public:
                             \en An object defining the names of generating curve contours. \~
   \param[in] spineName    - \ru Именователь направляющей.
                             \en An object defining the name of a guide curve. \~
+  \param[in] prog         - \ru Индикатор прогресса выполнения операции.
+                            \en An operation progress indicator. \~
 */
-  MbEvolutionSolidParams( const MbSweptData &           sweptData,
+  MbEvolutionShellParams( const MbSweptData &           sweptData,
                           const MbCurve3D &             spineCurve,
                           const EvolutionValues &       evolParams,
                           const MbSNameMaker &          operName,
@@ -4933,8 +4936,10 @@ public:
                             \en An object defining the names of generating curve contours. \~
   \param[in] spineName    - \ru Именователь направляющей.
                             \en An object defining the name of a guide curve. \~
+  \param[in] prog         - \ru Индикатор прогресса выполнения операции.
+                            \en An operation progress indicator. \~
 */
-  MbEvolutionSolidParams( const MbSweptData &           sweptData,
+  MbEvolutionShellParams( const MbSweptData &           sweptData,
                           const MbSpine &               spine,
                           const EvolutionValues &       evolParams,
                           const MbSNameMaker &          operName,
@@ -4962,8 +4967,10 @@ public:
                             \en An object defining the names of generating curve contours. \~
   \param[in] spineName    - \ru Именователь направляющей.
                             \en An object defining the name of a guide curve. \~
+  \param[in] prog         - \ru Индикатор прогресса выполнения операции.
+                            \en An operation progress indicator. \~
 */
-  MbEvolutionSolidParams( const MbSweptData &                  sweptData,
+  MbEvolutionShellParams( const MbSweptData &                  sweptData,
                           const MbSpine &                      spine,
                           const EvolutionValues &              evolParams,
                           const c3d::ConstFunctionSPtrVector * funcs,
@@ -4973,15 +4980,17 @@ public:
                           const MbSNameMaker &                 spineName,
                                 IProgressIndicator *           prog = nullptr );
 
-
   /// \ru Деструктор. \en Destructor. \~
-  ~MbEvolutionSolidParams();
+  ~MbEvolutionShellParams();
 
   /// \ru Получить данные об образующей. \en Get the generating curve data. \~
   const MbSweptData & GetSweptData() const;
 
+  /// \ru Получить направляющую кривую. \en Get the spine curve. \~
+  const MbCurve3D * GetSpineCurve() const;
+
   /// \ru Получить направляющую кривую с дополнительной информацией. \en Get the spine curve with additional information. \~
-  const c3d::ConstSpineSPtr & GetSpine() const;
+  const MbSpine * GetSpine() const;
 
   /// \ru Получить параметры операции. \en Get the operation parameters. \~
   const EvolutionValues & GetEvolutionParameters() const;
@@ -5007,7 +5016,7 @@ private:
   template<class NamesPointers>
   void SetContoursNames( const NamesPointers & contoursNames );
 
-OBVIOUS_PRIVATE_COPY( MbEvolutionSolidParams )
+OBVIOUS_PRIVATE_COPY( MbEvolutionShellParams )
 };
 
 
@@ -5016,10 +5025,10 @@ OBVIOUS_PRIVATE_COPY( MbEvolutionSolidParams )
 // \en Get the objects defining the names of generating contours. NamesPointers is a vector of pointers (SPtr is available, too) to MbSNameMaker. \~
 // ---
 template<class NamesPointers>
-void MbEvolutionSolidParams::GetContoursNames( NamesPointers & contoursNames ) const
+void MbEvolutionShellParams::GetContoursNames( NamesPointers & contoursNames ) const
 {
   contoursNames.reserve( contoursNames.size() + _contoursNames.size() );
-  for ( const auto & cntrNamePtr : _contoursNames )
+  for ( auto cntrNamePtr : _contoursNames )
     contoursNames.push_back( cntrNamePtr );
 }
 
@@ -5029,13 +5038,13 @@ void MbEvolutionSolidParams::GetContoursNames( NamesPointers & contoursNames ) c
 // \en Set the objects defining the names of generating contours. NamesPointers is a vector of pointers (SPtr is available, too) to MbSNameMaker. \~
 // ---
 template<class NamesPointers>
-inline void MbEvolutionSolidParams::SetContoursNames( const NamesPointers & contoursNames )
+inline void MbEvolutionShellParams::SetContoursNames( const NamesPointers & contoursNames )
 {
   _contoursNames.clear();
   _contoursNames.reserve( contoursNames.size() );
   for ( const auto & cntrNamePtr : contoursNames ) {
     if ( cntrNamePtr != nullptr )
-      _contoursNames.push_back( c3d::SNameMakerSPtr(&(cntrNamePtr->Duplicate())) );
+      _contoursNames.push_back( &(*cntrNamePtr) );
   }
 }
 

C3d/Include/op_swept_parameter.h

@@ -137,11 +137,20 @@ public:
              \en Constructor. \~
     \details \ru Конструктор по кривой.
              \en Constructor by a contour. \~
-    \param[in] _contour3d - \ru Кривая. Используются оригиналы.
-                             \en A curve. Used originals. \~
+    \param[in] _curve3d - \ru Кривая. Используются оригиналы.
+                          \en A curve. Used originals. \~
   */
   MbSweptData( MbCurve3D & _curve3d );
 
+  /** \brief \ru Конструктор по трехмерным кривым.
+             \en Constructor by 3d curves. \~
+    \details \ru Конструктор по трехмерным кривым.
+             \en Constructor by 3d curves. \~
+    \param[in] _curves3d - \ru Кривые. Используются оригиналы.
+                           \en A curves. Used originals. \~
+  */
+  MbSweptData( c3d::SpaceCurvesSPtrVector & _curves3d );
+
   /** \brief \ru Конструктор.
              \en Constructor. \~
     \details \ru Конструктор по контуру.
@@ -888,6 +897,10 @@ public:
         void        SetSurface2( const MbSurface * s ) { side2.SetSurface( s ); }
         /// \ru Поменять поверхности местами. \en Swap surfaces.
         void        ExchangeSurfaces();
+        /// \ru Уклон задан. \en Is draft set.
+        bool        IsRakeSet() const;
+        /// \ru Тонкая стенка задана. \en Is thickness set.
+        bool        IsThicknessSet() const;
 };
 
 
@@ -1563,12 +1576,31 @@ private:
 struct MATH_CLASS MbExtrusionLayout : public MbSweptLayout {
 public:
   MbVector3D dirVector; ///< \ru Вектор выдавливания. \en An extrusion vector.
+  double     rake1;     ///< \ru Уклон в прямом направлении. \en Slope in the forward direction.
+  double     rake2;     ///< \ru Уклон в обратном направлении. \en Slope in the opposite direction.
 
 public:
   /// \ru Конструктор. \en Constructor.
-  MbExtrusionLayout( const MbSurface & surf, Direction dir, const MbVector3D & dirVec ) : MbSweptLayout( surf, dir ), dirVector( dirVec ) {}
+  MbExtrusionLayout( const MbSurface & surf, Direction dir, const MbVector3D & dirVec )
+    : MbSweptLayout( surf, dir )
+    , dirVector( dirVec ) 
+    , rake1( 0.0 )
+    , rake2( 0.0 )
+  {}
+  /// \ru Конструктор. \en Constructor.
+  MbExtrusionLayout( const MbSurface & surf, Direction dir, double initRake1, double initRake2, const MbVector3D & dirVec )
+    : MbSweptLayout( surf, dir )
+    , dirVector( dirVec ) 
+    , rake1( initRake1 )
+    , rake2( initRake2 )
+  {}
   /// \ru Конструктор копирования. \en Copy-constructor.
-  MbExtrusionLayout( const MbExtrusionLayout & other ) : MbSweptLayout( other ), dirVector( other.dirVector ) {}
+  MbExtrusionLayout( const MbExtrusionLayout & other ) 
+    : MbSweptLayout( other )
+    , dirVector( other.dirVector )
+    , rake1( other.rake1 )
+    , rake2( other.rake2 )
+  {}
   /// \ru Деструктор. \en Destructor.
   virtual ~MbExtrusionLayout();
 public:
@@ -1697,7 +1729,8 @@ public:
   size_t          GetFacesCount() const { return faces.size(); }
   size_t          GetFaceSideCount() const { return faceSide.size(); }
   /// \ru Выдать опорную грань. \en Get guide face.
-  MbFace *        SetFace( size_t i ) { return ( i < faces.size() ) ? faces[i].get() : nullptr; }
+  const MbFace *  GetFace( size_t i ) const { return ( i < faces.size() ) ? faces[i].get() : nullptr; }
+  MbFace *        SetFace( size_t i )       { return ( i < faces.size() ) ? faces[i].get() : nullptr; }
   /// \ru Установить сторону касания грани. \en Set face side.
   void            SetFaceSide( size_t i, bool s ) { if ( i < faceSide.size() ) faceSide[i] = s; }
 
@@ -1715,6 +1748,7 @@ public:
   size_t          GetEdgesCount() const { return edges.size(); }
   size_t          GetEdgeSideCount() const { return edgeSide.size(); }
   /// \ru Выдать направляющее ребро. \en Get guide edge.
+  const MbCurveEdge * GetEdge( size_t i ) const { return ( i < edges.size() ) ? edges[i].get() : nullptr; }
   MbCurveEdge *   SetEdge( size_t i ) { return ( i < edges.size() ) ? edges[i].get() : nullptr; }
   /// \ru Установить сторону ребра. \en Set edge side.
   void            SetEdgeSide( size_t i, bool s ) { if ( i < edgeSide.size() ) edgeSide[i] = s; }
@@ -1725,7 +1759,8 @@ public:
   /// \ru Выдать количество тел опорных граней или направляющих рёбер. \en Get solids of reference faces or guide edges count.
   size_t          GetSolidsCount() const { return solids.size(); }
   /// \ru Выдать тело по индексу. \en Get solid by index.
-  MbSolid *       SetSolid( size_t i ) { return ( i < solids.size() ) ? solids[i].get() : nullptr; }
+  const MbSolid * GetSolid( size_t i ) const { return ( i < solids.size() ) ? solids[i].get() : nullptr; }
+  MbSolid *       SetSolid( size_t i )       { return ( i < solids.size() ) ? solids[i].get() : nullptr; }
   /// \ru Очистить контейр тел. \en Solid conteiner clear.
   void            SolidsClear();
   /// \ru Выдать уникальные тела. \en Give out unique solids.
@@ -1740,6 +1775,7 @@ public:
   /// \ru Выдать количество дополнительных направляющих кривых. \en Get additional guide curves count.
   size_t          GetCurvesCount() const { return curves.size(); }
   /// \ru Выдать дополнительную направляющую кривую. \en Get additional guide curve.
+  const MbCurve3D * GetCurve( size_t i ) const { return ( i < curves.size() ) ? curves[i].get() : nullptr; }
   MbCurve3D *     SetCurve( size_t i ) { return ( i < curves.size() ) ? curves[i].get() : nullptr; }
 
   /// \ru Добавить в данные кривую. \en Add curve to data. \~
@@ -2020,9 +2056,11 @@ public:
   size_t          GetFaceSideCount1() const { return rail1.GetFaceSideCount(); }
   size_t          GetFaceSideCount2() const { return rail2.GetFaceSideCount(); }
   /// \ru Выдать направляющую грань. \en Get guide face.
-  MbFace *        SetFace1( size_t i ) { return rail1.SetFace( i ); }
+  const MbFace *  GetFace1( size_t i ) const { return rail1.GetFace( i ); }
+  MbFace *        SetFace1( size_t i )       { return rail1.SetFace( i ); }
   /// \ru Выдать направляющую грань. \en Get guide face.
-  MbFace *        SetFace2( size_t i ) { return rail2.SetFace( i ); }
+  const MbFace *  GetFace2( size_t i ) const { return rail2.GetFace( i ); }
+  MbFace *        SetFace2( size_t i )       { return rail2.SetFace( i ); }
 
   /// \ru Добавить в данные направляющее ребро. \en Add guiding to data. \~
   void            AddEdge1( MbCurveEdge & _edge, bool side, MbSolid * solid = nullptr ) { rail1.AddEdge( _edge, side, solid ); }
@@ -2047,9 +2085,11 @@ public:
   size_t          GetEdgeSideCount1() const { return rail1.GetEdgeSideCount(); }
   size_t          GetEdgeSideCount2() const { return rail2.GetEdgeSideCount(); }
   /// \ru Выдать направляющее ребро. \en Get guide edge.
-  MbCurveEdge *   SetEdge1( size_t i ) { return rail1.SetEdge( i ); }
+  const MbCurveEdge * GetEdge1( size_t i ) const { return rail1.GetEdge( i ); }
+  MbCurveEdge *   SetEdge1( size_t i )           { return rail1.SetEdge( i ); }
   /// \ru Выдать направляющее ребро. \en Get guide edge.
-  MbCurveEdge *   SetEdge2( size_t i ) { return rail2.SetEdge( i ); }
+  const MbCurveEdge * GetEdge2( size_t i ) const { return rail2.GetEdge( i ); }
+  MbCurveEdge *   SetEdge2( size_t i )           { return rail2.SetEdge( i ); }
 
   /// \ru Выдать тела опорных граней или направляющих рёбер. \en Get solids of reference faces or guide edges.
   void            GetSolids1( std::vector<MbSolid *> & sols ) const { rail1.GetSolids( sols ); }
@@ -2060,8 +2100,10 @@ public:
   size_t          GetSolidsCount1() const { return rail1.GetSolidsCount(); }
   size_t          GetSolidsCount2() const { return rail2.GetSolidsCount(); }
   /// \ru Выдать тело по индексу. \en Get solid by index.
-  MbSolid *       SetSolid1( size_t i ) { return rail1.SetSolid( i ); }
-  MbSolid *       SetSolid2( size_t i ) { return rail2.SetSolid( i ); }
+  const MbSolid * GetSolid1( size_t i ) const { return rail1.GetSolid( i ); }
+  MbSolid *       SetSolid1( size_t i )       { return rail1.SetSolid( i ); }
+  const MbSolid * GetSolid2( size_t i ) const { return rail2.GetSolid( i ); }
+  MbSolid *       SetSolid2( size_t i )       { return rail2.SetSolid( i ); }
   /// \ru Выдать уникальные тела. \en Give out unique solids.
   void            GetUniqueSolids1( std::vector<MbSolid *> & sols ) const { rail1.GetUniqueSolids( sols ); }
   void            GetUniqueSolids2( std::vector<MbSolid *> & sols ) const { rail2.GetUniqueSolids( sols ); }
@@ -2078,9 +2120,11 @@ public:
   size_t          GetCurvesCount1() const { return rail1.GetCurvesCount(); }
   size_t          GetCurvesCount2() const { return rail2.GetCurvesCount(); }
   /// \ru Выдать направляющую кривую. \en Get guide curve.
-  MbCurve3D *     SetCurve1( size_t i ) { return rail1.SetCurve( i ); }
+  const MbCurve3D * GetCurve1( size_t i ) const { return rail1.GetCurve( i ); }
+  MbCurve3D *     SetCurve1( size_t i )         { return rail1.SetCurve( i ); }
   /// \ru Выдать направляющую кривую. \en Get guide curve.
-  MbCurve3D *     SetCurve2( size_t i ) { return rail2.SetCurve( i ); }
+  const MbCurve3D * GetCurve2( size_t i ) const { return rail2.GetCurve( i ); }
+  MbCurve3D *     SetCurve2( size_t i )         { return rail2.SetCurve( i ); }
 
   /// \ru Добавить в данные кривую, через которую должно пройти сечение. \en Add curve that the section should pass through. \~
   void            SetTrack1( MbCurve3D & tr ) { rail1.SetTrack( tr ); }
@@ -2370,4 +2414,140 @@ public :
 }; // MbSectionPhantom
 
 
+//------------------------------------------------------------------------------
+/** \brief \ru Параметры операции поиска ближайшего тела GetNearestSolid.
+           \en Parameters of the GetNearestSolid operation to find the nearest body. \~
+    \details \ru Параметры операции поиска ближайшего тела GetNearestSolid.
+             \en Parameters of the GetNearestSolid operation to find the nearest body. \n \~
+    \ingroup Shell_Building_Parameters
+*/
+// ---
+class MATH_CLASS MbNearestSolidParams : public MbPrecision
+{
+private:
+  c3d::SolidsSPtrVector    _solids;               ///< \ru Контейнер тел для поиска ближайшего. \en Container of bodies to find the nearest one.
+  MbSweptData              _sweptData;            ///< \ru Данные об образующей операции выдавливания. \en Information about the generatrix of the extrusion operation.
+
+  MbVector3D               _direction;            ///< \ru Направление выдавливания. \en Extrusion direction.
+  MbSweptLayout::Direction _operationDirection;   ///< \ru Направление поиска тел (прямое, обратное или оба). \en Body search direction (forward, reverse, or both).
+
+  SweptValuesAndSides      _valuesAndSides;       ///< \ru Для учета угла уклона и тонкой стенки. В разработке. \en To account for slope angle and thin wall. In developing.
+
+public:
+
+  /** \brief \ru Конструктор.
+             \en Constructor. \~
+      \details \ru Конструктор для образующей общего вида.
+               \en Constructor for a generatrix of a general form. \~
+      \param[in] sweptData          - \ru Образующая.
+                                      \en Generatrix. \~
+      \param[in] direction          - \ru Направление выдавливания.
+                                      \en Direction of extrusion. \~
+      \param[in] operationDirection - \ru Направление выдавливания (прямое, обратное или оба).
+                                      \en Direction of extrusion (forward, reverse, or both). \~
+      \param[in] solids             - \ru Набор тел для поиска ближайшего 
+                                      \en Container of bodies to find the nearest one. \~
+  */
+  MbNearestSolidParams( const MbSweptData &            sweptData,
+                        const MbVector3D &             direction,
+                              MbSweptLayout::Direction operationDirection,
+                        const c3d::SolidsSPtrVector  & solids );
+
+  /** \brief \ru Конструктор.
+             \en Constructor. \~
+      \details \ru Конструктор для образующей общего вида.
+               \en Constructor for a generatrix of a general form. \~
+      \param[in] sweptData          - \ru Образующая.
+                                      \en Generatrix. \~
+      \param[in] direction          - \ru Направление выдавливания.
+                                      \en Direction of extrusion. \~
+      \param[in] operationDirection - \ru Направление выдавливания (прямое, обратное или оба).
+                                      \en Direction of extrusion (forward, reverse, or both). \~
+      \param[in] valuesAndSides     - \ru Для учета угла уклона и тонкой стенки. В разработке.
+                                      \en To account for slope angle and thin wall. In developing. \~
+      \param[in] solids             - \ru Набор тел для поиска ближайшего 
+                                      \en Container of bodies to find the nearest one. \~
+  */
+  MbNearestSolidParams( const MbSweptData &            sweptData,
+                        const MbVector3D &             direction,
+                              MbSweptLayout::Direction operationDirection,
+                        const SweptValuesAndSides &    valuesAndSides,
+                        const c3d::SolidsSPtrVector  & solids );
+
+
+  const MbSweptData &             GetSweptData()        const { return _sweptData; }            ///< \ru Выдать информацию об образующей. \en Get information about the generatrix.
+  const MbVector3D &              GetDirectionVector()  const { return _direction; }            ///< \ru Выдать вектор направления выдавливания. \en Get the direction vector of the extrusion.
+        MbSweptLayout::Direction  GetDirection()        const { return _operationDirection; }   ///< \ru Выдать направление выдавливания (прямое, обратное или оба). \en Get the direction of the extrusion (forward, reverse, or both).
+  const c3d::SolidsSPtrVector &   GetSolids()           const { return _solids; }               ///< \ru Выдать набор тел. \en Get a set of solids.
+
+  const SweptValuesAndSides &     GetValuesAndSides()   const { return _valuesAndSides;     }   ///< \ru Выдать параметры для учета угла уклона о тонкой стенки. \en Get parameters to take into account the slope angle of the thin wall.
+
+  /** \brief \ru Изменение тела по индексу.
+             \en Changing the solid by index. \~
+      \details \ru Изменить тело по индексу.
+               \en Changing the solid by index. \~
+      \param[in] ind - \ru Индекс тела в контейнере тел _solids. Соответствует индексу тела в контейнере в аргументах конструктора.
+                       \en Solid index in solids container _solids. Corresponds to the index of the solid in the container in the constructor arguments. \~
+      \param[in] ind - \ru Новое тело.
+                       \en New solid. \~
+      \return \ru true, если индекс корректный.
+              \en true if the index is valid. \~
+  */
+        bool                      ChangeSolid( size_t ind, MbSolid * newSolid );
+
+private:
+  // \ru Добавление набора тел. \en Adding a set of solids.
+  void Add( const c3d::SolidsSPtrVector & solids );
+
+OBVIOUS_PRIVATE_COPY( MbNearestSolidParams )
+};
+
+
+//------------------------------------------------------------------------------
+/** \brief \ru Результат операции поиска ближайшего тела в заданном направлении.
+           \en The result of the search operation for the nearest body in the specified direction. \~
+    \details \ru Результат операции поиска ближайшего тела в заданном направлении..
+             \en The result of the search operation for the nearest body in the specified direction. \n \~
+    \ingroup Shell_Building_Parameters
+*/
+// ---
+class MATH_CLASS MbNearestSolidResult
+{
+private:
+  size_t _nPlus;    ///< \ru Индекс ближайшего тела в прямом направлении.   \en The index of the nearest solid in the forward direction.
+  size_t _nMinus;   ///< \ru Индекс ближайшего тела в обратном направлении. \en The index of the nearest solid in the reverse direction.
+
+public:
+  /// \ru Конструктор. \en Constructor.
+  MbNearestSolidResult()
+    : _nPlus ( SYS_MAX_T )
+    , _nMinus( SYS_MAX_T )
+  {}
+
+  /// \ru Конструктор. \en Constructor.
+  MbNearestSolidResult( size_t plus, size_t minus )
+    : _nPlus ( plus )
+    , _nMinus( minus )
+  {}
+
+  /// \ru Конструктор копирования. \en Copy constructor.
+  MbNearestSolidResult( const MbNearestSolidResult & other )
+    : _nPlus ( other._nPlus )
+    , _nMinus( other._nMinus )
+  {}
+
+  /// \ru Оператор присваивания. \en assignment operator.
+  const MbNearestSolidResult & operator = ( const MbNearestSolidResult & other ) {
+    _nPlus  = other._nPlus;
+    _nMinus = other._nMinus;
+    return *this;
+  }
+
+  ///< \ru Индекс ближайшего тела в прямом направлении. \en The index of the nearest solid in the forward direction.
+  size_t GetNearestPlus()  const { return _nPlus;  }
+  ///< \ru Индекс ближайшего тела в обратном направлении. \en The index of the nearest solid in the opposite direction.
+  size_t GetNearestMinus() const { return _nMinus; }
+};
+
+
 #endif // __OP_SWEPT_PARAMETERS_H

C3d/Include/tool_mutex.h

@@ -28,24 +28,122 @@
 //---
 enum MbeMultithreadedMode
 {
-  ///< \ru Многопоточность ядра полностью отключена. Использовать интерфейсы ядра в многопоточном приложении нельзя.
-  ///< \en Kernel multithreading is completely off. The kernel interfaces can't be used in a multithreaded application.
+  ///< \ru Многопоточность ядра полностью отключена. Не разрешено использовать интерфейсы ядра в многопоточных вычислениях.
+  ///< \en Kernel multithreading is completely disabled. Using kernel interfaces in parallel computing is prohibited.
   mtm_Off = 0,
-  ///< \ru Включена внутренняя многопоточность ядра при обработке независимых объектов (без общих данных). Можно использовать интерфейсы ядра для параллельной обработки независимых объектов.
-  ///< \en Internal kernel multithreading is ON for independent objects (without common data). The kernel interfaces can be used to process independent objects in parallel. 
+  ///< \ru Разрешена многопоточная обработка только для объектов, не имеющих общих данных (независимых объектов). Включены внутренние многопоточные вычисления только для независимых объектов.
+  ///< \en Allowed parallel processing of objects that do not have common data (independent objects). Enabled internal multi-threaded calculations only for independent objects.
   mtm_Standard = 1,
-  ///< \ru Обеспечивается потокобезопасность объектов ядра. Можно использовать интерфейсы ядра для параллельной обработки объектов. Но внутренняя многопоточность ядра при обработке объектов с общими данными отключена.
-  ///< \en Ensured thread-safety of the kernel objects. The kernel interfaces can be used to process objects in parallel. But internal multithreading is OFF for objects with shared data.
+  ///< \ru Обеспечивается потокобезопасность интерфейсов ядра. Разрешено использовать все интерфейсы ядра в многопоточных вычислениях. При этом включены внутренние многопоточные вычисления только для независимых объектов.
+  ///< \en Ensured thread safety of kernel interfaces. Allowed using all kernel interfaces in parallel computing. Enabled internal multithreaded calculations only for independent objects.
   mtm_SafeItems = 2,
-  ///< \ru Обеспечивается потокобезопасность объектов ядра. Можно использовать интерфейсы ядра для параллельной обработки объектов. Включена многопоточность ядра при обработке любых объектов.
-  ///< \en Ensured thread-safety of kernel objects. The kernel interfaces can be used to process objects in parallel. Kernel multithreading is ON for any objects. 
+  ///< \ru Обеспечивается потокобезопасность объектов ядра. Разрешено использовать все интерфейсы ядра в многопоточных вычислениях. Полностью включены внутренние многопоточные вычисления.
+  ///< \en Ensured thread-safety of kernel interfaces. Allowed using all kernel interfaces in parallel computing. Enabled all internal parallel calculations in the kernel.
   mtm_Items = 3,
-  ///< \ru Включена максимальная многопоточность ядра. Можно использовать интерфейсы ядра для параллельной обработки объектов. Включена многопоточность ядра при обработке любых объектов. 
-  ///< \en Maximal kernel multithreading is ON. The kernel interfaces can be used to process objects in parallel. Kernel multithreading is ON for any objects. 
+  ///< \ru Включена максимальная многопоточность ядра. Можно использовать интерфейсы ядра в параллельных вычислениях. Полностью включены внутренние многопоточные вычисления.
+  ///< \en Maximal kernel multithreading is ON. Allowed using all kernel interfaces in parallel computing. Enabled all internal parallel calculations in the kernel.
   mtm_Max = 31
 };
 
 
+////////////////////////////////////////////////////////////////////////////////
+//
+// \ru Поддержка многопоточности в пользовательском приложении.
+// 
+// \ru Перед запуском параллельных вычислений, необходимо проверить, что установленный режим
+//     многопоточности ядра, позволяет использовать параллельные вычисления.
+// \ru Чтобы использовать интерфейсы ядра в нескольких потоках,
+// \ru в ядре должен быть установлен режим многопоточных вычислений не ниже mtm_SafeItems.
+// \ru По умолчанию в ядре установлен режим максимальной многопоточности.
+//
+// \ru При использовании параллельных вычислений необходимо нотифицировать ядро
+//     о входе в параллельный регион и выходе из него.
+// \ru Для этого могут быть использованы:
+//     либо класс ParallelRegionGuard (защитник параллельного региона в области видимости),
+//     либо парные функции EnterParallelRegion и ExitParallelRegion,
+//     либо парные макросы ENTER_PARALLEL и EXIT_PARALLEL.
+// 
+// \ru Примеры:
+//
+//  // Использование класса ParallelRegionGuard.
+//  if( Math::CheckMultithreadedMode( mtm_Items ) ){
+//    ParallelRegionGuard l;
+//    std::thread t1( function1 );
+//    std::thread t2( function2 );
+//    t1.join();
+//    t2.join();
+//  }
+//
+//  // Использование функций.
+//  if( Math::CheckMultithreadedMode( mtm_Items ) ){
+//    EnterParallelRegion();
+//    std::thread t1( function1 );
+//    std::thread t2( function2 );
+//    t1.join();
+//    t2.join();
+//    ExitParallelRegion();
+//  }
+//
+//  // Использование макросов.
+//  bool useParallel = Math::CheckMultithreadedMode( mtm_Items );
+//  ENTER_PARALLEL( useParallel );
+//  std::thread t1( function1 );
+//  std::thread t2( function2 );
+//  t1.join();
+//  t2.join();
+//  EXIT_PARALLEL( useParallel );
+//
+//
+// \en Support of multithreading in user application.
+//
+// \en Before running parallel calculations, you need to check that the kernel multithreading mode 
+// \en allows parallel computing.
+// \en For using the kernel interfaces in several threads, the multithreading mode mtm_SafeItems
+// \en or higher should be defined in the kernel.
+// \en By default, the maximal multithreading mode is set in the kernel.
+//
+// \en While using parallel calculations, you need to notify the kernel about entering
+// \en and exiting a parallel region.
+// \en For that, you can use one of the ways:
+//     the class ParallelRegionGuard (a scoped guard of parallel region),
+// \en or the pair of the functions EnterParallelRegion and ExitParallelRegion, 
+//     or the pair of the macros ENTER_PARALLEL and EXIT_PARALLEL.
+// 
+// \en Examples:
+//
+//  // Using the ParallelRegionGuard class.
+//  if( Math::CheckMultithreadedMode( mtm_Items ) )
+//  {
+//    ParallelRegionGuard l;
+//    std::thread t1( function1 );
+//    std::thread t2( function2 );
+//    t1.join();
+//    t2.join();
+//  }
+//
+//  // Using the pair of the functions.
+//  if( Math::CheckMultithreadedMode( mtm_Items ) )
+//  {
+//    EnterParallelRegion();
+//    std::thread t1( function1 );
+//    std::thread t2( function2 );
+//    t1.join();
+//    t2.join();
+//    ExitParallelRegion();
+//  }
+//
+// // Using the pair of the macros.
+//  bool useParallel = Math::CheckMultithreadedMode( mtm_Items );
+//  ENTER_PARALLEL( useParallel );
+//  std::thread t1( function1 );
+//  std::thread t2( function2 );
+//  t1.join();
+//  t2.join();
+//  EXIT_PARALLEL( useParallel );
+//
+////////////////////////////////////////////////////////////////////////////////
+
+
 ////////////////////////////////////////////////////////////////////////////////
 //
 // \ru Управление блокировками.
@@ -141,74 +239,6 @@ public:
 #endif // C3D_NATIVE_LOCK
 
 
-////////////////////////////////////////////////////////////////////////////////
-//
-// \ru Поддержка многопоточности в пользовательском приложении.
-// \ru Перед запуском параллельных вычислений, приложение должно проверить, что установленный режим
-//     многопоточности ядра, позволяет использовать параллельные вычисления.
-// \ru Чтобы использовать интерфейсы ядра в нескольких потоках,
-// \ru для ядра должен быть установлен режим многопоточных вычислений не ниже mtm_SafeItems.
-//
-// \ru При использовании параллельных вычислений, пользовательское приложение
-// \ru обязано нотифицировать ядро о входе в параллельный регион и выходе из него.
-// \ru Для этого могут быть использованы класс ParallelRegionGuard (защитник параллельного региона
-// \ru в области видимости), функции EnterParallelRegion и ExitParallelRegion
-// или макросы ENTER_PARALLEL и EXIT_PARALLEL.
-// \ru Примеры:
-//
-//  if( Math::CheckMultithreadedMode( mtm_Items ) ){
-//    ParallelRegionGuard l;
-//    std::thread t1( function1 );
-//    std::thread t2( function2 );
-//    t1.join();
-//    t2.join();
-//  }
-//
-//  if( Math::CheckMultithreadedMode( mtm_Items ) ){
-//    EnterParallelRegion();
-//    std::thread t1( function1 );
-//    std::thread t2( function2 );
-//    t1.join();
-//    t2.join();
-//    ExitParallelRegion();
-//  }
-//
-//
-// \en Support of multithreading in user application.
-//
-// \en Before running parallel calculations, the application must check that the kernel multithreading mode 
-// \en allows parallel computing.
-// \en For using the kernel interfaces in several threads, the multithreading mode mtm_SafeItems
-// \en or higher should be defined for the kernel.
-//
-// \en When using parallel calculations, the application must notify the kernel about entering
-// \en and exiting a parallel region.
-// \en For that, the class ParallelRegionGuard (a scoped guard of parallel region),
-// \en the functions EnterParallelRegion and ExitParallelRegion, 
-// or macros ENTER_PARALLEL and EXIT_PARALLEL could be used.
-// \en Examples:
-//
-//  if( Math::CheckMultithreadedMode( mtm_Items ) )
-//  {
-//    ParallelRegionGuard l;
-//    std::thread t1( function1 );
-//    std::thread t2( function2 );
-//    t1.join();
-//    t2.join();
-//  }
-//
-//  if( Math::CheckMultithreadedMode( mtm_Items ) )
-//  {
-//    EnterParallelRegion();
-//    std::thread t1( function1 );
-//    std::thread t2( function2 );
-//    t1.join();
-//    t2.join();
-//    ExitParallelRegion();
-//  }
-//
-////////////////////////////////////////////////////////////////////////////////
-
 //------------------------------------------------------------------------------
 /** \brief \ru Защитник параллельного региона в области видимости.
            \en Scoped guard of parallel region. \~

C3d/Include/wire_frame.h

@@ -312,6 +312,9 @@ public :
           /// \ru Установить заданный флаг измененности для всех рёбер и вершин. \en Set flag of changes for all edges and vertices. 
           void    SetOwnChangedThrough( MbeChangedType );
 
+          /// Выдать центр тяжести каркаса. \en Get the frame's center of mass.
+          void GetWeightCentre( MbCartPoint3D & pc ) const;
+
 protected:
   /** \ru \name Функции для работы с проволочным каркасом как с кривой.
               Считается, что каркас имеет параметр, который изменяется от нуля до суммы параметрических длин всех рёбер.