kindred/create
1
1
Fork 0
Code Issues 37 Pull Requests Actions Packages Projects 9 Releases 2 Wiki Activity
Files
0865f5fbbf7287345035db2941a56961cbdbf16b
create/src/Mod/Fem/App/HypothesisPy.cpp
Markus Reitböck 4baa3a5ee7 Fem: use CMake to generate precompiled headers on all platforms 
"Professional CMake" book suggest the following:

"Targets should build successfully with or without compiler support for precompiled headers. It
 should be considered an optimization, not a requirement. In particular, do not explicitly include a
 precompile header (e.g. stdafx.h) in the source code, let CMake force-include an automatically
 generated precompile header on the compiler command line instead. This is more portable across
 the major compilers and is likely to be easier to maintain. It will also avoid warnings being
 generated from certain code checking tools like iwyu (include what you use)."

Therefore, removed the "#include <PreCompiled.h>" from sources, also
there is no need for the "#ifdef _PreComp_" anymore
2025-09-23 00:51:00 +02:00

1236 lines
45 KiB
C++
Raw Blame History

/***************************************************************************
* Copyright (c) 2010 Werner Mayer <wmayer[at]users.sourceforge.net> *
* *
* This file is part of the FreeCAD CAx development system. *
* *
* This library is free software; you can redistribute it and/or *
* modify it under the terms of the GNU Library General Public *
* License as published by the Free Software Foundation; either *
* version 2 of the License, or (at your option) any later version. *
* *
* This library is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU Library General Public License for more details. *
* *
* You should have received a copy of the GNU Library General Public *
* License along with this library; see the file COPYING.LIB. If not, *
* write to the Free Software Foundation, Inc., 59 Temple Place, *
* Suite 330, Boston, MA 02111-1307, USA *
* *
***************************************************************************/
// HypothesisPy.h must be included as first file to avoid compiler warning,
// see: https://forum.freecad.org/viewtopic.php?p=633192#p633192
#include "HypothesisPy.h"
#include <SMESH_Version.h> // needed for SMESH_VERSION_MAJOR
#include <StdMeshers_Arithmetic1D.hxx>
#include <StdMeshers_AutomaticLength.hxx>
#include <StdMeshers_CompositeSegment_1D.hxx>
#include <StdMeshers_Deflection1D.hxx>
#include <StdMeshers_Hexa_3D.hxx>
#include <StdMeshers_LayerDistribution.hxx>
#include <StdMeshers_LengthFromEdges.hxx>
#include <StdMeshers_LocalLength.hxx>
#if SMESH_VERSION_MAJOR <= 9 && SMESH_VERSION_MINOR < 10
#include <StdMeshers_MEFISTO_2D.hxx>
#endif
#include <StdMeshers_MaxElementArea.hxx>
#include <StdMeshers_MaxElementVolume.hxx>
#include <StdMeshers_MaxLength.hxx>
#include <StdMeshers_NotConformAllowed.hxx>
#include <StdMeshers_NumberOfLayers.hxx>
#include <StdMeshers_NumberOfSegments.hxx>
#include <StdMeshers_Prism_3D.hxx>
#include <StdMeshers_ProjectionSource1D.hxx>
#include <StdMeshers_ProjectionSource2D.hxx>
#include <StdMeshers_ProjectionSource3D.hxx>
#include <StdMeshers_Projection_1D.hxx>
#include <StdMeshers_Projection_2D.hxx>
#include <StdMeshers_Projection_3D.hxx>
#include <StdMeshers_QuadranglePreference.hxx>
#include <StdMeshers_Quadrangle_2D.hxx>
#include <StdMeshers_QuadraticMesh.hxx>
#include <StdMeshers_RadialPrism_3D.hxx>
#include <StdMeshers_Regular_1D.hxx>
#include <StdMeshers_SegmentAroundVertex_0D.hxx>
#include <StdMeshers_SegmentLengthAroundVertex.hxx>
#include <StdMeshers_StartEndLength.hxx>
#include <StdMeshers_UseExisting_1D2D.hxx>
#include <sstream>
#include <Base/Interpreter.h>
#include <Mod/Part/App/TopoShapePy.h>
#include "FemMeshPy.h"
using namespace Fem;
HypothesisPy::HypothesisPy(std::shared_ptr<SMESH_Hypothesis> h)
: hyp(h)
{}
HypothesisPy::~HypothesisPy() = default;
// ---------------------------------------------------------------------------
template<class T>
void SMESH_HypothesisPy<T>::init_type(PyObject* module)
{
// you must have overwritten the virtual functions
SMESH_HypothesisPy<T>::behaviors().supportRepr();
SMESH_HypothesisPy<T>::behaviors().supportGetattr();
SMESH_HypothesisPy<T>::behaviors().supportSetattr();
SMESH_HypothesisPy<T>::behaviors().set_tp_new(PyMake);
SMESH_HypothesisPy::add_varargs_method("setLibName",
&SMESH_HypothesisPy<T>::setLibName,
"setLibName(String)");
SMESH_HypothesisPy::add_varargs_method("getLibName",
&SMESH_HypothesisPy<T>::getLibName,
"String getLibName()");
#if SMESH_VERSION_MAJOR < 7
SMESH_HypothesisPy::add_varargs_method("setParameters",
&SMESH_HypothesisPy<T>::setParameters,
"setParameters(String)");
SMESH_HypothesisPy::add_varargs_method("getParameters",
&SMESH_HypothesisPy<T>::getParameters,
"String getParameters()");
SMESH_HypothesisPy::add_varargs_method("setLastParameters",
&SMESH_HypothesisPy<T>::setLastParameters,
"setLastParameters(String)");
SMESH_HypothesisPy::add_varargs_method("getLastParameters",
&SMESH_HypothesisPy<T>::getLastParameters,
"String getLastParameters()");
SMESH_HypothesisPy::add_varargs_method("clearParameters",
&SMESH_HypothesisPy<T>::clearParameters,
"clearParameters()");
#endif
SMESH_HypothesisPy::add_varargs_method("isAuxiliary",
&SMESH_HypothesisPy<T>::isAuxiliary,
"Bool isAuxiliary()");
SMESH_HypothesisPy::add_varargs_method("setParametersByMesh",
&SMESH_HypothesisPy<T>::setParametersByMesh,
"setParametersByMesh(Mesh,Shape)");
Base::Interpreter().addType(SMESH_HypothesisPy<T>::behaviors().type_object(),
module,
SMESH_HypothesisPy<T>::behaviors().getName());
}
template<class T>
SMESH_HypothesisPy<T>::SMESH_HypothesisPy(SMESH_Hypothesis* h)
: hyp(h)
{}
template<class T>
SMESH_HypothesisPy<T>::~SMESH_HypothesisPy() = default;
template<class T>
Py::Object SMESH_HypothesisPy<T>::getattr(const char* name)
{
if (strcmp(name, "this") == 0) {
return Hypothesis(Py::asObject(new HypothesisPy(this->getHypothesis())));
}
return Py::PythonExtension<T>::getattr(name);
}
template<class T>
Py::Object SMESH_HypothesisPy<T>::repr()
{
std::stringstream str;
str << hyp->GetName() << ", " << hyp->GetID();
return Py::String(str.str());
}
template<class T>
Py::Object SMESH_HypothesisPy<T>::setLibName(const Py::Tuple& args)
{
std::string libName = static_cast<std::string>(Py::String(args[0]));
hypothesis<SMESH_Hypothesis>()->SetLibName(libName.c_str());
return Py::None();
}
template<class T>
Py::Object SMESH_HypothesisPy<T>::getLibName(const Py::Tuple& args)
{
if (!PyArg_ParseTuple(args.ptr(), "")) {
throw Py::Exception();
}
return Py::String(hypothesis<SMESH_Hypothesis>()->GetLibName());
}
template<class T>
Py::Object SMESH_HypothesisPy<T>::setParametersByMesh(const Py::Tuple& args)
{
PyObject *mesh, *shape;
if (!PyArg_ParseTuple(args.ptr(),
"O!O!",
&(Fem::FemMeshPy::Type),
&mesh,
&(Part::TopoShapePy::Type),
&shape)) {
throw Py::Exception();
}
Fem::FemMesh* m = static_cast<Fem::FemMeshPy*>(mesh)->getFemMeshPtr();
const TopoDS_Shape& s = static_cast<Part::TopoShapePy*>(shape)->getTopoShapePtr()->getShape();
return Py::Boolean(hypothesis<SMESH_Hypothesis>()->SetParametersByMesh(m->getSMesh(), s));
}
template<class T>
Py::Object SMESH_HypothesisPy<T>::isAuxiliary(const Py::Tuple& args)
{
if (!PyArg_ParseTuple(args.ptr(), "")) {
throw Py::Exception();
}
return Py::Boolean(hypothesis<SMESH_Hypothesis>()->IsAuxiliary());
}
template<class T>
PyObject*
SMESH_HypothesisPy<T>::PyMake(struct _typeobject* /*type*/, PyObject* args, PyObject* /*kwds*/)
{
int hypId;
PyObject* obj;
if (!PyArg_ParseTuple(args, "iO!", &hypId, &(FemMeshPy::Type), &obj)) {
return nullptr;
}
FemMesh* mesh = static_cast<FemMeshPy*>(obj)->getFemMeshPtr();
#if SMESH_VERSION_MAJOR >= 9
return new T(hypId, mesh->getGenerator());
#else
return new T(hypId, 1, mesh->getGenerator());
#endif
}
// ---------------------------------------------------------------------------
void StdMeshers_Arithmetic1DPy::init_type(PyObject* module)
{
behaviors().name("StdMeshers_Arithmetic1D");
behaviors().doc("StdMeshers_Arithmetic1D");
add_varargs_method("setLength", &StdMeshers_Arithmetic1DPy::setLength, "setLength()");
add_varargs_method("getLength", &StdMeshers_Arithmetic1DPy::getLength, "getLength()");
SMESH_HypothesisPyBase::init_type(module);
}
#if SMESH_VERSION_MAJOR >= 9
StdMeshers_Arithmetic1DPy::StdMeshers_Arithmetic1DPy(int hypId, SMESH_Gen* gen)
: SMESH_HypothesisPyBase(new StdMeshers_Arithmetic1D(hypId, gen))
{}
#else
StdMeshers_Arithmetic1DPy::StdMeshers_Arithmetic1DPy(int hypId, int studyId, SMESH_Gen* gen)
: SMESH_HypothesisPyBase(new StdMeshers_Arithmetic1D(hypId, studyId, gen))
{}
#endif
StdMeshers_Arithmetic1DPy::~StdMeshers_Arithmetic1DPy() = default;
Py::Object StdMeshers_Arithmetic1DPy::setLength(const Py::Tuple& args)
{
hypothesis<StdMeshers_Arithmetic1D>()->SetLength((double)Py::Float(args[0]),
(bool)Py::Boolean(args[1]));
return Py::None();
}
Py::Object StdMeshers_Arithmetic1DPy::getLength(const Py::Tuple& args)
{
int start;
if (!PyArg_ParseTuple(args.ptr(), "i", &start)) {
throw Py::Exception();
}
return Py::Float(hypothesis<StdMeshers_Arithmetic1D>()->GetLength(start ? true : false));
}
// ---------------------------------------------------------------------------
void StdMeshers_AutomaticLengthPy::init_type(PyObject* module)
{
behaviors().name("StdMeshers_AutomaticLength");
behaviors().doc("StdMeshers_AutomaticLength");
add_varargs_method("setFineness", &StdMeshers_AutomaticLengthPy::setFineness, "setFineness()");
add_varargs_method("getFineness", &StdMeshers_AutomaticLengthPy::getFineness, "getFineness()");
add_varargs_method("getLength", &StdMeshers_AutomaticLengthPy::getLength, "getLength()");
SMESH_HypothesisPyBase::init_type(module);
}
#if SMESH_VERSION_MAJOR >= 9
StdMeshers_AutomaticLengthPy::StdMeshers_AutomaticLengthPy(int /*hypId*/, SMESH_Gen* /*gen*/)
: SMESH_HypothesisPyBase(0)
{}
#else
StdMeshers_AutomaticLengthPy::StdMeshers_AutomaticLengthPy(int /*hypId*/,
int /*studyId*/,
SMESH_Gen* /*gen*/)
: SMESH_HypothesisPyBase(nullptr)
{}
#endif
StdMeshers_AutomaticLengthPy::~StdMeshers_AutomaticLengthPy() = default;
Py::Object StdMeshers_AutomaticLengthPy::setFineness(const Py::Tuple& args)
{
double fine = (double)Py::Float(args[0]);
hypothesis<StdMeshers_AutomaticLength>()->SetFineness(fine);
return Py::None();
}
Py::Object StdMeshers_AutomaticLengthPy::getFineness(const Py::Tuple& args)
{
if (!PyArg_ParseTuple(args.ptr(), "")) {
throw Py::Exception();
}
return Py::Float(hypothesis<StdMeshers_AutomaticLength>()->GetFineness());
}
namespace Py
{
using FemMesh = ExtensionObject<Fem::FemMeshPy>;
using TopoShape = ExtensionObject<Part::TopoShapePy>;
template<>
bool FemMesh::accepts(PyObject* pyob) const
{
return (pyob && PyObject_TypeCheck(pyob, &(Fem::FemMeshPy::Type)));
}
template<>
bool TopoShape::accepts(PyObject* pyob) const
{
return (pyob && PyObject_TypeCheck(pyob, &(Part::TopoShapePy::Type)));
}
} // namespace Py
Py::Object StdMeshers_AutomaticLengthPy::getLength(const Py::Tuple& args)
{
Py::FemMesh mesh(args[0]);
Py::Object shape_or_double(args[1]);
Fem::FemMesh* m = mesh.extensionObject()->getFemMeshPtr();
if (shape_or_double.type() == Py::Float().type()) {
double len = (double)Py::Float(shape_or_double);
return Py::Float(hypothesis<StdMeshers_AutomaticLength>()->GetLength(m->getSMesh(), len));
}
else {
Py::TopoShape shape(shape_or_double);
const TopoDS_Shape& s = shape.extensionObject()->getTopoShapePtr()->getShape();
return Py::Float(hypothesis<StdMeshers_AutomaticLength>()->GetLength(m->getSMesh(), s));
}
}
// ---------------------------------------------------------------------------
void StdMeshers_NotConformAllowedPy::init_type(PyObject* module)
{
behaviors().name("StdMeshers_NotConformAllowed");
behaviors().doc("StdMeshers_NotConformAllowed");
SMESH_HypothesisPyBase::init_type(module);
}
#if SMESH_VERSION_MAJOR >= 9
StdMeshers_NotConformAllowedPy::StdMeshers_NotConformAllowedPy(int hypId, SMESH_Gen* gen)
: SMESH_HypothesisPyBase(new StdMeshers_NotConformAllowed(hypId, gen))
{}
#else
StdMeshers_NotConformAllowedPy::StdMeshers_NotConformAllowedPy(int hypId,
int studyId,
SMESH_Gen* gen)
: SMESH_HypothesisPyBase(new StdMeshers_NotConformAllowed(hypId, studyId, gen))
{}
#endif
StdMeshers_NotConformAllowedPy::~StdMeshers_NotConformAllowedPy() = default;
// ---------------------------------------------------------------------------
void StdMeshers_MaxLengthPy::init_type(PyObject* module)
{
behaviors().name("StdMeshers_MaxLength");
behaviors().doc("StdMeshers_MaxLength");
add_varargs_method("setLength", &StdMeshers_MaxLengthPy::setLength, "setLength()");
add_varargs_method("getLength", &StdMeshers_MaxLengthPy::getLength, "getLength()");
add_varargs_method("havePreestimatedLength",
&StdMeshers_MaxLengthPy::havePreestimatedLength,
"havePreestimatedLength()");
add_varargs_method("getPreestimatedLength",
&StdMeshers_MaxLengthPy::getPreestimatedLength,
"getPreestimatedLength()");
add_varargs_method("setPreestimatedLength",
&StdMeshers_MaxLengthPy::setPreestimatedLength,
"setPreestimatedLength()");
add_varargs_method("setUsePreestimatedLength",
&StdMeshers_MaxLengthPy::setUsePreestimatedLength,
"setUsePreestimatedLength()");
add_varargs_method("getUsePreestimatedLength",
&StdMeshers_MaxLengthPy::getUsePreestimatedLength,
"getUsePreestimatedLength()");
SMESH_HypothesisPyBase::init_type(module);
}
#if SMESH_VERSION_MAJOR >= 9
StdMeshers_MaxLengthPy::StdMeshers_MaxLengthPy(int hypId, SMESH_Gen* gen)
: SMESH_HypothesisPyBase(new StdMeshers_MaxLength(hypId, gen))
{}
#else
StdMeshers_MaxLengthPy::StdMeshers_MaxLengthPy(int hypId, int studyId, SMESH_Gen* gen)
: SMESH_HypothesisPyBase(new StdMeshers_MaxLength(hypId, studyId, gen))
{}
#endif
StdMeshers_MaxLengthPy::~StdMeshers_MaxLengthPy() = default;
Py::Object StdMeshers_MaxLengthPy::setLength(const Py::Tuple& args)
{
hypothesis<StdMeshers_MaxLength>()->SetLength((double)Py::Float(args[0]));
return Py::None();
}
Py::Object StdMeshers_MaxLengthPy::getLength(const Py::Tuple& args)
{
if (!PyArg_ParseTuple(args.ptr(), "")) {
throw Py::Exception();
}
return Py::Float(hypothesis<StdMeshers_MaxLength>()->GetLength());
}
Py::Object StdMeshers_MaxLengthPy::havePreestimatedLength(const Py::Tuple& args)
{
if (!PyArg_ParseTuple(args.ptr(), "")) {
throw Py::Exception();
}
return Py::Boolean(hypothesis<StdMeshers_MaxLength>()->HavePreestimatedLength());
}
Py::Object StdMeshers_MaxLengthPy::getPreestimatedLength(const Py::Tuple& args)
{
if (!PyArg_ParseTuple(args.ptr(), "")) {
throw Py::Exception();
}
return Py::Float(hypothesis<StdMeshers_MaxLength>()->GetPreestimatedLength());
}
Py::Object StdMeshers_MaxLengthPy::setPreestimatedLength(const Py::Tuple& args)
{
hypothesis<StdMeshers_MaxLength>()->SetPreestimatedLength((double)Py::Float(args[0]));
return Py::None();
}
Py::Object StdMeshers_MaxLengthPy::setUsePreestimatedLength(const Py::Tuple& args)
{
hypothesis<StdMeshers_MaxLength>()->SetUsePreestimatedLength((bool)Py::Boolean(args[0]));
return Py::None();
}
Py::Object StdMeshers_MaxLengthPy::getUsePreestimatedLength(const Py::Tuple& args)
{
if (!PyArg_ParseTuple(args.ptr(), "")) {
throw Py::Exception();
}
return Py::Boolean(hypothesis<StdMeshers_MaxLength>()->GetUsePreestimatedLength());
}
// ---------------------------------------------------------------------------
void StdMeshers_LocalLengthPy::init_type(PyObject* module)
{
behaviors().name("StdMeshers_LocalLength");
behaviors().doc("StdMeshers_LocalLength");
add_varargs_method("setLength", &StdMeshers_LocalLengthPy::setLength, "setLength()");
add_varargs_method("getLength", &StdMeshers_LocalLengthPy::getLength, "getLength()");
add_varargs_method("setPrecision", &StdMeshers_LocalLengthPy::setPrecision, "setPrecision()");
add_varargs_method("getPrecision", &StdMeshers_LocalLengthPy::getPrecision, "getPrecision()");
SMESH_HypothesisPyBase::init_type(module);
}
#if SMESH_VERSION_MAJOR >= 9
StdMeshers_LocalLengthPy::StdMeshers_LocalLengthPy(int hypId, SMESH_Gen* gen)
: SMESH_HypothesisPyBase(new StdMeshers_LocalLength(hypId, gen))
{}
#else
StdMeshers_LocalLengthPy::StdMeshers_LocalLengthPy(int hypId, int studyId, SMESH_Gen* gen)
: SMESH_HypothesisPyBase(new StdMeshers_LocalLength(hypId, studyId, gen))
{}
#endif
StdMeshers_LocalLengthPy::~StdMeshers_LocalLengthPy() = default;
Py::Object StdMeshers_LocalLengthPy::setLength(const Py::Tuple& args)
{
hypothesis<StdMeshers_LocalLength>()->SetLength((double)Py::Float(args[0]));
return Py::None();
}
Py::Object StdMeshers_LocalLengthPy::getLength(const Py::Tuple& args)
{
if (!PyArg_ParseTuple(args.ptr(), "")) {
throw Py::Exception();
}
return Py::Float(hypothesis<StdMeshers_LocalLength>()->GetLength());
}
Py::Object StdMeshers_LocalLengthPy::setPrecision(const Py::Tuple& args)
{
hypothesis<StdMeshers_LocalLength>()->SetPrecision((double)Py::Float(args[0]));
return Py::None();
}
Py::Object StdMeshers_LocalLengthPy::getPrecision(const Py::Tuple& args)
{
if (!PyArg_ParseTuple(args.ptr(), "")) {
throw Py::Exception();
}
return Py::Float(hypothesis<StdMeshers_LocalLength>()->GetPrecision());
}
// ---------------------------------------------------------------------------
void StdMeshers_MaxElementAreaPy::init_type(PyObject* module)
{
behaviors().name("StdMeshers_MaxElementArea");
behaviors().doc("StdMeshers_MaxElementArea");
add_varargs_method("setMaxArea", &StdMeshers_MaxElementAreaPy::setMaxArea, "setMaxArea()");
add_varargs_method("getMaxArea", &StdMeshers_MaxElementAreaPy::getMaxArea, "getMaxArea()");
SMESH_HypothesisPyBase::init_type(module);
}
#if SMESH_VERSION_MAJOR >= 9
StdMeshers_MaxElementAreaPy::StdMeshers_MaxElementAreaPy(int hypId, SMESH_Gen* gen)
: SMESH_HypothesisPyBase(new StdMeshers_MaxElementArea(hypId, gen))
{}
#else
StdMeshers_MaxElementAreaPy::StdMeshers_MaxElementAreaPy(int hypId, int studyId, SMESH_Gen* gen)
: SMESH_HypothesisPyBase(new StdMeshers_MaxElementArea(hypId, studyId, gen))
{}
#endif
StdMeshers_MaxElementAreaPy::~StdMeshers_MaxElementAreaPy() = default;
Py::Object StdMeshers_MaxElementAreaPy::setMaxArea(const Py::Tuple& args)
{
hypothesis<StdMeshers_MaxElementArea>()->SetMaxArea((double)Py::Float(args[0]));
return Py::None();
}
Py::Object StdMeshers_MaxElementAreaPy::getMaxArea(const Py::Tuple& args)
{
if (!PyArg_ParseTuple(args.ptr(), "")) {
throw Py::Exception();
}
return Py::Float(hypothesis<StdMeshers_MaxElementArea>()->GetMaxArea());
}
// ---------------------------------------------------------------------------
void StdMeshers_QuadranglePreferencePy::init_type(PyObject* module)
{
behaviors().name("StdMeshers_QuadranglePreference");
behaviors().doc("StdMeshers_QuadranglePreference");
SMESH_HypothesisPyBase::init_type(module);
}
#if SMESH_VERSION_MAJOR >= 9
StdMeshers_QuadranglePreferencePy::StdMeshers_QuadranglePreferencePy(int hypId, SMESH_Gen* gen)
: SMESH_HypothesisPyBase(new StdMeshers_QuadranglePreference(hypId, gen))
{}
#else
StdMeshers_QuadranglePreferencePy::StdMeshers_QuadranglePreferencePy(int hypId,
int studyId,
SMESH_Gen* gen)
: SMESH_HypothesisPyBase(new StdMeshers_QuadranglePreference(hypId, studyId, gen))
{}
#endif
StdMeshers_QuadranglePreferencePy::~StdMeshers_QuadranglePreferencePy() = default;
// ---------------------------------------------------------------------------
void StdMeshers_Quadrangle_2DPy::init_type(PyObject* module)
{
behaviors().name("StdMeshers_Quadrangle_2D");
behaviors().doc("StdMeshers_Quadrangle_2D");
SMESH_HypothesisPyBase::init_type(module);
}
#if SMESH_VERSION_MAJOR >= 9
StdMeshers_Quadrangle_2DPy::StdMeshers_Quadrangle_2DPy(int hypId, SMESH_Gen* gen)
: SMESH_HypothesisPyBase(new StdMeshers_Quadrangle_2D(hypId, gen))
{}
#else
StdMeshers_Quadrangle_2DPy::StdMeshers_Quadrangle_2DPy(int hypId, int studyId, SMESH_Gen* gen)
: SMESH_HypothesisPyBase(new StdMeshers_Quadrangle_2D(hypId, studyId, gen))
{}
#endif
StdMeshers_Quadrangle_2DPy::~StdMeshers_Quadrangle_2DPy() = default;
// ---------------------------------------------------------------------------
void StdMeshers_Regular_1DPy::init_type(PyObject* module)
{
behaviors().name("StdMeshers_Regular_1D");
behaviors().doc("StdMeshers_Regular_1D");
SMESH_HypothesisPyBase::init_type(module);
}
#if SMESH_VERSION_MAJOR >= 9
StdMeshers_Regular_1DPy::StdMeshers_Regular_1DPy(int hypId, SMESH_Gen* gen)
: SMESH_HypothesisPyBase(new StdMeshers_Regular_1D(hypId, gen))
{}
#else
StdMeshers_Regular_1DPy::StdMeshers_Regular_1DPy(int hypId, int studyId, SMESH_Gen* gen)
: SMESH_HypothesisPyBase(new StdMeshers_Regular_1D(hypId, studyId, gen))
{}
#endif
StdMeshers_Regular_1DPy::~StdMeshers_Regular_1DPy() = default;
// ---------------------------------------------------------------------------
void StdMeshers_UseExisting_1DPy::init_type(PyObject* module)
{
behaviors().name("StdMeshers_UseExisting_1D");
behaviors().doc("StdMeshers_UseExisting_1D");
SMESH_HypothesisPyBase::init_type(module);
}
#if SMESH_VERSION_MAJOR >= 9
StdMeshers_UseExisting_1DPy::StdMeshers_UseExisting_1DPy(int hypId, SMESH_Gen* gen)
: SMESH_HypothesisPyBase(new StdMeshers_UseExisting_1D(hypId, gen))
{}
#else
StdMeshers_UseExisting_1DPy::StdMeshers_UseExisting_1DPy(int hypId, int studyId, SMESH_Gen* gen)
: SMESH_HypothesisPyBase(new StdMeshers_UseExisting_1D(hypId, studyId, gen))
{}
#endif
StdMeshers_UseExisting_1DPy::~StdMeshers_UseExisting_1DPy() = default;
// ---------------------------------------------------------------------------
void StdMeshers_UseExisting_2DPy::init_type(PyObject* module)
{
behaviors().name("StdMeshers_UseExisting_2D");
behaviors().doc("StdMeshers_UseExisting_2D");
SMESH_HypothesisPyBase::init_type(module);
}
#if SMESH_VERSION_MAJOR >= 9
StdMeshers_UseExisting_2DPy::StdMeshers_UseExisting_2DPy(int hypId, SMESH_Gen* gen)
: SMESH_HypothesisPyBase(new StdMeshers_UseExisting_2D(hypId, gen))
{}
#else
StdMeshers_UseExisting_2DPy::StdMeshers_UseExisting_2DPy(int hypId, int studyId, SMESH_Gen* gen)
: SMESH_HypothesisPyBase(new StdMeshers_UseExisting_2D(hypId, studyId, gen))
{}
#endif
StdMeshers_UseExisting_2DPy::~StdMeshers_UseExisting_2DPy() = default;
// ---------------------------------------------------------------------------
void StdMeshers_CompositeSegment_1DPy::init_type(PyObject* module)
{
behaviors().name("StdMeshers_CompositeSegment_1D");
behaviors().doc("StdMeshers_CompositeSegment_1D");
SMESH_HypothesisPyBase::init_type(module);
}
#if SMESH_VERSION_MAJOR >= 9
StdMeshers_CompositeSegment_1DPy::StdMeshers_CompositeSegment_1DPy(int hypId, SMESH_Gen* gen)
: SMESH_HypothesisPyBase(new StdMeshers_CompositeSegment_1D(hypId, gen))
{}
#else
StdMeshers_CompositeSegment_1DPy::StdMeshers_CompositeSegment_1DPy(int hypId,
int studyId,
SMESH_Gen* gen)
: SMESH_HypothesisPyBase(new StdMeshers_CompositeSegment_1D(hypId, studyId, gen))
{}
#endif
StdMeshers_CompositeSegment_1DPy::~StdMeshers_CompositeSegment_1DPy() = default;
// ---------------------------------------------------------------------------
void StdMeshers_Deflection1DPy::init_type(PyObject* module)
{
behaviors().name("StdMeshers_Deflection1D");
behaviors().doc("StdMeshers_Deflection1D");
add_varargs_method("setDeflection",
&StdMeshers_Deflection1DPy::setDeflection,
"setDeflection()");
SMESH_HypothesisPyBase::init_type(module);
}
#if SMESH_VERSION_MAJOR >= 9
StdMeshers_Deflection1DPy::StdMeshers_Deflection1DPy(int hypId, SMESH_Gen* gen)
: SMESH_HypothesisPyBase(new StdMeshers_Deflection1D(hypId, gen))
{}
#else
StdMeshers_Deflection1DPy::StdMeshers_Deflection1DPy(int hypId, int studyId, SMESH_Gen* gen)
: SMESH_HypothesisPyBase(new StdMeshers_Deflection1D(hypId, studyId, gen))
{}
#endif
StdMeshers_Deflection1DPy::~StdMeshers_Deflection1DPy() = default;
Py::Object StdMeshers_Deflection1DPy::setDeflection(const Py::Tuple& args)
{
double fine = (double)Py::Float(args[0]);
hypothesis<StdMeshers_Deflection1D>()->SetDeflection(fine);
return Py::None();
}
// ---------------------------------------------------------------------------
void StdMeshers_Hexa_3DPy::init_type(PyObject* module)
{
behaviors().name("StdMeshers_Hexa_3D");
behaviors().doc("StdMeshers_Hexa_3D");
SMESH_HypothesisPyBase::init_type(module);
}
#if SMESH_VERSION_MAJOR >= 9
StdMeshers_Hexa_3DPy::StdMeshers_Hexa_3DPy(int hypId, SMESH_Gen* gen)
: SMESH_HypothesisPyBase(new StdMeshers_Hexa_3D(hypId, gen))
{}
#else
StdMeshers_Hexa_3DPy::StdMeshers_Hexa_3DPy(int hypId, int studyId, SMESH_Gen* gen)
: SMESH_HypothesisPyBase(new StdMeshers_Hexa_3D(hypId, studyId, gen))
{}
#endif
StdMeshers_Hexa_3DPy::~StdMeshers_Hexa_3DPy() = default;
// ---------------------------------------------------------------------------
void StdMeshers_StartEndLengthPy::init_type(PyObject* module)
{
behaviors().name("StdMeshers_StartEndLength");
behaviors().doc("StdMeshers_StartEndLength");
add_varargs_method("setLength", &StdMeshers_StartEndLengthPy::setLength, "setLength()");
add_varargs_method("getLength", &StdMeshers_StartEndLengthPy::getLength, "getLength()");
SMESH_HypothesisPyBase::init_type(module);
}
#if SMESH_VERSION_MAJOR >= 9
StdMeshers_StartEndLengthPy::StdMeshers_StartEndLengthPy(int hypId, SMESH_Gen* gen)
: SMESH_HypothesisPyBase(new StdMeshers_StartEndLength(hypId, gen))
{}
#else
StdMeshers_StartEndLengthPy::StdMeshers_StartEndLengthPy(int hypId, int studyId, SMESH_Gen* gen)
: SMESH_HypothesisPyBase(new StdMeshers_StartEndLength(hypId, studyId, gen))
{}
#endif
StdMeshers_StartEndLengthPy::~StdMeshers_StartEndLengthPy() = default;
Py::Object StdMeshers_StartEndLengthPy::setLength(const Py::Tuple& args)
{
hypothesis<StdMeshers_StartEndLength>()->SetLength((double)Py::Float(args[0]),
(bool)Py::Boolean(args[1]));
return Py::None();
}
Py::Object StdMeshers_StartEndLengthPy::getLength(const Py::Tuple& args)
{
return Py::Float(
hypothesis<StdMeshers_StartEndLength>()->GetLength((bool)Py::Boolean(args[0])));
}
// ---------------------------------------------------------------------------
void StdMeshers_SegmentLengthAroundVertexPy::init_type(PyObject* module)
{
behaviors().name("StdMeshers_SegmentLengthAroundVertex");
behaviors().doc("StdMeshers_SegmentLengthAroundVertex");
add_varargs_method("setLength",
&StdMeshers_SegmentLengthAroundVertexPy::setLength,
"setLength()");
add_varargs_method("getLength",
&StdMeshers_SegmentLengthAroundVertexPy::getLength,
"getLength()");
SMESH_HypothesisPyBase::init_type(module);
}
#if SMESH_VERSION_MAJOR >= 9
StdMeshers_SegmentLengthAroundVertexPy::StdMeshers_SegmentLengthAroundVertexPy(int hypId,
SMESH_Gen* gen)
: SMESH_HypothesisPyBase(new StdMeshers_SegmentLengthAroundVertex(hypId, gen))
{}
#else
StdMeshers_SegmentLengthAroundVertexPy::StdMeshers_SegmentLengthAroundVertexPy(int hypId,
int studyId,
SMESH_Gen* gen)
: SMESH_HypothesisPyBase(new StdMeshers_SegmentLengthAroundVertex(hypId, studyId, gen))
{}
#endif
StdMeshers_SegmentLengthAroundVertexPy::~StdMeshers_SegmentLengthAroundVertexPy() = default;
Py::Object StdMeshers_SegmentLengthAroundVertexPy::setLength(const Py::Tuple& args)
{
hypothesis<StdMeshers_SegmentLengthAroundVertex>()->SetLength((double)Py::Float(args[0]));
return Py::None();
}
Py::Object StdMeshers_SegmentLengthAroundVertexPy::getLength(const Py::Tuple& args)
{
if (!PyArg_ParseTuple(args.ptr(), "")) {
throw Py::Exception();
}
return Py::Float(hypothesis<StdMeshers_SegmentLengthAroundVertex>()->GetLength());
}
// ---------------------------------------------------------------------------
void StdMeshers_SegmentAroundVertex_0DPy::init_type(PyObject* module)
{
behaviors().name("StdMeshers_SegmentAroundVertex_0D");
behaviors().doc("StdMeshers_SegmentAroundVertex_0D");
SMESH_HypothesisPyBase::init_type(module);
}
#if SMESH_VERSION_MAJOR >= 9
StdMeshers_SegmentAroundVertex_0DPy::StdMeshers_SegmentAroundVertex_0DPy(int hypId, SMESH_Gen* gen)
: SMESH_HypothesisPyBase(new StdMeshers_SegmentAroundVertex_0D(hypId, gen))
{}
#else
StdMeshers_SegmentAroundVertex_0DPy::StdMeshers_SegmentAroundVertex_0DPy(int hypId,
int studyId,
SMESH_Gen* gen)
: SMESH_HypothesisPyBase(new StdMeshers_SegmentAroundVertex_0D(hypId, studyId, gen))
{}
#endif
StdMeshers_SegmentAroundVertex_0DPy::~StdMeshers_SegmentAroundVertex_0DPy() = default;
// ---------------------------------------------------------------------------
void StdMeshers_RadialPrism_3DPy::init_type(PyObject* module)
{
behaviors().name("StdMeshers_RadialPrism_3D");
behaviors().doc("StdMeshers_RadialPrism_3D");
SMESH_HypothesisPyBase::init_type(module);
}
#if SMESH_VERSION_MAJOR >= 9
StdMeshers_RadialPrism_3DPy::StdMeshers_RadialPrism_3DPy(int hypId, SMESH_Gen* gen)
: SMESH_HypothesisPyBase(new StdMeshers_RadialPrism_3D(hypId, gen))
{}
#else
StdMeshers_RadialPrism_3DPy::StdMeshers_RadialPrism_3DPy(int hypId, int studyId, SMESH_Gen* gen)
: SMESH_HypothesisPyBase(new StdMeshers_RadialPrism_3D(hypId, studyId, gen))
{}
#endif
StdMeshers_RadialPrism_3DPy::~StdMeshers_RadialPrism_3DPy() = default;
// ---------------------------------------------------------------------------
void StdMeshers_QuadraticMeshPy::init_type(PyObject* module)
{
behaviors().name("StdMeshers_QuadraticMesh");
behaviors().doc("StdMeshers_QuadraticMesh");
SMESH_HypothesisPyBase::init_type(module);
}
#if SMESH_VERSION_MAJOR >= 9
StdMeshers_QuadraticMeshPy::StdMeshers_QuadraticMeshPy(int hypId, SMESH_Gen* gen)
: SMESH_HypothesisPyBase(new StdMeshers_QuadraticMesh(hypId, gen))
{}
#else
StdMeshers_QuadraticMeshPy::StdMeshers_QuadraticMeshPy(int hypId, int studyId, SMESH_Gen* gen)
: SMESH_HypothesisPyBase(new StdMeshers_QuadraticMesh(hypId, studyId, gen))
{}
#endif
StdMeshers_QuadraticMeshPy::~StdMeshers_QuadraticMeshPy() = default;
// ---------------------------------------------------------------------------
void StdMeshers_ProjectionSource3DPy::init_type(PyObject* module)
{
behaviors().name("StdMeshers_ProjectionSource3D");
behaviors().doc("StdMeshers_ProjectionSource3D");
SMESH_HypothesisPyBase::init_type(module);
}
#if SMESH_VERSION_MAJOR >= 9
StdMeshers_ProjectionSource3DPy::StdMeshers_ProjectionSource3DPy(int hypId, SMESH_Gen* gen)
: SMESH_HypothesisPyBase(new StdMeshers_ProjectionSource3D(hypId, gen))
{}
#else
StdMeshers_ProjectionSource3DPy::StdMeshers_ProjectionSource3DPy(int hypId,
int studyId,
SMESH_Gen* gen)
: SMESH_HypothesisPyBase(new StdMeshers_ProjectionSource3D(hypId, studyId, gen))
{}
#endif
StdMeshers_ProjectionSource3DPy::~StdMeshers_ProjectionSource3DPy() = default;
// ---------------------------------------------------------------------------
void StdMeshers_ProjectionSource2DPy::init_type(PyObject* module)
{
behaviors().name("StdMeshers_ProjectionSource2D");
behaviors().doc("StdMeshers_ProjectionSource2D");
SMESH_HypothesisPyBase::init_type(module);
}
#if SMESH_VERSION_MAJOR >= 9
StdMeshers_ProjectionSource2DPy::StdMeshers_ProjectionSource2DPy(int hypId, SMESH_Gen* gen)
: SMESH_HypothesisPyBase(new StdMeshers_ProjectionSource2D(hypId, gen))
{}
#else
StdMeshers_ProjectionSource2DPy::StdMeshers_ProjectionSource2DPy(int hypId,
int studyId,
SMESH_Gen* gen)
: SMESH_HypothesisPyBase(new StdMeshers_ProjectionSource2D(hypId, studyId, gen))
{}
#endif
StdMeshers_ProjectionSource2DPy::~StdMeshers_ProjectionSource2DPy() = default;
// ---------------------------------------------------------------------------
void StdMeshers_ProjectionSource1DPy::init_type(PyObject* module)
{
behaviors().name("StdMeshers_ProjectionSource1D");
behaviors().doc("StdMeshers_ProjectionSource1D");
SMESH_HypothesisPyBase::init_type(module);
}
#if SMESH_VERSION_MAJOR >= 9
StdMeshers_ProjectionSource1DPy::StdMeshers_ProjectionSource1DPy(int hypId, SMESH_Gen* gen)
: SMESH_HypothesisPyBase(new StdMeshers_ProjectionSource1D(hypId, gen))
{}
#else
StdMeshers_ProjectionSource1DPy::StdMeshers_ProjectionSource1DPy(int hypId,
int studyId,
SMESH_Gen* gen)
: SMESH_HypothesisPyBase(new StdMeshers_ProjectionSource1D(hypId, studyId, gen))
{}
#endif
StdMeshers_ProjectionSource1DPy::~StdMeshers_ProjectionSource1DPy() = default;
// ---------------------------------------------------------------------------
void StdMeshers_Projection_3DPy::init_type(PyObject* module)
{
behaviors().name("StdMeshers_Projection_3D");
behaviors().doc("StdMeshers_Projection_3D");
SMESH_HypothesisPyBase::init_type(module);
}
#if SMESH_VERSION_MAJOR >= 9
StdMeshers_Projection_3DPy::StdMeshers_Projection_3DPy(int hypId, SMESH_Gen* gen)
: SMESH_HypothesisPyBase(new StdMeshers_Projection_3D(hypId, gen))
{}
#else
StdMeshers_Projection_3DPy::StdMeshers_Projection_3DPy(int hypId, int studyId, SMESH_Gen* gen)
: SMESH_HypothesisPyBase(new StdMeshers_Projection_3D(hypId, studyId, gen))
{}
#endif
StdMeshers_Projection_3DPy::~StdMeshers_Projection_3DPy() = default;
// ---------------------------------------------------------------------------
void StdMeshers_Projection_2DPy::init_type(PyObject* module)
{
behaviors().name("StdMeshers_Projection_2D");
behaviors().doc("StdMeshers_Projection_2D");
SMESH_HypothesisPyBase::init_type(module);
}
#if SMESH_VERSION_MAJOR >= 9
StdMeshers_Projection_2DPy::StdMeshers_Projection_2DPy(int hypId, SMESH_Gen* gen)
: SMESH_HypothesisPyBase(new StdMeshers_Projection_2D(hypId, gen))
{}
#else
StdMeshers_Projection_2DPy::StdMeshers_Projection_2DPy(int hypId, int studyId, SMESH_Gen* gen)
: SMESH_HypothesisPyBase(new StdMeshers_Projection_2D(hypId, studyId, gen))
{}
#endif
StdMeshers_Projection_2DPy::~StdMeshers_Projection_2DPy() = default;
// ---------------------------------------------------------------------------
void StdMeshers_Projection_1DPy::init_type(PyObject* module)
{
behaviors().name("StdMeshers_Projection_1D");
behaviors().doc("StdMeshers_Projection_1D");
SMESH_HypothesisPyBase::init_type(module);
}
#if SMESH_VERSION_MAJOR >= 9
StdMeshers_Projection_1DPy::StdMeshers_Projection_1DPy(int hypId, SMESH_Gen* gen)
: SMESH_HypothesisPyBase(new StdMeshers_Projection_1D(hypId, gen))
{}
#else
StdMeshers_Projection_1DPy::StdMeshers_Projection_1DPy(int hypId, int studyId, SMESH_Gen* gen)
: SMESH_HypothesisPyBase(new StdMeshers_Projection_1D(hypId, studyId, gen))
{}
#endif
StdMeshers_Projection_1DPy::~StdMeshers_Projection_1DPy() = default;
// ---------------------------------------------------------------------------
void StdMeshers_Prism_3DPy::init_type(PyObject* module)
{
behaviors().name("StdMeshers_Prism_3D");
behaviors().doc("StdMeshers_Prism_3D");
SMESH_HypothesisPyBase::init_type(module);
}
#if SMESH_VERSION_MAJOR >= 9
StdMeshers_Prism_3DPy::StdMeshers_Prism_3DPy(int hypId, SMESH_Gen* gen)
: SMESH_HypothesisPyBase(new StdMeshers_Prism_3D(hypId, gen))
{}
#else
StdMeshers_Prism_3DPy::StdMeshers_Prism_3DPy(int hypId, int studyId, SMESH_Gen* gen)
: SMESH_HypothesisPyBase(new StdMeshers_Prism_3D(hypId, studyId, gen))
{}
#endif
StdMeshers_Prism_3DPy::~StdMeshers_Prism_3DPy() = default;
// ---------------------------------------------------------------------------
void StdMeshers_NumberOfSegmentsPy::init_type(PyObject* module)
{
behaviors().name("StdMeshers_NumberOfSegments");
behaviors().doc("StdMeshers_NumberOfSegments");
add_varargs_method("setNumberOfSegments",
&StdMeshers_NumberOfSegmentsPy::setNumSegm,
"setNumberOfSegments()");
add_varargs_method("getNumberOfSegments",
&StdMeshers_NumberOfSegmentsPy::getNumSegm,
"getNumberOfSegments()");
SMESH_HypothesisPyBase::init_type(module);
}
#if SMESH_VERSION_MAJOR >= 9
StdMeshers_NumberOfSegmentsPy::StdMeshers_NumberOfSegmentsPy(int hypId, SMESH_Gen* gen)
: SMESH_HypothesisPyBase(new StdMeshers_NumberOfSegments(hypId, gen))
{}
#else
StdMeshers_NumberOfSegmentsPy::StdMeshers_NumberOfSegmentsPy(int hypId, int studyId, SMESH_Gen* gen)
: SMESH_HypothesisPyBase(new StdMeshers_NumberOfSegments(hypId, studyId, gen))
{}
#endif
StdMeshers_NumberOfSegmentsPy::~StdMeshers_NumberOfSegmentsPy() = default;
Py::Object StdMeshers_NumberOfSegmentsPy::setNumSegm(const Py::Tuple& args)
{
hypothesis<StdMeshers_NumberOfSegments>()->SetNumberOfSegments((int)Py::Long(args[0]));
return Py::None();
}
Py::Object StdMeshers_NumberOfSegmentsPy::getNumSegm(const Py::Tuple& args)
{
if (!PyArg_ParseTuple(args.ptr(), "")) {
throw Py::Exception();
}
return Py::Long(hypothesis<StdMeshers_NumberOfSegments>()->GetNumberOfSegments());
}
// ---------------------------------------------------------------------------
void StdMeshers_NumberOfLayersPy::init_type(PyObject* module)
{
behaviors().name("StdMeshers_NumberOfLayers");
behaviors().doc("StdMeshers_NumberOfLayers");
add_varargs_method("setNumberOfLayers",
&StdMeshers_NumberOfLayersPy::setNumLayers,
"setNumberOfLayers()");
add_varargs_method("getNumberOfLayers",
&StdMeshers_NumberOfLayersPy::getNumLayers,
"getNumberOfLayers()");
SMESH_HypothesisPyBase::init_type(module);
}
#if SMESH_VERSION_MAJOR >= 9
StdMeshers_NumberOfLayersPy::StdMeshers_NumberOfLayersPy(int hypId, SMESH_Gen* gen)
: SMESH_HypothesisPyBase(new StdMeshers_NumberOfLayers(hypId, gen))
{}
#else
StdMeshers_NumberOfLayersPy::StdMeshers_NumberOfLayersPy(int hypId, int studyId, SMESH_Gen* gen)
: SMESH_HypothesisPyBase(new StdMeshers_NumberOfLayers(hypId, studyId, gen))
{}
#endif
StdMeshers_NumberOfLayersPy::~StdMeshers_NumberOfLayersPy() = default;
Py::Object StdMeshers_NumberOfLayersPy::setNumLayers(const Py::Tuple& args)
{
hypothesis<StdMeshers_NumberOfLayers>()->SetNumberOfLayers((int)Py::Long(args[0]));
return Py::None();
}
Py::Object StdMeshers_NumberOfLayersPy::getNumLayers(const Py::Tuple& args)
{
if (!PyArg_ParseTuple(args.ptr(), "")) {
throw Py::Exception();
}
return Py::Long(hypothesis<StdMeshers_NumberOfLayers>()->GetNumberOfLayers());
}
// ---------------------------------------------------------------------------
#if SMESH_VERSION_MAJOR <= 9 && SMESH_VERSION_MINOR < 10
void StdMeshers_MEFISTO_2DPy::init_type(PyObject* module)
{
behaviors().name("StdMeshers_MEFISTO_2D");
behaviors().doc("StdMeshers_MEFISTO_2D");
SMESH_HypothesisPyBase::init_type(module);
}
#if SMESH_VERSION_MAJOR >= 9
StdMeshers_MEFISTO_2DPy::StdMeshers_MEFISTO_2DPy(int hypId, SMESH_Gen* gen)
: SMESH_HypothesisPyBase(new StdMeshers_MEFISTO_2D(hypId, gen))
{}
#else
StdMeshers_MEFISTO_2DPy::StdMeshers_MEFISTO_2DPy(int hypId, int studyId, SMESH_Gen* gen)
: SMESH_HypothesisPyBase(new StdMeshers_MEFISTO_2D(hypId, studyId, gen))
{}
#endif
StdMeshers_MEFISTO_2DPy::~StdMeshers_MEFISTO_2DPy() = default;
#endif
// ---------------------------------------------------------------------------
void StdMeshers_MaxElementVolumePy::init_type(PyObject* module)
{
behaviors().name("StdMeshers_MaxElementVolume");
behaviors().doc("StdMeshers_MaxElementVolume");
add_varargs_method("setMaxVolume",
&StdMeshers_MaxElementVolumePy::setMaxVolume,
"setMaxVolume()");
add_varargs_method("getMaxVolume",
&StdMeshers_MaxElementVolumePy::getMaxVolume,
"getMaxVolume()");
SMESH_HypothesisPyBase::init_type(module);
}
#if SMESH_VERSION_MAJOR >= 9
StdMeshers_MaxElementVolumePy::StdMeshers_MaxElementVolumePy(int hypId, SMESH_Gen* gen)
: SMESH_HypothesisPyBase(new StdMeshers_MaxElementVolume(hypId, gen))
{}
#else
StdMeshers_MaxElementVolumePy::StdMeshers_MaxElementVolumePy(int hypId, int studyId, SMESH_Gen* gen)
: SMESH_HypothesisPyBase(new StdMeshers_MaxElementVolume(hypId, studyId, gen))
{}
#endif
StdMeshers_MaxElementVolumePy::~StdMeshers_MaxElementVolumePy() = default;
Py::Object StdMeshers_MaxElementVolumePy::setMaxVolume(const Py::Tuple& args)
{
hypothesis<StdMeshers_MaxElementVolume>()->SetMaxVolume((double)Py::Float(args[0]));
return Py::None();
}
Py::Object StdMeshers_MaxElementVolumePy::getMaxVolume(const Py::Tuple& args)
{
if (!PyArg_ParseTuple(args.ptr(), "")) {
throw Py::Exception();
}
return Py::Float(hypothesis<StdMeshers_MaxElementVolume>()->GetMaxVolume());
}
// ---------------------------------------------------------------------------
void StdMeshers_LengthFromEdgesPy::init_type(PyObject* module)
{
behaviors().name("StdMeshers_LengthFromEdges");
behaviors().doc("StdMeshers_LengthFromEdges");
add_varargs_method("setMode", &StdMeshers_LengthFromEdgesPy::setMode, "setMode()");
add_varargs_method("getMode", &StdMeshers_LengthFromEdgesPy::getMode, "getMode()");
SMESH_HypothesisPyBase::init_type(module);
}
#if SMESH_VERSION_MAJOR >= 9
StdMeshers_LengthFromEdgesPy::StdMeshers_LengthFromEdgesPy(int hypId, SMESH_Gen* gen)
: SMESH_HypothesisPyBase(new StdMeshers_LengthFromEdges(hypId, gen))
{}
#else
StdMeshers_LengthFromEdgesPy::StdMeshers_LengthFromEdgesPy(int hypId, int studyId, SMESH_Gen* gen)
: SMESH_HypothesisPyBase(new StdMeshers_LengthFromEdges(hypId, studyId, gen))
{}
#endif
StdMeshers_LengthFromEdgesPy::~StdMeshers_LengthFromEdgesPy() = default;
Py::Object StdMeshers_LengthFromEdgesPy::setMode(const Py::Tuple& args)
{
hypothesis<StdMeshers_LengthFromEdges>()->SetMode((int)Py::Long(args[0]));
return Py::None();
}
Py::Object StdMeshers_LengthFromEdgesPy::getMode(const Py::Tuple& args)
{
if (!PyArg_ParseTuple(args.ptr(), "")) {
throw Py::Exception();
}
return Py::Long(hypothesis<StdMeshers_LengthFromEdges>()->GetMode());
}
// ---------------------------------------------------------------------------
void StdMeshers_LayerDistributionPy::init_type(PyObject* module)
{
behaviors().name("StdMeshers_LayerDistribution");
behaviors().doc("StdMeshers_LayerDistribution");
add_varargs_method("setLayerDistribution",
&StdMeshers_LayerDistributionPy::setLayerDistribution,
"setLayerDistribution()");
add_varargs_method("getLayerDistribution",
&StdMeshers_LayerDistributionPy::getLayerDistribution,
"getLayerDistribution()");
SMESH_HypothesisPyBase::init_type(module);
}
#if SMESH_VERSION_MAJOR >= 9
StdMeshers_LayerDistributionPy::StdMeshers_LayerDistributionPy(int hypId, SMESH_Gen* gen)
: SMESH_HypothesisPyBase(new StdMeshers_LayerDistribution(hypId, gen))
{}
#else
StdMeshers_LayerDistributionPy::StdMeshers_LayerDistributionPy(int hypId,
int studyId,
SMESH_Gen* gen)
: SMESH_HypothesisPyBase(new StdMeshers_LayerDistribution(hypId, studyId, gen))
{}
#endif
StdMeshers_LayerDistributionPy::~StdMeshers_LayerDistributionPy() = default;
Py::Object StdMeshers_LayerDistributionPy::setLayerDistribution(const Py::Tuple& args)
{
if (!PyArg_ParseTuple(args.ptr(), "")) {
throw Py::Exception();
}
return Py::None();
}
Py::Object StdMeshers_LayerDistributionPy::getLayerDistribution(const Py::Tuple& args)
{
if (!PyArg_ParseTuple(args.ptr(), "")) {
throw Py::Exception();
}
return Py::None();
}
Reference in New Issue View Git Blame Copy Permalink