kindred/create
1
1
Fork 0
Code Issues 44 Pull Requests Actions Packages Projects 9 Releases 2 Wiki Activity
Files
6abb2b447f26e2861614ec4e9c2d3ba51e26336c
create/src/Mod/Mesh/App/MeshProperties.cpp
pre-commit-ci[bot] 25c3ba7338 All: Reformat according to new standard
2025-11-11 13:49:01 +01:00

950 lines
28 KiB
C++
Raw Blame History

// SPDX-License-Identifier: LGPL-2.1-or-later
/***************************************************************************
* Copyright (c) Jürgen Riegel <juergen.riegel@web.de> *
* *
* 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 <Base/Converter.h>
#include <Base/Exception.h>
#include <Base/Reader.h>
#include <Base/Stream.h>
#include <Base/VectorPy.h>
#include <Base/Writer.h>
#include "Core/Iterator.h"
#include "Core/MeshKernel.h"
#include "Core/MeshIO.h"
#include "MeshProperties.h"
#include "Mesh.h"
#include "MeshPy.h"
using namespace Mesh;
TYPESYSTEM_SOURCE(Mesh::PropertyNormalList, App::PropertyLists)
TYPESYSTEM_SOURCE(Mesh::PropertyCurvatureList, App::PropertyLists)
TYPESYSTEM_SOURCE(Mesh::PropertyMaterial, App::Property)
TYPESYSTEM_SOURCE(Mesh::PropertyMeshKernel, App::PropertyComplexGeoData)
PropertyNormalList::PropertyNormalList() = default;
void PropertyNormalList::setSize(int newSize)
{
_lValueList.resize(newSize);
}
int PropertyNormalList::getSize() const
{
return static_cast<int>(_lValueList.size());
}
void PropertyNormalList::setValue(const Base::Vector3f& lValue)
{
aboutToSetValue();
_lValueList.resize(1);
_lValueList[0] = lValue;
hasSetValue();
}
void PropertyNormalList::setValue(float x, float y, float z)
{
aboutToSetValue();
_lValueList.resize(1);
_lValueList[0].Set(x, y, z);
hasSetValue();
}
void PropertyNormalList::setValues(const std::vector<Base::Vector3f>& values)
{
aboutToSetValue();
_lValueList = values;
hasSetValue();
}
PyObject* PropertyNormalList::getPyObject()
{
PyObject* list = PyList_New(getSize());
for (int i = 0; i < getSize(); i++) {
PyList_SetItem(list, i, new Base::VectorPy(_lValueList[i]));
}
return list;
}
void PropertyNormalList::setPyObject(PyObject* value)
{
if (PyList_Check(value)) {
Py_ssize_t nSize = PyList_Size(value);
std::vector<Base::Vector3f> values;
values.resize(nSize);
for (Py_ssize_t i = 0; i < nSize; ++i) {
PyObject* item = PyList_GetItem(value, i);
App::PropertyVector val;
val.setPyObject(item);
values[i] = Base::convertTo<Base::Vector3f>(val.getValue());
}
setValues(values);
}
else if (PyObject_TypeCheck(value, &(Base::VectorPy::Type))) {
Base::VectorPy* pcObject = static_cast<Base::VectorPy*>(value);
Base::Vector3d* val = pcObject->getVectorPtr();
setValue(Base::convertTo<Base::Vector3f>(*val));
}
else if (PyTuple_Check(value) && PyTuple_Size(value) == 3) {
App::PropertyVector val;
val.setPyObject(value);
setValue(Base::convertTo<Base::Vector3f>(val.getValue()));
}
else {
std::string error = std::string("type must be 'Vector' or list of 'Vector', not ");
error += value->ob_type->tp_name;
throw Py::TypeError(error);
}
}
void PropertyNormalList::Save(Base::Writer& writer) const
{
if (!writer.isForceXML()) {
writer.Stream() << writer.ind() << "<VectorList file=\"" << writer.addFile(getName(), this)
<< "\"/>" << std::endl;
}
}
void PropertyNormalList::Restore(Base::XMLReader& reader)
{
reader.readElement("VectorList");
std::string file(reader.getAttribute<const char*>("file"));
if (!file.empty()) {
// initiate a file read
reader.addFile(file.c_str(), this);
}
}
void PropertyNormalList::SaveDocFile(Base::Writer& writer) const
{
Base::OutputStream str(writer.Stream());
uint32_t uCt = (uint32_t)getSize();
str << uCt;
for (auto it : _lValueList) {
str << it.x << it.y << it.z;
}
}
void PropertyNormalList::RestoreDocFile(Base::Reader& reader)
{
Base::InputStream str(reader);
uint32_t uCt = 0;
str >> uCt;
std::vector<Base::Vector3f> values(uCt);
for (auto& it : values) {
str >> it.x >> it.y >> it.z;
}
setValues(values);
}
App::Property* PropertyNormalList::Copy() const
{
PropertyNormalList* p = new PropertyNormalList();
p->_lValueList = _lValueList;
return p;
}
void PropertyNormalList::Paste(const App::Property& from)
{
aboutToSetValue();
_lValueList = dynamic_cast<const PropertyNormalList&>(from)._lValueList;
hasSetValue();
}
unsigned int PropertyNormalList::getMemSize() const
{
return static_cast<unsigned int>(_lValueList.size() * sizeof(Base::Vector3f));
}
void PropertyNormalList::transformGeometry(const Base::Matrix4D& mat)
{
// A normal vector is only a direction with unit length, so we only need to rotate it
// (no translations or scaling)
// Extract scale factors (assumes an orthogonal rotation matrix)
// Use the fact that the length of the row vectors of R are all equal to 1
// And that scaling is applied after rotating
double s[3];
s[0] = sqrt(mat[0][0] * mat[0][0] + mat[0][1] * mat[0][1] + mat[0][2] * mat[0][2]);
s[1] = sqrt(mat[1][0] * mat[1][0] + mat[1][1] * mat[1][1] + mat[1][2] * mat[1][2]);
s[2] = sqrt(mat[2][0] * mat[2][0] + mat[2][1] * mat[2][1] + mat[2][2] * mat[2][2]);
// Set up the rotation matrix: zero the translations and make the scale factors = 1
Base::Matrix4D rot;
rot.setToUnity();
for (unsigned short i = 0; i < 3; i++) {
for (unsigned short j = 0; j < 3; j++) {
rot[i][j] = mat[i][j] / s[i];
}
}
aboutToSetValue();
// Rotate the normal vectors
for (int ii = 0; ii < getSize(); ii++) {
set1Value(ii, rot * operator[](ii));
}
hasSetValue();
}
// ----------------------------------------------------------------------------
PropertyCurvatureList::PropertyCurvatureList() = default;
void PropertyCurvatureList::setValue(const CurvatureInfo& lValue)
{
aboutToSetValue();
_lValueList.resize(1);
_lValueList[0] = lValue;
hasSetValue();
}
void PropertyCurvatureList::setValues(const std::vector<CurvatureInfo>& lValues)
{
aboutToSetValue();
_lValueList = lValues;
hasSetValue();
}
std::vector<float> PropertyCurvatureList::getCurvature(int mode) const
{
const std::vector<Mesh::CurvatureInfo>& fCurvInfo = getValues();
std::vector<float> fValues;
fValues.reserve(fCurvInfo.size());
// Mean curvature
if (mode == MeanCurvature) {
for (const auto& it : fCurvInfo) {
fValues.push_back(0.5F * (it.fMaxCurvature + it.fMinCurvature));
}
}
// Gaussian curvature
else if (mode == GaussCurvature) {
for (const auto& it : fCurvInfo) {
fValues.push_back(it.fMaxCurvature * it.fMinCurvature);
}
}
// Maximum curvature
else if (mode == MaxCurvature) {
for (const auto& it : fCurvInfo) {
fValues.push_back(it.fMaxCurvature);
}
}
// Minimum curvature
else if (mode == MinCurvature) {
for (const auto& it : fCurvInfo) {
fValues.push_back(it.fMinCurvature);
}
}
// Absolute curvature
else if (mode == AbsCurvature) {
for (const auto& it : fCurvInfo) {
if (fabs(it.fMaxCurvature) > fabs(it.fMinCurvature)) {
fValues.push_back(it.fMaxCurvature);
}
else {
fValues.push_back(it.fMinCurvature);
}
}
}
return fValues;
}
void PropertyCurvatureList::transformGeometry(const Base::Matrix4D& mat)
{
// The principal direction is only a vector with unit length, so we only need to rotate it
// (no translations or scaling)
// Extract scale factors (assumes an orthogonal rotation matrix)
// Use the fact that the length of the row vectors of R are all equal to 1
// And that scaling is applied after rotating
double s[3];
s[0] = sqrt(mat[0][0] * mat[0][0] + mat[0][1] * mat[0][1] + mat[0][2] * mat[0][2]);
s[1] = sqrt(mat[1][0] * mat[1][0] + mat[1][1] * mat[1][1] + mat[1][2] * mat[1][2]);
s[2] = sqrt(mat[2][0] * mat[2][0] + mat[2][1] * mat[2][1] + mat[2][2] * mat[2][2]);
// Set up the rotation matrix: zero the translations and make the scale factors = 1
Base::Matrix4D rot;
rot.setToUnity();
for (unsigned short i = 0; i < 3; i++) {
for (unsigned short j = 0; j < 3; j++) {
rot[i][j] = mat[i][j] / s[i];
}
}
aboutToSetValue();
// Rotate the principal directions
for (int ii = 0; ii < getSize(); ii++) {
CurvatureInfo ci = operator[](ii);
ci.cMaxCurvDir = rot * ci.cMaxCurvDir;
ci.cMinCurvDir = rot * ci.cMinCurvDir;
_lValueList[ii] = ci;
}
hasSetValue();
}
void PropertyCurvatureList::Save(Base::Writer& writer) const
{
if (!writer.isForceXML()) {
writer.Stream() << writer.ind() << "<CurvatureList file=\""
<< writer.addFile(getName(), this) << "\"/>" << std::endl;
}
}
void PropertyCurvatureList::Restore(Base::XMLReader& reader)
{
reader.readElement("CurvatureList");
std::string file(reader.getAttribute<const char*>("file"));
if (!file.empty()) {
// initiate a file read
reader.addFile(file.c_str(), this);
}
}
void PropertyCurvatureList::SaveDocFile(Base::Writer& writer) const
{
Base::OutputStream str(writer.Stream());
uint32_t uCt = (uint32_t)getSize();
str << uCt;
for (const auto& it : _lValueList) {
str << it.fMaxCurvature << it.fMinCurvature;
str << it.cMaxCurvDir.x << it.cMaxCurvDir.y << it.cMaxCurvDir.z;
str << it.cMinCurvDir.x << it.cMinCurvDir.y << it.cMinCurvDir.z;
}
}
void PropertyCurvatureList::RestoreDocFile(Base::Reader& reader)
{
Base::InputStream str(reader);
uint32_t uCt = 0;
str >> uCt;
std::vector<CurvatureInfo> values(uCt);
for (auto& it : values) {
str >> it.fMaxCurvature >> it.fMinCurvature;
str >> it.cMaxCurvDir.x >> it.cMaxCurvDir.y >> it.cMaxCurvDir.z;
str >> it.cMinCurvDir.x >> it.cMinCurvDir.y >> it.cMinCurvDir.z;
}
setValues(values);
}
PyObject* PropertyCurvatureList::getPyObject()
{
Py::List list;
for (const auto& it : _lValueList) {
Py::Tuple tuple(4);
tuple.setItem(0, Py::Float(it.fMaxCurvature));
tuple.setItem(1, Py::Float(it.fMinCurvature));
Py::Tuple maxDir(3);
maxDir.setItem(0, Py::Float(it.cMaxCurvDir.x));
maxDir.setItem(1, Py::Float(it.cMaxCurvDir.y));
maxDir.setItem(2, Py::Float(it.cMaxCurvDir.z));
tuple.setItem(2, maxDir);
Py::Tuple minDir(3);
minDir.setItem(0, Py::Float(it.cMinCurvDir.x));
minDir.setItem(1, Py::Float(it.cMinCurvDir.y));
minDir.setItem(2, Py::Float(it.cMinCurvDir.z));
tuple.setItem(3, minDir);
list.append(tuple);
}
return Py::new_reference_to(list);
}
void PropertyCurvatureList::setPyObject(PyObject* /*value*/)
{
throw Base::AttributeError(std::string("This attribute is read-only"));
}
App::Property* PropertyCurvatureList::Copy() const
{
PropertyCurvatureList* p = new PropertyCurvatureList();
p->_lValueList = _lValueList;
return p;
}
void PropertyCurvatureList::Paste(const App::Property& from)
{
aboutToSetValue();
_lValueList = dynamic_cast<const PropertyCurvatureList&>(from)._lValueList;
hasSetValue();
}
// ----------------------------------------------------------------------------
const MeshCore::Material& PropertyMaterial::getValue() const
{
return _material;
}
MeshCore::MeshIO::Binding PropertyMaterial::getBinding() const
{
return _material.binding;
}
const std::vector<Base::Color>& PropertyMaterial::getAmbientColor() const
{
return _material.ambientColor;
}
const std::vector<Base::Color>& PropertyMaterial::getDiffuseColor() const
{
return _material.diffuseColor;
}
const std::vector<Base::Color>& PropertyMaterial::getSpecularColor() const
{
return _material.specularColor;
}
const std::vector<Base::Color>& PropertyMaterial::getEmissiveColor() const
{
return _material.emissiveColor;
}
const std::vector<float>& PropertyMaterial::getShininess() const
{
return _material.shininess;
}
const std::vector<float>& PropertyMaterial::getTransparency() const
{
return _material.transparency;
}
void PropertyMaterial::setValue(const MeshCore::Material& value)
{
aboutToSetValue();
_material = value;
hasSetValue();
}
void PropertyMaterial::setAmbientColor(const std::vector<Base::Color>& value)
{
aboutToSetValue();
_material.ambientColor = value;
hasSetValue();
}
void PropertyMaterial::setDiffuseColor(const std::vector<Base::Color>& value)
{
aboutToSetValue();
_material.diffuseColor = value;
hasSetValue();
}
void PropertyMaterial::setSpecularColor(const std::vector<Base::Color>& value)
{
aboutToSetValue();
_material.specularColor = value;
hasSetValue();
}
void PropertyMaterial::setEmissiveColor(const std::vector<Base::Color>& value)
{
aboutToSetValue();
_material.emissiveColor = value;
hasSetValue();
}
void PropertyMaterial::setShininess(const std::vector<float>& value)
{
aboutToSetValue();
_material.shininess = value;
hasSetValue();
}
void PropertyMaterial::setTransparency(const std::vector<float>& value)
{
aboutToSetValue();
_material.transparency = value;
hasSetValue();
}
void PropertyMaterial::setBinding(MeshCore::MeshIO::Binding bind)
{
aboutToSetValue();
_material.binding = bind;
hasSetValue();
}
PyObject* PropertyMaterial::getPyObject()
{
auto getColorList = [](const std::vector<Base::Color>& color) {
Py::List list;
for (const auto& it : color) {
list.append(Py::TupleN(Py::Float(it.r), Py::Float(it.g), Py::Float(it.b)));
}
return list;
};
auto getFloatList = [](const std::vector<float>& value) {
Py::List list;
for (auto it : value) {
list.append(Py::Float(it));
}
return list;
};
Py::Dict dict;
dict.setItem("binding", Py::Long(static_cast<int>(_material.binding)));
dict.setItem("ambientColor", getColorList(_material.ambientColor));
dict.setItem("diffuseColor", getColorList(_material.diffuseColor));
dict.setItem("specularColor", getColorList(_material.specularColor));
dict.setItem("emissiveColor", getColorList(_material.emissiveColor));
dict.setItem("shininess", getFloatList(_material.shininess));
dict.setItem("transparency", getFloatList(_material.transparency));
return Py::new_reference_to(dict);
}
void PropertyMaterial::setPyObject(PyObject* obj)
{
auto getColorList = [](const Py::Dict& dict, const std::string& key) {
std::vector<Base::Color> color;
if (dict.hasKey(key)) {
Py::Sequence list(dict.getItem(key));
color.reserve(list.size());
for (const auto& it : list) {
Py::Sequence tuple(it);
float r = static_cast<float>(Py::Float(tuple[0]));
float g = static_cast<float>(Py::Float(tuple[1]));
float b = static_cast<float>(Py::Float(tuple[2]));
color.emplace_back(r, g, b);
}
}
return color;
};
auto getFloatList = [](const Py::Dict& dict, const std::string& key) {
std::vector<float> value;
if (dict.hasKey(key)) {
Py::Sequence list(dict.getItem(key));
value.reserve(list.size());
for (const auto& it : list) {
value.push_back(static_cast<float>(Py::Float(it)));
}
}
return value;
};
try {
MeshCore::Material material;
Py::Dict dict(obj);
if (dict.hasKey("binding")) {
Py::Long binding(dict.getItem("binding"));
int bind = static_cast<int>(binding);
material.binding = static_cast<MeshCore::MeshIO::Binding>(bind);
}
material.ambientColor = getColorList(dict, "ambientColor");
material.diffuseColor = getColorList(dict, "diffuseColor");
material.specularColor = getColorList(dict, "specularColor");
material.emissiveColor = getColorList(dict, "emissiveColor");
material.shininess = getFloatList(dict, "shininess");
material.transparency = getFloatList(dict, "transparency");
setValue(material);
}
catch (Py::Exception& e) {
e.clear();
throw Base::TypeError("Not a dict with expected keys");
}
}
void PropertyMaterial::Save(Base::Writer& writer) const
{
if (!writer.isForceXML()) {
writer.Stream() << writer.ind() << "<Material file=\"" << writer.addFile(getName(), this)
<< "\"/>" << std::endl;
}
}
void PropertyMaterial::Restore(Base::XMLReader& reader)
{
reader.readElement("Material");
if (reader.hasAttribute("file")) {
std::string file(reader.getAttribute<const char*>("file"));
if (!file.empty()) {
// initiate a file read
reader.addFile(file.c_str(), this);
}
}
}
void PropertyMaterial::SaveDocFile(Base::Writer& writer) const
{
Base::OutputStream str(writer.Stream());
auto saveColor = [&str](const std::vector<Base::Color>& color) {
uint32_t count = static_cast<uint32_t>(color.size());
str << count;
for (const auto& it : color) {
str << it.getPackedValue();
}
};
auto saveFloat = [&str](const std::vector<float>& value) {
uint32_t count = static_cast<uint32_t>(value.size());
str << count;
for (const auto& it : value) {
str << it;
}
};
uint32_t bind = static_cast<uint32_t>(_material.binding);
str << bind;
saveColor(_material.ambientColor);
saveColor(_material.diffuseColor);
saveColor(_material.specularColor);
saveColor(_material.emissiveColor);
saveFloat(_material.shininess);
saveFloat(_material.transparency);
}
void PropertyMaterial::RestoreDocFile(Base::Reader& reader)
{
Base::InputStream str(reader);
auto restoreColor = [&str](std::vector<Base::Color>& color) {
uint32_t count = 0;
str >> count;
color.resize(count);
for (auto& it : color) {
uint32_t value {}; // must be 32 bit long
str >> value;
it.setPackedValue(value);
}
};
auto restoreFloat = [&str](std::vector<float>& value) {
uint32_t count = 0;
str >> count;
value.resize(count);
for (auto& it : value) {
float valueF {};
str >> valueF;
it = valueF;
}
};
MeshCore::Material material;
uint32_t bind = 0;
str >> bind;
material.binding = static_cast<MeshCore::MeshIO::Binding>(bind);
restoreColor(material.ambientColor);
restoreColor(material.diffuseColor);
restoreColor(material.specularColor);
restoreColor(material.emissiveColor);
restoreFloat(material.shininess);
restoreFloat(material.transparency);
setValue(material);
}
const char* PropertyMaterial::getEditorName() const
{
return "";
}
App::Property* PropertyMaterial::Copy() const
{
PropertyMaterial* prop = new PropertyMaterial();
prop->_material = _material;
return prop;
}
void PropertyMaterial::Paste(const Property& from)
{
aboutToSetValue();
using ObjectType = std::remove_pointer<decltype(this)>::type;
_material = dynamic_cast<const ObjectType&>(from)._material;
hasSetValue();
}
unsigned int PropertyMaterial::getMemSize() const
{
auto size = (_material.ambientColor.size() + _material.diffuseColor.size()
+ _material.emissiveColor.size() + _material.specularColor.size())
* sizeof(Base::Color)
+ (_material.shininess.size() + _material.transparency.size()) * sizeof(float)
+ _material.library.size() + sizeof(_material);
return static_cast<unsigned int>(size);
}
bool PropertyMaterial::isSame(const App::Property& other) const
{
if (&other == this) {
return true;
}
return getTypeId() == other.getTypeId()
&& getValue() == static_cast<decltype(this)>(&other)->getValue();
}
// ----------------------------------------------------------------------------
PropertyMeshKernel::PropertyMeshKernel()
: _meshObject(new MeshObject())
{
// Note: Normally this property is a member of a document object, i.e. the setValue()
// method gets called in the constructor of a subclass of DocumentObject, e.g. Mesh::Feature.
// This means that the created MeshObject here will be replaced and deleted immediately.
// However, we anyway create this object in case we use this class in another context.
}
PropertyMeshKernel::~PropertyMeshKernel()
{
if (meshPyObject) {
// Note: Do not call setInvalid() of the Python binding
// because the mesh should still be accessible afterwards.
meshPyObject->parentProperty = nullptr;
Py_DECREF(meshPyObject);
}
}
void PropertyMeshKernel::setValuePtr(MeshObject* mesh)
{
// use the tmp. object to guarantee that the referenced mesh is not destroyed
// before calling hasSetValue()
Base::Reference<MeshObject> tmp(_meshObject);
aboutToSetValue();
_meshObject = mesh;
hasSetValue();
}
void PropertyMeshKernel::setValue(const MeshObject& mesh)
{
aboutToSetValue();
*_meshObject = mesh;
hasSetValue();
}
void PropertyMeshKernel::setValue(const MeshCore::MeshKernel& mesh)
{
aboutToSetValue();
_meshObject->setKernel(mesh);
hasSetValue();
}
void PropertyMeshKernel::swapMesh(MeshObject& mesh)
{
aboutToSetValue();
_meshObject->swap(mesh);
hasSetValue();
}
void PropertyMeshKernel::swapMesh(MeshCore::MeshKernel& mesh)
{
aboutToSetValue();
_meshObject->swap(mesh);
hasSetValue();
}
const MeshObject& PropertyMeshKernel::getValue() const
{
return *_meshObject;
}
const MeshObject* PropertyMeshKernel::getValuePtr() const
{
return static_cast<MeshObject*>(_meshObject);
}
const Data::ComplexGeoData* PropertyMeshKernel::getComplexData() const
{
return static_cast<MeshObject*>(_meshObject);
}
Base::BoundBox3d PropertyMeshKernel::getBoundingBox() const
{
return _meshObject->getBoundBox();
}
unsigned int PropertyMeshKernel::getMemSize() const
{
unsigned int size = 0;
size += _meshObject->getMemSize();
return size;
}
MeshObject* PropertyMeshKernel::startEditing()
{
aboutToSetValue();
return static_cast<MeshObject*>(_meshObject);
}
void PropertyMeshKernel::finishEditing()
{
hasSetValue();
}
void PropertyMeshKernel::transformGeometry(const Base::Matrix4D& rclMat)
{
aboutToSetValue();
_meshObject->transformGeometry(rclMat);
hasSetValue();
}
void PropertyMeshKernel::setPointIndices(const std::vector<std::pair<PointIndex, Base::Vector3f>>& inds)
{
aboutToSetValue();
MeshCore::MeshKernel& kernel = _meshObject->getKernel();
for (const auto& it : inds) {
kernel.SetPoint(it.first, it.second);
}
hasSetValue();
}
void PropertyMeshKernel::setTransform(const Base::Matrix4D& rclTrf)
{
_meshObject->setTransform(rclTrf);
}
Base::Matrix4D PropertyMeshKernel::getTransform() const
{
return _meshObject->getTransform();
}
PyObject* PropertyMeshKernel::getPyObject()
{
if (!meshPyObject) {
meshPyObject = new MeshPy(&*_meshObject); // Lgtm[cpp/resource-not-released-in-destructor]
// ** Not destroyed in this class because it is
// reference-counted and destroyed elsewhere
meshPyObject->setConst(); // set immutable
meshPyObject->parentProperty = this;
}
Py_INCREF(meshPyObject);
return meshPyObject;
}
void PropertyMeshKernel::setPyObject(PyObject* value)
{
if (PyObject_TypeCheck(value, &(MeshPy::Type))) {
MeshPy* mesh = static_cast<MeshPy*>(value);
// Do not allow one to reassign the same instance
if (&(*this->_meshObject) != mesh->getMeshObjectPtr()) {
// Note: Copy the content, do NOT reference the same mesh object
setValue(*(mesh->getMeshObjectPtr()));
}
}
else if (PyList_Check(value)) {
// new instance of MeshObject
Py::List triangles(value);
MeshObject* mesh = MeshObject::createMeshFromList(triangles);
setValuePtr(mesh);
}
else {
std::string error = std::string("type must be 'Mesh', not ");
error += value->ob_type->tp_name;
throw Base::TypeError(error);
}
}
void PropertyMeshKernel::Save(Base::Writer& writer) const
{
if (writer.isForceXML()) {
writer.Stream() << writer.ind() << "<Mesh>" << std::endl;
MeshCore::MeshOutput saver(_meshObject->getKernel());
saver.SaveXML(writer);
}
else {
writer.Stream() << writer.ind() << "<Mesh file=\"" << writer.addFile("MeshKernel.bms", this)
<< "\"/>" << std::endl;
}
}
void PropertyMeshKernel::Restore(Base::XMLReader& reader)
{
reader.readElement("Mesh");
std::string file(reader.getAttribute<const char*>("file"));
if (file.empty()) {
// read XML
MeshCore::MeshKernel kernel;
MeshCore::MeshInput restorer(kernel);
restorer.LoadXML(reader);
// avoid to duplicate the mesh in memory
MeshCore::MeshPointArray points;
MeshCore::MeshFacetArray facets;
kernel.Adopt(points, facets);
aboutToSetValue();
_meshObject->getKernel().Adopt(points, facets);
hasSetValue();
}
else {
// initiate a file read
reader.addFile(file.c_str(), this);
}
}
void PropertyMeshKernel::SaveDocFile(Base::Writer& writer) const
{
_meshObject->save(writer.Stream());
}
void PropertyMeshKernel::RestoreDocFile(Base::Reader& reader)
{
aboutToSetValue();
_meshObject->load(reader);
hasSetValue();
}
App::Property* PropertyMeshKernel::Copy() const
{
// Note: Copy the content, do NOT reference the same mesh object
PropertyMeshKernel* prop = new PropertyMeshKernel();
*(prop->_meshObject) = *(this->_meshObject);
return prop;
}
void PropertyMeshKernel::Paste(const App::Property& from)
{
// Note: Copy the content, do NOT reference the same mesh object
aboutToSetValue();
const PropertyMeshKernel& prop = dynamic_cast<const PropertyMeshKernel&>(from);
*(this->_meshObject) = *(prop._meshObject);
hasSetValue();
}
Reference in New Issue View Git Blame Copy Permalink