1239 lines
46 KiB
C++
1239 lines
46 KiB
C++
/***************************************************************************
|
|
* 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 *
|
|
* *
|
|
***************************************************************************/
|
|
|
|
#include "PreCompiled.h"
|
|
|
|
// 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
|
|
|
|
#ifndef _PreComp_
|
|
#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>
|
|
#endif
|
|
|
|
#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();
|
|
}
|