kindred/create
1
1
Fork 0
Code Issues 30 Pull Requests Actions Packages Projects 9 Releases 2 Wiki Activity

Mesh: [skip ci] refactor Mesh open/import functions

Browse Source
This commit is contained in:
wmayer
2021-03-20 21:54:30 +01:00
parent 182952a881
commit f4e3e8abd6
4 changed files with 199 additions and 145 deletions
Download Patch File Download Diff File Expand all files Collapse all files

156
src/Mod/Mesh/App/AppMeshPy.cpp
View File

@@ -52,6 +52,7 @@
#include "Mesh.h"
#include "Exporter.h"
#include "Importer.h"
#include "FeatureMeshImport.h"
#include <Mod/Mesh/App/MeshPy.h>
@@ -173,79 +174,11 @@ private:
std::string EncodedName = std::string(Name);
PyMem_Free(Name);
MeshObject mesh;
MeshCore::Material mat;
if (mesh.load(EncodedName.c_str(), &mat)) {
Base::FileInfo file(EncodedName.c_str());
// create new document and add Import feature
App::Document *pcDoc = App::GetApplication().newDocument("Unnamed");
unsigned long segmct = mesh.countSegments();
if (segmct > 1) {
for (unsigned long i=0; i<segmct; i++) {
const Segment& group = mesh.getSegment(i);
std::string groupName = group.getName();
if (groupName.empty())
groupName = file.fileNamePure();
// create new document and add Import feature
App::Document *pcDoc = App::GetApplication().newDocument("Unnamed");
std::unique_ptr<MeshObject> segm(mesh.meshFromSegment(group.getIndices()));
Mesh::Feature *pcFeature = static_cast<Mesh::Feature *>
(pcDoc->addObject("Mesh::Feature", groupName.c_str()));
pcFeature->Label.setValue(groupName.c_str());
pcFeature->Mesh.swapMesh(*segm);
// if colors are set per face
if (mat.binding == MeshCore::MeshIO::PER_FACE &&
mat.diffuseColor.size() == mesh.countFacets()) {
App::PropertyColorList* prop = static_cast<App::PropertyColorList*>
(pcFeature->addDynamicProperty("App::PropertyColorList", "VertexColors"));
if (prop) {
std::vector<App::Color> diffuseColor;
diffuseColor.reserve(group.getIndices().size());
for (const auto& it : group.getIndices()) {
diffuseColor.push_back(mat.diffuseColor[it]);
}
prop->setValues(diffuseColor);
}
}
pcFeature->purgeTouched();
}
}
else if (mat.binding == MeshCore::MeshIO::PER_VERTEX &&
mat.diffuseColor.size() == mesh.countPoints()) {
FeatureCustom *pcFeature = new FeatureCustom();
pcFeature->Label.setValue(file.fileNamePure().c_str());
pcFeature->Mesh.swapMesh(mesh);
App::PropertyColorList* prop = static_cast<App::PropertyColorList*>
(pcFeature->addDynamicProperty("App::PropertyColorList", "VertexColors"));
if (prop) {
prop->setValues(mat.diffuseColor);
}
pcFeature->purgeTouched();
pcDoc->addObject(pcFeature, file.fileNamePure().c_str());
}
else if (mat.binding == MeshCore::MeshIO::PER_FACE &&
mat.diffuseColor.size() == mesh.countFacets()) {
FeatureCustom *pcFeature = new FeatureCustom();
pcFeature->Label.setValue(file.fileNamePure().c_str());
pcFeature->Mesh.swapMesh(mesh);
App::PropertyColorList* prop = static_cast<App::PropertyColorList*>
(pcFeature->addDynamicProperty("App::PropertyColorList", "FaceColors"));
if (prop) {
prop->setValues(mat.diffuseColor);
}
pcFeature->purgeTouched();
pcDoc->addObject(pcFeature, file.fileNamePure().c_str());
}
else {
Mesh::Feature *pcFeature = static_cast<Mesh::Feature *>
(pcDoc->addObject("Mesh::Feature", file.fileNamePure().c_str()));
pcFeature->Label.setValue(file.fileNamePure().c_str());
pcFeature->Mesh.swapMesh(mesh);
pcFeature->purgeTouched();
}
}
Mesh::Importer import(pcDoc);
import.load(EncodedName);
return Py::None();
}
@@ -260,86 +193,19 @@ private:
PyMem_Free(Name);
App::Document *pcDoc = 0;
if (DocName)
if (DocName) {
pcDoc = App::GetApplication().getDocument(DocName);
else
}
else {
pcDoc = App::GetApplication().getActiveDocument();
}
if (!pcDoc) {
pcDoc = App::GetApplication().newDocument(DocName);
}
MeshObject mesh;
MeshCore::Material mat;
if (mesh.load(EncodedName.c_str(), &mat)) {
Base::FileInfo file(EncodedName.c_str());
unsigned long segmct = mesh.countSegments();
if (segmct > 1) {
for (unsigned long i=0; i<segmct; i++) {
const Segment& group = mesh.getSegment(i);
std::string groupName = group.getName();
if (groupName.empty())
groupName = file.fileNamePure();
std::unique_ptr<MeshObject> segm(mesh.meshFromSegment(group.getIndices()));
Mesh::Feature *pcFeature = static_cast<Mesh::Feature *>
(pcDoc->addObject("Mesh::Feature", groupName.c_str()));
pcFeature->Label.setValue(groupName.c_str());
pcFeature->Mesh.swapMesh(*segm);
// if colors are set per face
if (mat.binding == MeshCore::MeshIO::PER_FACE &&
mat.diffuseColor.size() == mesh.countFacets()) {
App::PropertyColorList* prop = static_cast<App::PropertyColorList*>
(pcFeature->addDynamicProperty("App::PropertyColorList", "VertexColors"));
if (prop) {
std::vector<App::Color> diffuseColor;
diffuseColor.reserve(group.getIndices().size());
for (const auto& it : group.getIndices()) {
diffuseColor.push_back(mat.diffuseColor[it]);
}
prop->setValues(diffuseColor);
}
}
pcFeature->purgeTouched();
}
}
else if (mat.binding == MeshCore::MeshIO::PER_VERTEX &&
mat.diffuseColor.size() == mesh.countPoints()) {
FeatureCustom *pcFeature = new FeatureCustom();
pcFeature->Label.setValue(file.fileNamePure().c_str());
pcFeature->Mesh.swapMesh(mesh);
App::PropertyColorList* prop = static_cast<App::PropertyColorList*>
(pcFeature->addDynamicProperty("App::PropertyColorList", "VertexColors"));
if (prop) {
prop->setValues(mat.diffuseColor);
}
pcFeature->purgeTouched();
pcDoc->addObject(pcFeature, file.fileNamePure().c_str());
}
else if (mat.binding == MeshCore::MeshIO::PER_FACE &&
mat.diffuseColor.size() == mesh.countFacets()) {
FeatureCustom *pcFeature = new FeatureCustom();
pcFeature->Label.setValue(file.fileNamePure().c_str());
pcFeature->Mesh.swapMesh(mesh);
App::PropertyColorList* prop = static_cast<App::PropertyColorList*>
(pcFeature->addDynamicProperty("App::PropertyColorList", "FaceColors"));
if (prop) {
prop->setValues(mat.diffuseColor);
}
pcFeature->purgeTouched();
pcDoc->addObject(pcFeature, file.fileNamePure().c_str());
}
else {
Mesh::Feature *pcFeature = static_cast<Mesh::Feature *>
(pcDoc->addObject("Mesh::Feature", file.fileNamePure().c_str()));
pcFeature->Label.setValue(file.fileNamePure().c_str());
pcFeature->Mesh.swapMesh(mesh);
pcFeature->purgeTouched();
}
}
Mesh::Importer import(pcDoc);
import.load(EncodedName);
return Py::None();
}

2
src/Mod/Mesh/App/CMakeLists.txt
View File

@@ -329,6 +329,8 @@ SET(Mesh_SRCS
AppMeshPy.cpp
Exporter.cpp
Exporter.h
Importer.cpp
Importer.h
Facet.cpp
Facet.h
FacetPyImp.cpp

123
src/Mod/Mesh/App/Importer.cpp Normal file
View File

@@ -0,0 +1,123 @@
/***************************************************************************
* Copyright (c) 2021 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"
#ifndef _PreComp_
#endif
#include "Importer.h"
#include "MeshFeature.h"
#include <App/Document.h>
using namespace Mesh;
Importer::Importer(App::Document* doc)
: document(doc)
{
}
void Importer::load(const std::string& fileName)
{
MeshObject mesh;
MeshCore::Material mat;
if (mesh.load(fileName.c_str(), &mat)) {
Base::FileInfo file(fileName.c_str());
unsigned long segmct = mesh.countSegments();
if (segmct > 1) {
createMeshFromSegments(file.fileNamePure(), mat, mesh);
}
else if (mat.binding == MeshCore::MeshIO::PER_VERTEX &&
mat.diffuseColor.size() == mesh.countPoints()) {
Feature* feature = createMesh(file.fileNamePure(), mesh);
addVertexColors(feature, mat.diffuseColor);
feature->purgeTouched();
}
else if (mat.binding == MeshCore::MeshIO::PER_FACE &&
mat.diffuseColor.size() == mesh.countFacets()) {
Feature* feature = createMesh(file.fileNamePure(), mesh);
addFaceColors(feature, mat.diffuseColor);
feature->purgeTouched();
}
else {
Feature* feature = createMesh(file.fileNamePure(), mesh);
feature->purgeTouched();
}
}
}
void Importer::addVertexColors(Feature* feature, const std::vector<App::Color>& colors)
{
addColors(feature, "VertexColors", colors);
}
void Importer::addFaceColors(Feature* feature, const std::vector<App::Color>& colors)
{
addColors(feature, "FaceColors", colors);
}
void Importer::addColors(Feature* feature, const std::string& property, const std::vector<App::Color>& colors)
{
App::PropertyColorList* prop = static_cast<App::PropertyColorList*>
(feature->addDynamicProperty("App::PropertyColorList", property.c_str()));
if (prop) {
prop->setValues(colors);
}
}
void Importer::createMeshFromSegments(const std::string& name, MeshCore::Material& mat, MeshObject& mesh)
{
unsigned long segmct = mesh.countSegments();
for (unsigned long i=0; i<segmct; i++) {
const Segment& group = mesh.getSegment(i);
std::string groupName = group.getName();
if (groupName.empty())
groupName = name;
std::unique_ptr<MeshObject> segm(mesh.meshFromSegment(group.getIndices()));
Feature* feature = createMesh(groupName, *segm);
// if colors are set per face
if (mat.binding == MeshCore::MeshIO::PER_FACE &&
mat.diffuseColor.size() == mesh.countFacets()) {
std::vector<App::Color> diffuseColor;
diffuseColor.reserve(group.getIndices().size());
for (const auto& it : group.getIndices()) {
diffuseColor.push_back(mat.diffuseColor[it]);
}
addFaceColors(feature, diffuseColor);
}
feature->purgeTouched();
}
}
Feature* Importer::createMesh(const std::string& name, MeshObject& mesh)
{
Mesh::Feature *pcFeature = static_cast<Mesh::Feature *>
(document->addObject("Mesh::Feature", name.c_str()));
pcFeature->Label.setValue(name);
pcFeature->Mesh.swapMesh(mesh);
return pcFeature;
}

63
src/Mod/Mesh/App/Importer.h Normal file
View File

@@ -0,0 +1,63 @@
/***************************************************************************
* Copyright (c) 2021 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 *
* *
***************************************************************************/
#ifndef MESH_IMPORTER_H
#define MESH_IMPORTER_H
#include <string>
#include <vector>
namespace App {
class Document;
class Color;
}
namespace MeshCore {
struct Material;
}
namespace Mesh
{
class MeshObject;
class Feature;
class Importer
{
public:
Importer(App::Document*);
~Importer() = default;
void load(const std::string& fileName);
private:
void addVertexColors(Feature*, const std::vector<App::Color>&);
void addFaceColors(Feature*, const std::vector<App::Color>&);
void addColors(Feature*, const std::string& property, const std::vector<App::Color>&);
Feature* createMesh(const std::string& name, MeshObject&);
void createMeshFromSegments(const std::string& name, MeshCore::Material& mat, MeshObject& mesh);
private:
App::Document* document;
};
} // namespace Mesh
#endif // MESH_IMPORTER_H