kindred/create
1
1
Fork 0
Code Issues 53 Pull Requests Actions Packages Projects 9 Releases 2 Wiki Activity
Files
9738b9b6ea3e2a99e7857019e8bde64d825907fe
create/src/Mod/Fem/App/PropertyPostDataObject.cpp

524 lines
19 KiB
C++
Raw Blame History

/***************************************************************************
* Copyright (c) 2015 Stefan Tröger <stefantroeger@gmx.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_
#include <Python.h>
#include <vtkCompositeDataSet.h>
#include <vtkMultiBlockDataSet.h>
#include <vtkMultiPieceDataSet.h>
#include <vtkPolyData.h>
#include <vtkRectilinearGrid.h>
#include <vtkStructuredGrid.h>
#include <vtkUniformGrid.h>
#include <vtkUnstructuredGrid.h>
#include <vtkXMLDataSetWriter.h>
#include <vtkXMLMultiBlockDataWriter.h>
#include <vtkXMLMultiBlockDataReader.h>
#include <vtkXMLImageDataReader.h>
#include <vtkXMLPolyDataReader.h>
#include <vtkXMLRectilinearGridReader.h>
#include <vtkXMLStructuredGridReader.h>
#include <vtkXMLUnstructuredGridReader.h>
#endif
#include <App/Application.h>
#include <App/DocumentObject.h>
#include <Base/Console.h>
#include <Base/FileInfo.h>
#include <Base/Reader.h>
#include <Base/Stream.h>
#include <Base/Writer.h>
#include <CXX/Objects.hxx>
#ifdef _MSC_VER
#include <zipios++/zipios-config.h>
#endif
#include <zipios++/zipoutputstream.h>
#include <zipios++/zipinputstream.h>
#include "PropertyPostDataObject.h"
using namespace Fem;
TYPESYSTEM_SOURCE(Fem::PropertyPostDataObject, App::Property)
PropertyPostDataObject::PropertyPostDataObject() = default;
PropertyPostDataObject::~PropertyPostDataObject() = default;
void PropertyPostDataObject::scaleDataObject(vtkDataObject* dataObject, double s)
{
auto scalePoints = [](vtkPoints* points, double s) {
for (vtkIdType i = 0; i < points->GetNumberOfPoints(); i++) {
double xyz[3];
points->GetPoint(i, xyz);
for (double& j : xyz) {
j *= s;
}
points->SetPoint(i, xyz);
}
};
if (dataObject->GetDataObjectType() == VTK_POLY_DATA) {
vtkPolyData* dataSet = vtkPolyData::SafeDownCast(dataObject);
scalePoints(dataSet->GetPoints(), s);
}
else if (dataObject->GetDataObjectType() == VTK_STRUCTURED_GRID) {
vtkStructuredGrid* dataSet = vtkStructuredGrid::SafeDownCast(dataObject);
scalePoints(dataSet->GetPoints(), s);
}
else if (dataObject->GetDataObjectType() == VTK_UNSTRUCTURED_GRID) {
vtkUnstructuredGrid* dataSet = vtkUnstructuredGrid::SafeDownCast(dataObject);
scalePoints(dataSet->GetPoints(), s);
}
else if (dataObject->GetDataObjectType() == VTK_MULTIBLOCK_DATA_SET) {
vtkMultiBlockDataSet* dataSet = vtkMultiBlockDataSet::SafeDownCast(dataObject);
for (unsigned int i = 0; i < dataSet->GetNumberOfBlocks(); i++) {
scaleDataObject(dataSet->GetBlock(i), s);
}
}
else if (dataObject->GetDataObjectType() == VTK_MULTIPIECE_DATA_SET) {
vtkMultiPieceDataSet* dataSet = vtkMultiPieceDataSet::SafeDownCast(dataObject);
for (unsigned int i = 0; i < dataSet->GetNumberOfPieces(); i++) {
scaleDataObject(dataSet->GetPiece(i), s);
}
}
}
void PropertyPostDataObject::scale(double s)
{
if (m_dataObject) {
aboutToSetValue();
scaleDataObject(m_dataObject, s);
hasSetValue();
}
}
void PropertyPostDataObject::setValue(const vtkSmartPointer<vtkDataObject>& ds)
{
aboutToSetValue();
if (ds) {
createDataObjectByExternalType(ds);
m_dataObject->DeepCopy(ds);
}
else {
m_dataObject = nullptr;
}
hasSetValue();
}
const vtkSmartPointer<vtkDataObject>& PropertyPostDataObject::getValue() const
{
return m_dataObject;
}
bool PropertyPostDataObject::isComposite()
{
return m_dataObject && !m_dataObject->IsA("vtkDataSet");
}
bool PropertyPostDataObject::isDataSet()
{
return m_dataObject && m_dataObject->IsA("vtkDataSet");
}
int PropertyPostDataObject::getDataType()
{
if (!m_dataObject) {
return -1;
}
return m_dataObject->GetDataObjectType();
}
PyObject* PropertyPostDataObject::getPyObject()
{
// TODO: fetch the vtk python object from the data set and return it
return Py::new_reference_to(Py::None());
}
void PropertyPostDataObject::setPyObject(PyObject* /*value*/)
{}
App::Property* PropertyPostDataObject::Copy() const
{
PropertyPostDataObject* prop = new PropertyPostDataObject();
if (m_dataObject) {
prop->createDataObjectByExternalType(m_dataObject);
prop->m_dataObject->DeepCopy(m_dataObject);
}
return prop;
}
void PropertyPostDataObject::createDataObjectByExternalType(vtkSmartPointer<vtkDataObject> ex)
{
switch (ex->GetDataObjectType()) {
case VTK_POLY_DATA:
m_dataObject = vtkSmartPointer<vtkPolyData>::New();
break;
case VTK_STRUCTURED_GRID:
m_dataObject = vtkSmartPointer<vtkStructuredGrid>::New();
break;
case VTK_RECTILINEAR_GRID:
m_dataObject = vtkSmartPointer<vtkRectilinearGrid>::New();
break;
case VTK_UNSTRUCTURED_GRID:
m_dataObject = vtkSmartPointer<vtkUnstructuredGrid>::New();
break;
case VTK_UNIFORM_GRID:
m_dataObject = vtkSmartPointer<vtkUniformGrid>::New();
break;
case VTK_COMPOSITE_DATA_SET:
m_dataObject = vtkCompositeDataSet::New();
break;
case VTK_MULTIBLOCK_DATA_SET:
m_dataObject = vtkSmartPointer<vtkMultiBlockDataSet>::New();
break;
case VTK_MULTIPIECE_DATA_SET:
m_dataObject = vtkSmartPointer<vtkMultiPieceDataSet>::New();
break;
default:
break;
};
}
void PropertyPostDataObject::Paste(const App::Property& from)
{
aboutToSetValue();
m_dataObject = dynamic_cast<const PropertyPostDataObject&>(from).m_dataObject;
hasSetValue();
}
unsigned int PropertyPostDataObject::getMemSize() const
{
return m_dataObject ? m_dataObject->GetActualMemorySize() : 0;
}
void PropertyPostDataObject::getPaths(std::vector<App::ObjectIdentifier>& /*paths*/) const
{
/* paths.push_back(App::ObjectIdentifier(getContainer())
<< App::ObjectIdentifier::Component::SimpleComponent(getName())
<< App::ObjectIdentifier::Component::SimpleComponent(
App::ObjectIdentifier::String("ShapeType")));
paths.push_back(App::ObjectIdentifier(getContainer())
<< App::ObjectIdentifier::Component::SimpleComponent(getName())
<< App::ObjectIdentifier::Component::SimpleComponent(
App::ObjectIdentifier::String("Orientation")));
paths.push_back(App::ObjectIdentifier(getContainer())
<< App::ObjectIdentifier::Component::SimpleComponent(getName())
<< App::ObjectIdentifier::Component::SimpleComponent(
App::ObjectIdentifier::String("Length")));
paths.push_back(App::ObjectIdentifier(getContainer())
<< App::ObjectIdentifier::Component::SimpleComponent(getName())
<< App::ObjectIdentifier::Component::SimpleComponent(
App::ObjectIdentifier::String("Area")));
paths.push_back(App::ObjectIdentifier(getContainer())
<< App::ObjectIdentifier::Component::SimpleComponent(getName())
<< App::ObjectIdentifier::Component::SimpleComponent(
App::ObjectIdentifier::String("Volume")));
*/
}
void PropertyPostDataObject::Save(Base::Writer& writer) const
{
if (!m_dataObject) {
return;
}
std::string extension;
switch (m_dataObject->GetDataObjectType()) {
case VTK_POLY_DATA:
extension = "vtp";
break;
case VTK_STRUCTURED_GRID:
extension = "vts";
break;
case VTK_RECTILINEAR_GRID:
extension = "vtr";
break;
case VTK_UNSTRUCTURED_GRID:
extension = "vtu";
break;
case VTK_UNIFORM_GRID:
extension = "vti"; // image data
break;
case VTK_MULTIBLOCK_DATA_SET:
extension = "zip";
break;
default:
break;
};
if (!writer.isForceXML()) {
std::string file = "Data." + extension;
writer.Stream() << writer.ind() << "<Data file=\"" << writer.addFile(file.c_str(), this)
<< "\"/>" << std::endl;
}
}
void PropertyPostDataObject::Restore(Base::XMLReader& reader)
{
reader.readElement("Data");
if (!reader.hasAttribute("file")) {
return;
}
std::string file(reader.getAttribute("file"));
if (!file.empty()) {
// initiate a file read
reader.addFile(file.c_str(), this);
}
}
void add_to_zip(Base::FileInfo path, int zip_path_idx, zipios::ZipOutputStream& ZipWriter) {
if (path.isDir()) {
for(auto file : path.getDirectoryContent()) {
add_to_zip(file, zip_path_idx, ZipWriter);
}
}
else {
ZipWriter.putNextEntry(path.filePath().substr(zip_path_idx));
Base::ifstream file(path, std::ios::in | std::ios::binary);
if (file) {
std::streambuf* buf = file.rdbuf();
ZipWriter << buf;
}
}
}
void PropertyPostDataObject::SaveDocFile(Base::Writer& writer) const
{
// If the shape is empty we simply store nothing. The file size will be 0 which
// can be checked when reading in the data.
if (!m_dataObject) {
return;
}
// create a temporary file and copy the content to the zip stream
// once the tmp. filename is known use always the same because otherwise
// we may run into some problems on the Linux platform
static Base::FileInfo fi = Base::FileInfo(App::Application::getTempFileName());
bool success = false;
Base::FileInfo datafolder;
vtkSmartPointer<vtkXMLWriter> xmlWriter;
if (m_dataObject->IsA("vtkMultiBlockDataSet")) {
// create a tmp directory to write in
datafolder = Base::FileInfo(App::Application::getTempPath() + "vtk_datadir");
datafolder.createDirectories();
auto datafile = Base::FileInfo(datafolder.filePath() + "/datafile.vtm");
//create the data: vtm file and subfolder with the subsequent data files
xmlWriter = vtkSmartPointer<vtkXMLMultiBlockDataWriter>::New();
xmlWriter->SetInputDataObject(m_dataObject);
xmlWriter->SetFileName(datafile.filePath().c_str());
xmlWriter->SetDataModeToBinary();
}
else {
xmlWriter = vtkSmartPointer<vtkXMLDataSetWriter>::New();
xmlWriter->SetInputDataObject(m_dataObject);
xmlWriter->SetFileName(fi.filePath().c_str());
xmlWriter->SetDataModeToBinary();
#ifdef VTK_CELL_ARRAY_V2
// Looks like an invalid data object that causes a crash with vtk9
vtkUnstructuredGrid* dataGrid = vtkUnstructuredGrid::SafeDownCast(m_dataObject);
if (dataGrid && (dataGrid->GetPiece() < 0 || dataGrid->GetNumberOfPoints() <= 0)) {
std::cerr << "PropertyPostDataObject::SaveDocFile: ignore empty vtkUnstructuredGrid\n";
return;
}
#endif
}
if (xmlWriter->Write() != 1) {
// Note: Do NOT throw an exception here because if the tmp. file could
// not be created we should not abort.
// We only print an error message but continue writing the next files to the
// stream...
App::PropertyContainer* father = this->getContainer();
if (father && father->isDerivedFrom<App::DocumentObject>()) {
App::DocumentObject* obj = static_cast<App::DocumentObject*>(father);
Base::Console().Error("Dataset of '%s' cannot be written to vtk file '%s'\n",
obj->Label.getValue(),
fi.filePath().c_str());
}
else {
Base::Console().Error("Cannot save vtk file '%s'\n", fi.filePath().c_str());
}
std::stringstream ss;
ss << "Cannot save vtk file '" << fi.filePath() << "'";
writer.addError(ss.str());
}
else if (m_dataObject->IsA("vtkMultiBlockDataSet")) {
// ZIP file we store all data in
zipios::ZipOutputStream ZipWriter(fi.filePath());
ZipWriter.putNextEntry("dummy"); //need to add a dummy first, as the read stream preloads the first entry, and we cannot get the file name...
add_to_zip(datafolder, datafolder.filePath().length(), ZipWriter);
ZipWriter.close();
datafolder.deleteDirectoryRecursive();
}
Base::ifstream file(fi, std::ios::in | std::ios::binary);
if (file) {
std::streambuf* buf = file.rdbuf();
writer.Stream() << buf;
}
file.close();
// remove temp file
fi.deleteFile();
}
void PropertyPostDataObject::RestoreDocFile(Base::Reader& reader)
{
Base::FileInfo xml(reader.getFileName());
// create a temporary file and copy the content from the zip stream
Base::FileInfo fi(App::Application::getTempFileName());
Base::FileInfo fo;
// read in the ASCII file and write back to the file stream
Base::ofstream file(fi, std::ios::out | std::ios::binary);
unsigned long ulSize = 0;
if (reader) {
std::streambuf* buf = file.rdbuf();
reader >> buf;
file.flush();
ulSize = buf->pubseekoff(0, std::ios::cur, std::ios::in);
}
file.close();
// Read the data from the temp file
if (ulSize > 0) {
std::string extension = xml.extension();
// TODO: read in of composite data structures need to be coded,
// including replace of "GetOutputAsDataSet()"
vtkSmartPointer<vtkXMLReader> xmlReader;
if (extension == "vtp") {
xmlReader = vtkSmartPointer<vtkXMLPolyDataReader>::New();
}
else if (extension == "vts") {
xmlReader = vtkSmartPointer<vtkXMLStructuredGridReader>::New();
}
else if (extension == "vtr") {
xmlReader = vtkSmartPointer<vtkXMLRectilinearGridReader>::New();
}
else if (extension == "vtu") {
xmlReader = vtkSmartPointer<vtkXMLUnstructuredGridReader>::New();
}
else if (extension == "vti") {
xmlReader = vtkSmartPointer<vtkXMLImageDataReader>::New();
}
else if (extension == "zip") {
// first unzip the file into a datafolder
zipios::ZipInputStream ZipReader(fi.filePath());
fo = Base::FileInfo(App::Application::getTempPath() + "vtk_extract_datadir");
fo.createDirectories();
try {
zipios::ConstEntryPointer entry = ZipReader.getNextEntry();
while(entry->isValid()) {
Base::FileInfo entry_path(fo.filePath() + entry->getName());
if (entry->isDirectory()) {
// seems not to be called
entry_path.createDirectories();
}
else {
auto entry_dir = Base::FileInfo(entry_path.dirPath());
if(!entry_dir.exists()) {
entry_dir.createDirectories();
}
Base::ofstream file(entry_path, std::ios::out | std::ios::binary);
std::streambuf* buf = file.rdbuf();
ZipReader >> buf;
file.flush();
file.close();
}
entry = ZipReader.getNextEntry();
}
}
catch (const std::exception&) {
// there is no further entry
}
// create the reader, and change the file for it to read. Also delete zip file, not needed anymore
fi.deleteFile();
fi = Base::FileInfo(fo.filePath() + "/datafile.vtm");
xmlReader = vtkSmartPointer<vtkXMLMultiBlockDataReader>::New();
}
xmlReader->SetFileName(fi.filePath().c_str());
xmlReader->Update();
if (!xmlReader->GetOutputDataObject(0)) {
// Note: Do NOT throw an exception here because if the tmp. created file could
// not be read it's NOT an indication for an invalid input stream 'reader'.
// We only print an error message but continue reading the next files from the
// stream...
App::PropertyContainer* father = this->getContainer();
if (father && father->isDerivedFrom<App::DocumentObject>()) {
App::DocumentObject* obj = static_cast<App::DocumentObject*>(father);
Base::Console().Error("Dataset file '%s' with data of '%s' seems to be empty\n",
fi.filePath().c_str(),
obj->Label.getValue());
}
else {
Base::Console().Warning("Loaded Dataset file '%s' seems to be empty\n",
fi.filePath().c_str());
}
}
else {
aboutToSetValue();
createDataObjectByExternalType(xmlReader->GetOutputDataObject(0));
m_dataObject->DeepCopy(xmlReader->GetOutputDataObject(0));
hasSetValue();
}
}
// delete the temp file
fi.deleteFile();
if (xml.extension() == "zip") {
fo.deleteDirectoryRecursive();
}
}
Reference in New Issue View Git Blame Copy Permalink