Egalware/Extern
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
12eac5a4f2b7a14feb4e336bc0fcb1c04a626833
Extern/C3d/Include/op_mesh_parameter.h
T
SaraP 65b88af326 Extern : 
- C3d aggiornamento delle librerie ( 117956).
2023-08-21 08:57:30 +02:00

742 lines
36 KiB
C++
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
////////////////////////////////////////////////////////////////////////////////
/**
\file
\brief \ru Параметры операций над полигональными сетками.
\en Parameters of operations on the polygonal meshes. \~
*/
////////////////////////////////////////////////////////////////////////////////
#ifndef __OP_MESH_PARAMETERS_H
#define __OP_MESH_PARAMETERS_H
#include <math_define.h>
#include <mesh_plane_grid.h>
#include <mesh_float_point.h>
#include <model_item.h>
#include <templ_sptr.h>
#include <cur_contour.h>
#include <op_binding_data.h>
#include <curve3d.h>
#include <curve.h>
#include <mesh.h>
class MATH_CLASS MbFaceShell;
class MATH_CLASS MbStepData;
//------------------------------------------------------------------------------
/** \brief \ru Параметры операции упрощения триангуляции.
\en Triangulation simplification parameters. \~
\details \ru Параметры операции упрощения триангуляции.
Упрощение может производиться до достижения заданного количества треугольников,
либо до превышения заданной точности.
\en Triangulation simplification parameters.
Simplification can be carried out until target triangles count reaching or until
exceeding of specified tolerance. \~
\ingroup Shell_Building_Parameters
*/
// ---
class MATH_CLASS MbMeshSimplificationParams
{
private:
c3d::DoubleVector _toleranceLevels; ///< \ru Уровни точностей для упрощения. \en Tolerance levels for simplification. \~
c3d::IndicesVector _triangleCountLevels; ///< \ru Уровни количества треугольников для упрощения. \en Triangle count levels for simplification. \~
public:
/// \ru Конструктор для задания целевй точности. \en Constructor for tolerance target. \~
MbMeshSimplificationParams( const c3d::DoubleVector & toleranceLevels )
: _toleranceLevels( toleranceLevels )
, _triangleCountLevels()
{}
/// \ru Конструктор для задания целевого количества треугольников. \en Constructor for triangles count target. \~
MbMeshSimplificationParams( const c3d::IndicesVector & triangleCountLevels )
: _toleranceLevels()
, _triangleCountLevels( triangleCountLevels )
{}
/// \ru Деструктор. \en Destructor. \~
~MbMeshSimplificationParams() {}
///< \ru Делать ли упрощение до достижения целевого количества треугольников. \en Is target triangles count. \~
bool IsTriangleCountTarget() const { return !_triangleCountLevels.empty(); }
///< \ru Делать ли упрощение до достижения целевой точности. \en Is target tolerance. \~
bool IsToleranceTarget() const { return !_toleranceLevels.empty(); }
///< \ru Получить уровни упрощения для точности. \en Get simplification levels for tolerance. \~
const c3d::DoubleVector & ToleranceLevels() const { return _toleranceLevels; }
///< \ru Получить уровни упрощения для количества треугольников. \en Get simplification levels for triangles count. \~
const c3d::IndicesVector & TrianglesCountLevels() const { return _triangleCountLevels; }
///< \ru Валидны ли параметры? \en Is parameters valid? \~
bool IsValid() const
{
bool isValid = true;
if ( IsTriangleCountTarget() )
{
if ( _triangleCountLevels.size() > 1 )
{
auto valPrev = _triangleCountLevels.front();
for ( size_t i = 1, n = _triangleCountLevels.size(); i < n; ++i )
{
const auto val = _triangleCountLevels[i];
if ( val >= valPrev )
{
isValid = false;
break;
}
valPrev = val;
}
}
}
else if ( IsToleranceTarget() )
{
if ( _toleranceLevels.size() > 1 )
{
auto valPrev = _toleranceLevels.front();
for ( size_t i = 1, n = _toleranceLevels.size(); i < n; ++i )
{
const auto val = _toleranceLevels[i];
if ( val <= valPrev )
{
isValid = false;
break;
}
valPrev = val;
}
}
}
return isValid;
}
OBVIOUS_PRIVATE_COPY( MbMeshSimplificationParams )
};
//------------------------------------------------------------------------------
/** \brief \ru Параметры операции создания выпуклого многоугольника в 2D.
\en Parameters for convex hull 2D creation. \~
\details \ru Параметры операции создания выпуклого многоугольника в 2D.
\en Parameters for convex hull 2D creation. \~
\ingroup Shell_Building_Parameters
*/
// ---
class MATH_CLASS MbConvexHullParams
{
private:
bool _makeGrid; ///< \ru Создавать ли двумерную триангуляцию. \en Should planar grid be created. \~
bool _makeDelaunay; ///< \ru Создавать ли Делоне триангуляцию. \en Should planar grid be Delaunay triangulation. \~
bool _makeContour; ///< \ru Создавать ли двумерный контур. \en Should planar contour be created. \~
double _tolerance; ///< \ru Точность. \en Tolerance. \~
c3d::ParamPointsVector _points; ///< \ru Точки. \en Points. \~
public:
/// \ru Конструктор.. \en Constructor. \~
MbConvexHullParams( const c3d::ParamPointsVector & points, double tolerance, bool makeContour, bool makeGrid, bool makeDelaunay )
: _points ( points )
, _tolerance ( tolerance )
, _makeContour ( makeContour )
, _makeGrid ( makeGrid )
, _makeDelaunay( makeDelaunay )
{}
/// \ru Конструктор.. \en Constructor. \~
MbConvexHullParams( const std::vector<MbFloatPoint> & points, double tolerance, bool makeContour, bool makeGrid, bool makeDelaunay )
: _tolerance ( tolerance )
, _makeContour ( makeContour )
, _makeGrid ( makeGrid )
, _makeDelaunay( makeDelaunay )
{
_points.clear();
_points.reserve( points.size() );
for ( const auto & pt : points )
_points.push_back( MbCartPoint( pt ) );
}
/// \ru Конструктор.. \en Constructor. \~
MbConvexHullParams( const SArray<MbFloatPoint> & points, double tolerance, bool makeContour, bool makeGrid, bool makeDelaunay )
: _tolerance ( tolerance )
, _makeContour ( makeContour )
, _makeGrid ( makeGrid )
, _makeDelaunay( makeDelaunay )
{
_points.clear();
_points.reserve( points.size() );
for ( const auto & pt : points )
_points.push_back( MbCartPoint( pt ) );
}
/// \ru Конструктор.. \en Constructor. \~
MbConvexHullParams( const SArray<MbCartPoint> & points, double tolerance, bool makeContour, bool makeGrid, bool makeDelaunay )
: _tolerance ( tolerance )
, _makeContour ( makeContour )
, _makeGrid ( makeGrid )
, _makeDelaunay( makeDelaunay )
{
_points.clear();
_points.reserve( points.size() );
for ( const auto & pt : points )
_points.push_back( pt );
}
/// \ru Деструктор. \en Destructor. \~
~MbConvexHullParams() {}
///< \ru Создавать ли двумерную триангуляцию. \en Should planar grid be created. \~
bool ShouldMakeGrid() const { return _makeGrid; }
///< \ru Создавать ли Делоне триангуляцию. \en Should planar grid be Delaunay triangulation. \~
bool ShouldMakeDelaunay() const { return _makeDelaunay; }
///< \ru Создавать ли двумерный контур. \en Should planar contour be created. \~
bool ShouldMakeContour() const { return _makeContour; }
///< \ru Получить точность. \en Get tolerance. \~
double GetTolerance() const { return _tolerance; }
///< \ru Получить точки. \en Get points. \~
const c3d::ParamPointsVector & GetPoints() const { return _points; }
OBVIOUS_PRIVATE_COPY( MbConvexHullParams )
};
//------------------------------------------------------------------------------
/** \brief \ru Результаты создания выпуклого многоугольника в 2D.
\en Results of convex hull 2D creating. \~
\details \ru Результаты создания выпуклого многоугольника в 2D.
\en Results of convex hull 2D creating. \~
\ingroup Shell_Building_Parameters
*/
// ---
struct MATH_CLASS MbConvexHullResults
{
public:
c3d::IndicesVector _hullIndices; ///< \ru Индексы точек выпуклого многоугольника. \en Indices of convex hull points. \~
c3d::ParamPointsVector _hull; ///< \ru Выпуклый многоугольник. \en Convex hull. \~
SPtr<MbPlanarGrid> _grid; ///< \ru Точки. \en Points. \~
SPtr<MbContour> _contour; ///< \ru Контур. \en Contour. \~
/// \ru Конструктор.. \en Constructor. \~
MbConvexHullResults()
: _hullIndices()
, _hull()
, _grid()
, _contour()
{}
/// \ru Деструктор. \en Destructor. \~
~MbConvexHullResults() {}
OBVIOUS_PRIVATE_COPY( MbConvexHullResults )
};
//------------------------------------------------------------------------------
/** \brief \ru Параметры операции создания выпуклой оболочки в 3D.
\en Parameters for convex hull 3D creation. \~
\details \ru Параметры операции создания выпуклой оболочки в 3D.
\en Parameters for convex hull 3D creation. \~
\ingroup Shell_Building_Parameters
*/
// ---
class MATH_CLASS MbConvexHullParams3D
{
private:
double _tolerance; ///< \ru Точность. \en Tolerance. \~
c3d::SpacePointsVector _points; ///< \ru Точки. \en Points. \~
public:
/// \ru Конструктор.. \en Constructor. \~
MbConvexHullParams3D( const c3d::SpacePointsVector & points, double tolerance )
: _points ( points )
, _tolerance( tolerance )
{}
/// \ru Конструктор.. \en Constructor. \~
MbConvexHullParams3D( const std::vector<MbFloatPoint3D> & points, double tolerance )
: _tolerance( tolerance )
{
_points.clear();
_points.reserve( points.size() );
for ( const auto & pt : points )
_points.push_back( MbCartPoint3D( pt ) );
}
/// \ru Конструктор.. \en Constructor. \~
MbConvexHullParams3D( const SArray<MbFloatPoint3D> & points, double tolerance )
: _tolerance( tolerance )
{
_points.clear();
_points.reserve( points.size() );
for ( const auto & pt : points )
_points.push_back( MbCartPoint3D( pt ) );
}
/// \ru Конструктор.. \en Constructor. \~
MbConvexHullParams3D( const SArray<MbCartPoint3D> & points, double tolerance )
: _tolerance( tolerance )
{
_points.clear();
_points.reserve( points.size() );
for ( const auto & pt : points )
_points.push_back( pt );
}
/// \ru Деструктор. \en Destructor. \~
~MbConvexHullParams3D() {}
///< \ru Получить точность. \en Get tolerance. \~
double GetTolerance() const { return _tolerance; }
///< \ru Получить точки. \en Get points. \~
const c3d::SpacePointsVector & GetPoints() const { return _points; }
OBVIOUS_PRIVATE_COPY( MbConvexHullParams3D )
};
//------------------------------------------------------------------------------
/** \brief \ru Параметры для поиска и замены повторяющихся полигональных объектов (#MbMesh) на вставки #MbInstance.
\en Parameters for the replacement of repetative meshes (#MbMesh) into #MbInstance. \~
\details \ru Параметры для поиска и замены одинаковых полигональных объектов (#MbMesh) на вставки #MbInstance.
Возможно переключение между абсолютной/относительной точностями сравнения точек. Под относительной
точностью имеется в виду ограничение сверху по каждой координате на abs( (c1 - c2) / (c1 + c2) ). \n
\en Parameters for the replacement of repetative meshes (#MbMesh) into #MbInstance.
It is possible to switch between absolute/relative accuracy for the points comparison. The relative
accuracy is the upper bound of the expression abs( (c1 - c2) / (c1 + c2) ) for each coordinate. \n \~
\ingroup Polygonal_Objects
*/
// ---
class MATH_CLASS MbMeshToInstanceParams : public MbPrecision
{
private:
/// \ru Использовать относительную или абсолютную точность при сравнении точек.\en Use absolute or relative tolerance for points comparison.\~
bool _isAbsoluteAccuracy;
public:
/// \ru Конструктор по-умолчанию. \en Default constructor.\~
MbMeshToInstanceParams ()
: MbPrecision ( )
, _isAbsoluteAccuracy( true )
{}
/// \ru Конструктор. \en Constructor. \~
MbMeshToInstanceParams ( double precision, bool isAbsoluteAccuracy )
: MbPrecision ( precision, ANGLE_REGION )
, _isAbsoluteAccuracy( isAbsoluteAccuracy )
{}
/// \ru Деструктор. \en Destructor. \~
~MbMeshToInstanceParams() {}
/// \ru Переключатель между абсолютной и относительной точностью. \en Switch between absolute and relative accuracy. \~
void SetAbsoluteAccuracy( bool isAbs ) { _isAbsoluteAccuracy = isAbs; }
/// \ru Установлена абсолютная или относительная точность. \en Whether the accuracy is set to absolute or relative. \~
bool IsAbsoluteAccuracy () const { return _isAbsoluteAccuracy; }
OBVIOUS_PRIVATE_COPY( MbMeshToInstanceParams );
};
//------------------------------------------------------------------------------
/** \brief \ru Результаты поиска и замены повторяющихся полигональных объектов (#MbMesh) на вставки #MbInstance.
\en Results of the replacement of repetative meshes (#MbMesh) into #MbInstance. \~
\details \ru Результаты поиска и замены одинаковых полигональных объектов (#MbMesh) на вставки #MbInstance.
Содержат присланный массив, где на месте повторяющихся полигональных объектов расположены вставки. \n
\en Results of the replacement of repetative meshes (#MbMesh) into #MbInstance.
Contain the initial array, where instances replace repeatative meshes.\n \~
\ingroup Polygonal_Objects
*/
// ---
class MATH_CLASS MbMeshToInstanceResults
{
public:
c3d::ItemsSPtrVector _meshContainer; ///< \ru Выходной массив. \en Output array \~
size_t _nReplaced; ///< \ru Число заменённых объектов. \en Number of replaced objects. \~
public:
/// \ru Конструктор. \en Constructor. \~
MbMeshToInstanceResults()
: _nReplaced ( 0 )
{}
/// \ru Деструктор. \en Destructor. \~
~MbMeshToInstanceResults() {}
/// \ru Обнулить. \en Reset. \~
void Reset () { _nReplaced = 0; _meshContainer.clear(); }
OBVIOUS_PRIVATE_COPY( MbMeshToInstanceResults );
};
//------------------------------------------------------------------------------
/** \brief \ru Режим отбраковки выбросов при вписывании поверхности в набор точек.
\en Outliers rejection mode for surface fitting. \~
\ingroup Polygonal_Objects
*/
// ---
enum MbeRejectOutliersType
{
rot_NoReject = 0, ///< \ru Не отбраковывать выбросы. \en No outliers rejection.
rot_Sigma = 1, ///< \ru Отбраковывать выбросы по критерию N*sigma. \en Reject outliers by N*sigma criterion.
rot_Percent = 2, ///< \ru Отбраковывать выбросы по процентному критерию. \en Reject outliers by percent criterion.
rot_MaxDistance = 3 ///< \ru Отбраковывать выбросы по критерию максимального отклонения. \en Reject outliers by maximum distance criterion.
};
//------------------------------------------------------------------------------
/** \brief \ru Базовый класс для параметров вписывания кривых.
\en Base class for curve fitting parameters. \~
\ingroup Polygonal_Objects
*/
// ---
class MATH_CLASS MbCurveFitParametersBase : public MbPrecision
{
public:
/** \brief \ru Тип кривой для вписывания.
\en Type of a curve to be fit. \~
\ingroup Polygonal_Objects
*/
enum MbeCurveFitType
{
cft_Undef = 0, ///< \ru Не определено. \en Undefined.
cft_Line = 1, ///< \ru Прямая. \en Line.
cft_Circle = 2, ///< \ru Окружность. \en Circle.
cft_Ellipse = 3 ///< \ru Эллипс. \en Ellipse.
};
private:
MbeRejectOutliersType _typeReject; ///< \ru Способ отбраковки выбросов. \en Outliers rejection mode.
double _valueReject; ///< \ru Пороговое значения для отбраковки выбросов. \en Outliers rejection mode treshold value.
MbeCurveFitType _curveType; ///< \ru Тип кривой. \en A curve type.
public:
/// \ru Конструктор по параметрам. \en Constructor by parameters.
explicit MbCurveFitParametersBase( double tolerance,
MbeRejectOutliersType typeReject,
double valueReject,
MbeCurveFitType curveType )
: MbPrecision ( tolerance, tolerance )
, _typeReject ( typeReject )
, _valueReject( valueReject )
, _curveType ( curveType )
{}
/// \ru Выдать метод отбраковки выбросов. \en Get outliers rejection mode.
MbeRejectOutliersType GetOutliersRejectionMode() const { return _typeReject; }
/// \ru Выдать пороговое значения для отбраковки выбросов. \en Get outliers rejection mode treshold value.
double GetOutliersRejectionValue() const { return _valueReject; }
/// \ru Выдать тип кривой. \en Get curve type.
MbeCurveFitType GetCurveType() const { return _curveType; }
OBVIOUS_PRIVATE_COPY( MbCurveFitParametersBase )
};
//------------------------------------------------------------------------------
/** \brief \ru Параметры вписывания 2Д кривых.
\en 2D curve fitting parameters. \~
\ingroup Polygonal_Objects
*/
// ---
class MATH_CLASS MbCurveFitParameters : public MbCurveFitParametersBase
{
private:
c3d::ParamPointsVector _points; ///< \ru Точки. \en Points.
public:
/// \ru Конструктор по параметрам. \en Constructor by parameters.
explicit MbCurveFitParameters( MbeCurveFitType curveType,
double tolerance,
MbeRejectOutliersType typeReject,
double valueReject )
: MbCurveFitParametersBase( tolerance, typeReject, valueReject, curveType )
{}
/// \ru Конструктор по параметрам. \en Constructor by parameters.
explicit MbCurveFitParameters( MbeCurveFitType curveType,
double tolerance )
: MbCurveFitParametersBase( tolerance, rot_NoReject, 0., curveType )
{}
/// \ru Установить точки для вписывания. \en Set points to fit in.
void SetPoints( const c3d::ParamPointsVector & points ) { _points = points; }
/// \ru Получить точки для вписывания. \en Get points to fit in.
const c3d::ParamPointsVector & GetPoints() const { return _points; }
OBVIOUS_PRIVATE_COPY( MbCurveFitParameters )
};
//------------------------------------------------------------------------------
/** \brief \ru Параметры вписывания 3Д кривых.
\en 3D curve fitting parameters. \~
\ingroup Polygonal_Objects
*/
// ---
class MATH_CLASS MbCurveFitParameters3D : public MbCurveFitParametersBase
{
private:
c3d::SpacePointsVector _points; ///< \ru Точки. \en Points.
public:
/// \ru Конструктор по параметрам. \en Constructor by parameters.
explicit MbCurveFitParameters3D( MbeCurveFitType curveType,
double tolerance,
MbeRejectOutliersType typeReject,
double valueReject )
: MbCurveFitParametersBase( tolerance, typeReject, valueReject, curveType )
{}
/// \ru Конструктор по параметрам. \en Constructor by parameters.
explicit MbCurveFitParameters3D( MbeCurveFitType curveType,
double tolerance )
: MbCurveFitParametersBase( tolerance, rot_NoReject, 0., curveType )
{}
/// \ru Установить точки для вписывания. \en Set points to fit in.
void SetPoints( const c3d::SpacePointsVector & points ) { _points = points; }
/// \ru Получить точки для вписывания. \en Get points to fit in.
const c3d::SpacePointsVector & GetPoints() const { return _points; }
OBVIOUS_PRIVATE_COPY( MbCurveFitParameters3D )
};
//------------------------------------------------------------------------------
/** \brief \ru Базовый класс для результатов вписывания.
\en Base class for fitting results. \~
\ingroup Polygonal_Objects
*/
// ---
class MATH_CLASS MbFitResultsBase
{
private:
double _devMax; ///< \ru Максимальное получившееся отклонение. \en A maximal deviation.
double _devMean; ///< \ru Среднее получившееся отклонение. \en A mean deviation.
double _rmsd; ///< \ru Среднее квадратическое отклонение. \en A root-mean-square deviation.
public:
/// \ru Конструктор по умолчанию. \en Default constructor.
explicit MbFitResultsBase()
: _devMax ( 0.0 )
, _devMean( 0.0 )
, _rmsd ( 0.0 )
{}
/// \ru Инициализировать данные. \en Initialize data.
void Init( double devMax, double devMean, double rmsd ) {
_devMax = devMax;
_devMean = devMean;
_rmsd = rmsd;
}
/// \ru Выдать максимальное отклонение. \en Get maximal deviation.
double GetTolerance() const { return _devMax; }
/// \ru Выдать среднее отклонение. \en Get mean deviation.
double GetMeanDeviation() const { return _devMean; }
/// \ru Выдать cреднее квадратическое отклонение. \en Get root-mean-square deviation.
double GetRmsd() const { return _rmsd; }
OBVIOUS_PRIVATE_COPY( MbFitResultsBase )
};
//------------------------------------------------------------------------------
/** \brief \ru Результат вписывания 2Д кривой.
\en 2D curve fitting results. \~
\ingroup Polygonal_Objects
*/
// ---
class MATH_CLASS MbCurveFitResults : public MbFitResultsBase
{
private:
SPtr<MbCurve> _curve; ///< \ru Кривая. \en A curve.
public:
/// \ru Конструктор по умолчанию. \en Default constructor.
explicit MbCurveFitResults()
: MbFitResultsBase( )
, _curve ( nullptr )
{}
/// \ru Инициализировать данные. \en Initialize data.
void Init( MbCurve * pCurve, double devMax, double devMean, double rmsd )
{
_curve = pCurve;
MbFitResultsBase::Init( devMax, devMean, rmsd );
}
/// \ru Выдать поверхность. \en Get surface.
SPtr<MbCurve> GetCurve() const { return _curve; }
OBVIOUS_PRIVATE_COPY( MbCurveFitResults )
};
//------------------------------------------------------------------------------
/** \brief \ru Результат вписывания 3Д кривой.
\en 2D curve fitting results. \~
\ingroup Polygonal_Objects
*/
// ---
class MATH_CLASS MbCurveFitResults3D : public MbFitResultsBase
{
private:
SPtr<MbCurve3D> _curve; ///< \ru Кривая. \en A curve.
public:
/// \ru Конструктор по умолчанию. \en Default constructor.
explicit MbCurveFitResults3D()
: MbFitResultsBase()
, _curve( nullptr )
{}
/// \ru Инициализировать данные. \en Initialize data.
void Init( MbCurve3D * pCurve, double devMax, double devMean, double rmsd )
{
_curve = pCurve;
MbFitResultsBase::Init( devMax, devMean, rmsd );
}
/// \ru Выдать поверхность. \en Get surface.
SPtr<MbCurve3D> GetCurve() const { return _curve; }
OBVIOUS_PRIVATE_COPY( MbCurveFitResults3D )
};
//------------------------------------------------------------------------------
/** \brief \ru Параметры развёртки триангуляции на плоскость.
\en Parameter for an unwrapping the mesh on a plane. \~
\details \ru Параметры развёртки триангуляции на плоскость. \n
Параметры содержат информацию о положении развёртки и свойствах материала.
\en Parameter for an unwrapping the mesh on a plane. \n
The parameters contain information about the scan position and material properties. \~
\ingroup Shell_Building_Parameters
\warning \ru В разработке.
\en Under development. \~
*/
// ---
class MATH_CLASS MbMeshUnwrapParams
{
protected:
MbPlacement3D _place; ///< \ru Локальная система координат развернутой поверхности. \en The local coordinate system for result surface. \~
double _coefPoisson; ///< \ru Коэффициент Пуассона материала поверхности. \en The Poisson's ratio of suface material. \~
SPtr<MbMesh> _baseMesh; ///< \ru Базовая триангуляция. \en The base triangulation. \~
SPtr<MbMesh> _remeshedMesh; ///< \ru Ремешированная триангуляция. \en The remeshed triangulation. \~
public:
/** \brief \ru Конструктор по умолчанию.
\en Default constructor. \~
*/
MbMeshUnwrapParams();
/// \ru Конструктор по параметрам. \en Constructor by parameters.
MbMeshUnwrapParams( const MbPlacement3D & place, double poisson = 0.25 );
/// \ru Конструктор копирования. \en Copy-constructor.
MbMeshUnwrapParams( const MbMeshUnwrapParams & that );
/// \ru Деструктор. \en Destructor.
~MbMeshUnwrapParams() {}
public:
/// \ru Оператор присваивания. \en Assignment operator.
MbMeshUnwrapParams & operator = ( const MbMeshUnwrapParams & that );
/// \ru Установить локальную систему координат развернутой поверхности сетки. \en Set local coordinate system for mesh unwrapping. \~
void SetPlacement( const MbPlacement3D & pl ) { _place.Init( pl ); }
// \ru Получить локальную систему координат развернутой поверхности сетки. \en Get local coordinate system for mesh unwrapping. \~
const MbPlacement3D & GetPlacement() const { return _place; }
/// \ru Установить коэффициент Пуассона материала грани. \en Set the Poisson's ratio of face material. \~
void SetPoissonsRatio( double poisson ) { _coefPoisson = poisson; }
/// \ru Получить коэффициент Пуассона материала грани. \en Get the Poisson's ratio of face material. \~
double GetPoissonsRatio() const { return _coefPoisson; }
/// \ru Получить базовую сетку. \en Get the base mesh. \~
const SPtr<MbMesh> & GetBaseMesh() const { return _baseMesh; }
/// \ru Получить ремешированную сетку. \en Get the remeshed mesh. \~
const SPtr<MbMesh> & GetRemeshedMesh() const { return _remeshedMesh; }
/// \ru Преобразовать объект согласно матрице. \en Transform an object according to the matrix.
void Transform( const MbMatrix3D & matr );
/// \ru Сдвинуть объект вдоль вектора. \en Move an object along a vector.
void Move( const MbVector3D & to );
/// \ru Повернуть объект вокруг оси на заданный угол. \en Rotate an object at a given angle around an axis.
void Rotate( const MbAxis3D & axis, double ang );
/// \ru Являются ли объекты равными? \en Determine whether an object is equal?
bool IsSame( const MbMeshUnwrapParams & that, double accuracy ) const;
/// \ru Инициализировать базовую сетку по оболочке. \en Initialize base mesh by shell.
bool InitBaseMesh( const MbFaceShell & shell, const MbStepData & stepData );
/// \ru Инициализировать ремешированную сетку с заданным размером треугольника (если triangleSize < 0, размер будет оценен автоматически). \en Initialize remeshed mesh with defined triangle size. If triangleSize < 0, then it will be estimated automatically.
bool InitRemeshedMesh( double triangleSize, bool bReparam = false );
KNOWN_OBJECTS_RW_REF_OPERATORS( MbMeshUnwrapParams ) // \ru Для работы со ссылками и объектами класса. \en For working with references and objects of the class.
}; // MbMeshUnwrapParams
//------------------------------------------------------------------------------
/** \brief \ru Результат развёртки триангуляции на плоскость.
\en Result of an unwrapping the mesh on a plane. \~
\details \ru Результат развёртки триангуляции на плоскость. \n
\en Result of an unwrapping the mesh on a plane. \n
\ingroup Shell_Building_Parameters
\warning \ru В разработке.
\en Under development. \~
*/
// ---
class MATH_CLASS MbMeshUnwrapResult
{
protected:
MbPlacement3D _place; ///< \ru Локальная система координат развернутой поверхности грани. \en The local coordinate system for result surface. \~
double _coefPoisson; ///< \ru Коэффициент Пуассона материала грани. \en The Poisson's ratio of face material. \~
size_t _idNearest; ///< \ru Индекс ближайшего к началу локальной системы координат треугольника. \en Index of the nearest to the local coordinate system origin triangle. \~
SPtr<MbMesh> _unwrappedMesh; ///< \ru Результат - триангуляция (3Д копия сетки из MbMeshUnwrapParams) с заполненными 2Д параметрами точек на плоскости развертки. \en Result - mesh (3D copy of the mesh from MbMeshUnwrapParams ) with filled 2D parameters on the unwrapped plane. \~
public:
/** \brief \ru Конструктор по умолчанию.
\en Default constructor. \~
*/
MbMeshUnwrapResult();
/// \ru Деструктор. \en Destructor.
~MbMeshUnwrapResult() {}
public:
/// \ru Получить локальную систему координат развернутой поверхности сетки. \en Get local coordinate system for mesh unwrapping. \~
const MbPlacement3D & GetPlacement() const { return _place; }
// \ru Получить коэффициент Пуассона материала грани. \en Get the Poisson's ratio of face material. \~
double GetPoissonsRatio() const { return _coefPoisson; }
/// \ru Получить сетку. \en Get the base mesh. \~
const SPtr<MbMesh> & GetUnwrappedMesh() const { return _unwrappedMesh; }
/// \ru Получить индекс ближайшего треугольника. \en Get the nearest triangle index. \~
size_t GetNearestTriangleId() const { return _idNearest; }
/// \ru Рассчитать плоскую триангуляцию-развертку. \en Calculate the flat unwrapped mesh. \~
void GetFlatUnwrappedMesh( SPtr<MbMesh> & flatMesh ) const;
/// \ru Рассчитать регулярную прямоугольную сетку с заданным размером ячейки. \en Calculate the regular quad mesh with defined cell size. \~
void GetQuadMesh( double cellSize, SPtr<MbMesh> & quadMesh );
/// \ru Получить деформации треугольников. \en Get triangles deformations. \~
void GetTrianglesDeformations( c3d::SpaceVectorsVector & deformations ) const;
/// \ru Получить напряжения треугольников для заданного модуля Юнга. \en Get triangles strains for defined Young modulus. \~
void GetTrianglesStrains( double young, c3d::DoubleVector & strains ) const;
/// \ru Функции для внутреннего использования. \en Functions for internal use. \~
/// \ru Инициализировать по параметрам. \en Initialize by parameters. \~
void InitByParams( const MbMeshUnwrapParams & params );
/// \ru Получить ремешированную сетку. \en Get the remeshed mesh. \~
SPtr<MbMesh> & SetUnwrappedMesh() { return _unwrappedMesh; }
/// \ru Установить индекс ближайшего треугольника. \en Set the nearest triangle index. \~
void SetNearestTriangleId( size_t id ) { _idNearest = id; }
OBVIOUS_PRIVATE_COPY( MbMeshUnwrapResult );
}; // MbMeshUnwrapResult
//------------------------------------------------------------------------------
/** \brief \ru Параметры совмещения объектов.
\en Parameters of object alignment. \~
\details \ru Параметры совмещения объектов.
\en Parameters of object alignment. \~
\warning \ru В разработке.
\en Under development. \~
*/
// ---
class MATH_CLASS MbObjectAlignmentParams
{
private:
size_t _iterationMax; ///< \ru Максимальное количество итераций. \en Maximum iteration count.
public:
/// \ru Конструктор. \en Constructor.
MbObjectAlignmentParams( size_t iterationMax = 10000 ) : _iterationMax( iterationMax ) {}
/// \ru Деструктор. \en Destructor.
~MbObjectAlignmentParams() {}
/// \ru Получить максимальное количество итераций. \en Get the maximum iteration count. \~
size_t GetIterationMax() const { return _iterationMax; }
}; // MbObjectAlignmentParams
#endif // __OP_MESH_PARAMETERS_H
Reference in New Issue View Git Blame Copy Permalink