diff --git a/CMakeExternals/SOFA.cmake b/CMakeExternals/SOFA.cmake index 172c56c17b..d21b109e67 100644 --- a/CMakeExternals/SOFA.cmake +++ b/CMakeExternals/SOFA.cmake @@ -1,227 +1,173 @@ #----------------------------------------------------------------------------- # SOFA #----------------------------------------------------------------------------- if(MITK_USE_SOFA) # Sanity checks if(DEFINED SOFA_DIR AND NOT EXISTS ${SOFA_DIR}) message(FATAL_ERROR "SOFA_DIR variable is defined but corresponds to non-existing directory") endif() function(write_downloadfile_script script_filename remote local md5) file(WRITE ${script_filename} "message(STATUS \"downloading... src='${remote}' dst='${local}'\") file(DOWNLOAD \"${remote}\" \"${local}\" SHOW_PROGRESS EXPECTED_MD5 ${md5} STATUS status LOG log) list(GET status 0 status_code) list(GET status 1 status_string) if(NOT status_code EQUAL 0) message(FATAL_ERROR \"error: downloading '${remote}' failed status_code: \${status_code} status_string: \${status_string} log: \${log}\") endif() message(STATUS \"downloading... done\")") endfunction() function(write_extractfile_script script_filename filename directory) set(args "") if(filename MATCHES "(\\.|=)(bz2|tar\\.gz|tgz|zip)$") set(args "xfz") elseif(filename MATCHES "(\\.|=)tar$") set(args "xf") else() message(SEND_ERROR "error: do not know how to extract '${filename}' -- known types are .bz2, .tar, .tar.gz, .tgz, and .zip") return() endif() file(WRITE ${script_filename} "get_filename_component(filename \"${filename}\" ABSOLUTE) get_filename_component(directory \"${directory}\" ABSOLUTE) message(STATUS \"extracting... src='\${filename}' dst='\${directory}'\") if(NOT EXISTS \"\${filename}\") message(FATAL_ERROR \"error: file to extract does not exists: '\${filename}'\") endif() set(i 0) while(EXISTS \"\${directory}/../tmp-\${i}\") math(EXPR i \"\${i} + 1\") endwhile() set(ut_dir \"\${directory}/../tmp-\${i}\") file(MAKE_DIRECTORY \"\${ut_dir}\") message(STATUS \"extracting... [tar ${args}]\") execute_process(COMMAND \${CMAKE_COMMAND} -E tar ${args} \${filename} WORKING_DIRECTORY \${ut_dir} RESULT_VARIABLE rv) if(NOT rv EQUAL 0) message(STATUS \"extracting... [error clean up]\") file(REMOVE_RECURSE \"\${ut_dir}\") message(FATAL_ERROR \"error: extract of '\${filename}' failed\") endif() message(STATUS \"extracting... [copy]\") file(GLOB contents \"\${ut_dir}/*\") file(COPY \${contents} DESTINATION \${directory}) message(STATUS \"extracting... [clean up]\") file(REMOVE_RECURSE \"\${ut_dir}\") message(STATUS \"extracting... done\")") endfunction() set(proj SOFA) set(proj_DEPENDENCIES) set(SOFA_DEPENDS ${proj}) set(stamp_dir "${CMAKE_BINARY_DIR}/${proj}-cmake/src/${proj}-stamp") set(download_dir "${CMAKE_BINARY_DIR}/${proj}-cmake/src") set(source_dir "${CMAKE_BINARY_DIR}/${proj}-src") set(url_base "http://dl.dropbox.com/u/5822501/") - set(file "sofa-framework-1.0-rc1.zip") - set(md5 "e0f57db0d4c8178afba55c31cf7b6bdc") + set(rev "8935") + set(file "sofa-rev${rev}.zip") + set(md5 "ec5028b9b3ec23293983c4d785325847") write_downloadfile_script( - "${stamp_dir}/download-framework.cmake" + "${stamp_dir}/download-sofa.cmake" "${url_base}${file}" "${download_dir}/${file}" "${md5}" ) write_extractfile_script( - "${stamp_dir}/extract-framework.cmake" + "${stamp_dir}/extract-sofa.cmake" "${download_dir}/${file}" "${source_dir}" ) - set(download_cmd ${CMAKE_COMMAND} -P ${stamp_dir}/download-framework.cmake) - list(APPEND download_cmd ${CMAKE_COMMAND} -P ${stamp_dir}/extract-framework.cmake) + set(download_cmd ${CMAKE_COMMAND} -P ${stamp_dir}/download-sofa.cmake) + list(APPEND download_cmd ${CMAKE_COMMAND} -P ${stamp_dir}/extract-sofa.cmake) - set(file "sofa-modules-1.0-rc1.zip") - set(md5 "27c9d35ea3fd4bbc753ead62f522c6e7") - - write_downloadfile_script( - "${stamp_dir}/download-modules.cmake" - "${url_base}${file}" - "${download_dir}/${file}" - "${md5}" - ) - - write_extractfile_script( - "${stamp_dir}/extract-modules.cmake" - "${download_dir}/${file}" - "${source_dir}" - ) - - list(APPEND download_cmd ${CMAKE_COMMAND} -P ${stamp_dir}/download-modules.cmake) - list(APPEND download_cmd ${CMAKE_COMMAND} -P ${stamp_dir}/extract-modules.cmake) - - if(MSVC) - if(MSVC90) - if(CMAKE_SIZEOF_VOID_P EQUAL 8) - set(file "sofa-dependencies-win64-msvc-2008-1.0-rc1.zip") - set(md5 "5aaf89c36bbd6b87f8c5784a505bf789") - else() - set(file "sofa-dependencies-win32-msvc-2008-1.0-rc1.zip") - set(md5 "b4240694393bd5014f1870a394e84d38") - endif() - elseif(MSVC10) - if(CMAKE_SIZEOF_VOID_P EQUAL 8) - set(file "dependencies-win64-msvc-2010-1.0-rc1.zip") - set(md5 "57014882593b28e3b3e5a4fa85803776") - else() - set(file "dependencies-win32-msvc-2010-1.0-rc1.zip") - set(md5 "b6de57312d36d5bd56980ef0284b9ab9") - endif() - endif() - - write_downloadfile_script( - "${stamp_dir}/download-dependencies.cmake" - "${url_base}${file}" - "${download_dir}/${file}" - "${md5}" - ) - - write_extractfile_script( - "${stamp_dir}/extract-dependencies.cmake" - "${download_dir}/${file}" - "${source_dir}" - ) - - list(APPEND download_cmd ${CMAKE_COMMAND} -P ${stamp_dir}/download-dependencies.cmake) - list(APPEND download_cmd ${CMAKE_COMMAND} -P ${stamp_dir}/extract-dependencies.cmake) - endif() - - set(file "sofa-patch-1.0-rc1.zip") - set(md5 "b6c112c94dbca92ca5bec894e9bfa18e") + set(file "sofa-rev${rev}-patch.zip") + set(md5 "34709f71ad134502ca2cec68737f1883") write_downloadfile_script( "${stamp_dir}/download-patch.cmake" "${url_base}${file}" "${download_dir}/${file}" "${md5}" ) write_extractfile_script( "${stamp_dir}/extract-patch.cmake" "${download_dir}/${file}" "${source_dir}" ) list(APPEND download_cmd ${CMAKE_COMMAND} -P ${stamp_dir}/download-patch.cmake) list(APPEND download_cmd ${CMAKE_COMMAND} -P ${stamp_dir}/extract-patch.cmake) - set(file "sofa-cmake-1.0-rc1.zip") - set(md5 "41fc95b1a51a404c28eac5860932b017") + set(file "sofa-rev${rev}-cmake.zip") + set(md5 "bc49343e153ff0eec563d20dc0bbd91f") write_downloadfile_script( "${stamp_dir}/download-cmake.cmake" "${url_base}${file}" "${download_dir}/${file}" "${md5}" ) write_extractfile_script( "${stamp_dir}/extract-cmake.cmake" "${download_dir}/${file}" "${source_dir}" ) list(APPEND download_cmd ${CMAKE_COMMAND} -P ${stamp_dir}/download-cmake.cmake) list(APPEND download_cmd ${CMAKE_COMMAND} -P ${stamp_dir}/extract-cmake.cmake) if(NOT DEFINED SOFA_DIR) ExternalProject_Add(${proj} SOURCE_DIR ${source_dir} BINARY_DIR ${proj}-build PREFIX ${proj}-cmake DOWNLOAD_COMMAND "${download_cmd}" INSTALL_COMMAND "" CMAKE_GENERATOR ${gen} CMAKE_ARGS ${ep_common_args} ${additional_cmake_args} DEPENDS ${proj_DEPENDENCIES} ) set(SOFA_DIR ${CMAKE_CURRENT_BINARY_DIR}/${proj}-build) else() mitkMacroEmptyExternalProject(${proj} "${proj}_DEPENDENCIES}") endif() endif() diff --git a/Modules/Simulation/mitkSimulation.cpp b/Modules/Simulation/mitkSimulation.cpp index 56ca9f0788..181bd9f969 100644 --- a/Modules/Simulation/mitkSimulation.cpp +++ b/Modules/Simulation/mitkSimulation.cpp @@ -1,155 +1,158 @@ /*=================================================================== The Medical Imaging Interaction Toolkit (MITK) Copyright (c) German Cancer Research Center, Division of Medical and Biological Informatics. All rights reserved. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See LICENSE.txt or http://www.mitk.org for details. ===================================================================*/ #include "mitkSimulation.h" +#include +#include +#include #include const float mitk::Simulation::ScaleFactor = 1000.0f; -static sofa::simulation::Simulation::SPtr CreateSimulation() +static sofa::simulation::Simulation::SPtr CreateSimulation(mitk::Simulation::SimulationType type = mitk::Simulation::Tree) { - std::string key = "MultiMappingObject"; - - if (sofa::simulation::xml::BaseElement::NodeFactory::HasKey(key)) - sofa::simulation::xml::BaseElement::NodeFactory::ResetEntry(key); - - return sofa::core::objectmodel::New(); + if (type == mitk::Simulation::DAG) + return sofa::core::objectmodel::New(); + else if (type == mitk::Simulation::Bgl) + return sofa::core::objectmodel::New(); + else + return sofa::core::objectmodel::New(); } void mitk::Simulation::SetActiveSimulation(mitk::Simulation* simulation) { if (simulation == NULL) { sofa::simulation::setSimulation(NULL); sofa::core::visual::VisualParams::defaultInstance()->drawTool() = NULL; } else { sofa::simulation::Simulation* sofaSimulation = simulation->m_Simulation.get(); if (sofa::simulation::getSimulation() != sofaSimulation) { sofa::simulation::setSimulation(sofaSimulation); sofa::core::visual::VisualParams::defaultInstance()->drawTool() = &simulation->m_DrawTool; } } } mitk::Simulation::Simulation() : m_Simulation(CreateSimulation()), m_DefaultDT(0.0) { } mitk::Simulation::~Simulation() { if (m_Simulation != NULL) { if (m_RootNode != NULL) m_Simulation->unload(m_RootNode); if (sofa::simulation::getSimulation() == m_Simulation.get()) SetActiveSimulation(NULL); } } double mitk::Simulation::GetDefaultDT() const { return m_DefaultDT; } mitk::SimulationDrawTool* mitk::Simulation::GetDrawTool() { return &m_DrawTool; } sofa::simulation::Node::SPtr mitk::Simulation::GetRootNode() const { return m_RootNode; } sofa::simulation::Simulation::SPtr mitk::Simulation::GetSimulation() const { return m_Simulation; } bool mitk::Simulation::RequestedRegionIsOutsideOfTheBufferedRegion() { return false; } void mitk::Simulation::SetAsActiveSimulation() { SetActiveSimulation(this); } void mitk::Simulation::SetDefaultDT(double dt) { m_DefaultDT = std::max(0.0, dt); } void mitk::Simulation::SetRequestedRegion(itk::DataObject*) { } void mitk::Simulation::SetRequestedRegionToLargestPossibleRegion() { } void mitk::Simulation::SetRootNode(sofa::simulation::Node* rootNode) { m_RootNode.reset(rootNode); } void mitk::Simulation::UpdateOutputInformation() { if (this->GetSource().IsNotNull()) this->GetSource()->UpdateOutputInformation(); if (m_RootNode != NULL) { const sofa::defaulttype::BoundingBox& boundingBox = m_RootNode->f_bbox.getValue(); const sofa::defaulttype::Vector3& min = boundingBox.minBBox(); const sofa::defaulttype::Vector3& max = boundingBox.maxBBox(); mitk::Geometry3D::BoundsArrayType bounds; bounds[0] = static_cast(min.x() * ScaleFactor); bounds[1] = static_cast(max.x() * ScaleFactor); bounds[2] = static_cast(min.y() * ScaleFactor); bounds[3] = static_cast(max.y() * ScaleFactor); bounds[4] = static_cast(min.z() * ScaleFactor); bounds[5] = static_cast(max.z() * ScaleFactor); if(this->GetGeometry() != NULL) { this->GetGeometry()->SetBounds(bounds); } else { Geometry3D::Pointer geometry = Geometry3D::New(); geometry->SetBounds(bounds); this->SetGeometry(geometry); } } this->GetTimeSlicedGeometry()->UpdateInformation(); } bool mitk::Simulation::VerifyRequestedRegion() { return true; } diff --git a/Modules/Simulation/mitkSimulation.h b/Modules/Simulation/mitkSimulation.h index 4625283c2f..e0324cf73c 100644 --- a/Modules/Simulation/mitkSimulation.h +++ b/Modules/Simulation/mitkSimulation.h @@ -1,64 +1,71 @@ /*=================================================================== The Medical Imaging Interaction Toolkit (MITK) Copyright (c) German Cancer Research Center, Division of Medical and Biological Informatics. All rights reserved. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See LICENSE.txt or http://www.mitk.org for details. ===================================================================*/ #ifndef mitkSimulation_h #define mitkSimulation_h #include "mitkSimulationDrawTool.h" #include #include #include namespace mitk { class Simulation_EXPORT Simulation : public BaseData { public: + enum SimulationType + { + Tree, + DAG, + Bgl + }; + mitkClassMacro(Simulation, BaseData); itkNewMacro(Self); static void SetActiveSimulation(Self* simulation); static const float ScaleFactor; double GetDefaultDT() const; SimulationDrawTool* GetDrawTool(); sofa::simulation::Node::SPtr GetRootNode() const; sofa::simulation::Simulation::SPtr GetSimulation() const; bool RequestedRegionIsOutsideOfTheBufferedRegion(); void SetAsActiveSimulation(); void SetDefaultDT(double dt); void SetRequestedRegion(itk::DataObject* data); void SetRequestedRegionToLargestPossibleRegion(); void SetRootNode(sofa::simulation::Node* rootNode); void UpdateOutputInformation(); bool VerifyRequestedRegion(); private: Simulation(); ~Simulation(); Simulation(Self&); Self& operator=(const Self&); sofa::simulation::Simulation::SPtr m_Simulation; sofa::simulation::Node::SPtr m_RootNode; SimulationDrawTool m_DrawTool; double m_DefaultDT; }; } #endif diff --git a/Modules/Simulation/mitkSimulationDrawTool.cpp b/Modules/Simulation/mitkSimulationDrawTool.cpp index ee6221a1da..941dbdf00e 100644 --- a/Modules/Simulation/mitkSimulationDrawTool.cpp +++ b/Modules/Simulation/mitkSimulationDrawTool.cpp @@ -1,619 +1,627 @@ /*=================================================================== The Medical Imaging Interaction Toolkit (MITK) Copyright (c) German Cancer Research Center, Division of Medical and Biological Informatics. All rights reserved. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See LICENSE.txt or http://www.mitk.org for details. ===================================================================*/ #include "mitkSimulation.h" #include "mitkSimulationDrawTool.h" #include #include #include #include #include #include #include #include #include #include #include #include mitk::SimulationDrawTool::SimulationDrawTool() : m_PolygonMode(0), m_Wireframe(false), m_Update(true) { } mitk::SimulationDrawTool::~SimulationDrawTool() { this->DeleteVtkObjects(); } void mitk::SimulationDrawTool::DeleteVtkObjects() { for (std::vector::const_iterator object = m_VtkObjects.begin(); object != m_VtkObjects.end(); ++object) (*object)->Delete(); m_VtkObjects.clear(); for (std::vector::const_iterator actor = m_Actors.begin(); actor != m_Actors.end(); ++actor) (*actor)->Delete(); m_Actors.clear(); } void mitk::SimulationDrawTool::DisableUpdate() { m_Update = false; } std::vector mitk::SimulationDrawTool::GetActors() const { return m_Actors; } void mitk::SimulationDrawTool::InitProperty(vtkProperty* property) const { if (m_Wireframe) property->SetRepresentationToWireframe(); else property->SetRepresentationToSurface(); } void mitk::SimulationDrawTool::Reset() { this->DeleteVtkObjects(); m_Update = true; } void mitk::SimulationDrawTool::drawPoints(const std::vector& points, float pointSize, const Vec4f color) { if (!m_Update || points.empty()) return; unsigned int numPoints = points.size(); vtkPoints* vtkPoints = vtkPoints::New(); vtkPoints->SetNumberOfPoints(numPoints); vtkCellArray* cellArray = vtkCellArray::New(); for (unsigned int i = 0; i < numPoints; ++i) { vtkPoints->SetPoint(i, points[i].elems); cellArray->InsertNextCell(1); cellArray->InsertCellPoint(i); } vtkPolyData* polyData = vtkPolyData::New(); polyData->SetPoints(vtkPoints); polyData->SetVerts(cellArray); vtkPoints->Delete(); cellArray->Delete(); vtkPolyDataMapper* polyDataMapper = vtkPolyDataMapper::New(); polyDataMapper->SetInput(polyData); vtkActor* actor = vtkActor::New(); actor->SetMapper(polyDataMapper); actor->SetScale(Simulation::ScaleFactor); vtkProperty* property = actor->GetProperty(); property->SetColor(color.x(), color.y(), color.z()); property->SetPointSize(pointSize); m_VtkObjects.push_back(polyData); m_VtkObjects.push_back(polyDataMapper); m_Actors.push_back(actor); } void mitk::SimulationDrawTool::drawLines(const std::vector& points, float lineWidth, const Vec4f color) { if (!m_Update || points.empty()) return; unsigned int numPoints = points.size(); std::vector indices; for (unsigned int i = 0; i < numPoints; i += 2) indices.push_back(Vec2i(i, i + 1)); this->drawLines(points, indices, lineWidth, color); } void mitk::SimulationDrawTool::drawLines(const std::vector& points, const std::vector& indices, float lineWidth, const Vec4f color) { if (!m_Update || points.empty()) return; unsigned int numPoints = points.size(); vtkPoints* vtkPoints = vtkPoints::New(); vtkPoints->SetNumberOfPoints(numPoints); for (unsigned int i = 0; i < numPoints; ++i) vtkPoints->SetPoint(i, points[i].elems); vtkPolyData* polyData = vtkPolyData::New(); polyData->SetPoints(vtkPoints); vtkPoints->Delete(); vtkCellArray* lines = vtkCellArray::New(); unsigned int numIndices = indices.size(); for (unsigned int i = 0; i < numIndices; ++i) { lines->InsertNextCell(2); lines->InsertCellPoint(indices[i].elems[0]); lines->InsertCellPoint(indices[i].elems[1]); } polyData->SetLines(lines); lines->Delete(); vtkPolyDataMapper* polyDataMapper = vtkPolyDataMapper::New(); polyDataMapper->SetInput(polyData); vtkActor* actor = vtkActor::New(); actor->SetMapper(polyDataMapper); actor->SetScale(Simulation::ScaleFactor); vtkProperty* property = actor->GetProperty(); property->SetLineWidth(lineWidth); property->SetColor(color.x(), color.y(), color.z()); m_VtkObjects.push_back(polyData); m_VtkObjects.push_back(polyDataMapper); m_Actors.push_back(actor); } void mitk::SimulationDrawTool::drawTriangles(const std::vector& points, const Vec4f color) { if (!m_Update || points.empty()) return; unsigned int numPoints = points.size(); vtkPoints* vtkPoints = vtkPoints::New(); vtkPoints->SetNumberOfPoints(numPoints); for (unsigned int i = 0; i < numPoints; ++i) vtkPoints->SetPoint(i, points[i].elems); vtkPolyData* polyData = vtkPolyData::New(); polyData->SetPoints(vtkPoints); vtkPoints->Delete(); vtkCellArray* triangles = vtkCellArray::New(); for (unsigned int i = 0; i < points.size(); i += 3) { triangles->InsertNextCell(3); triangles->InsertCellPoint(i); triangles->InsertCellPoint(i + 1); triangles->InsertCellPoint(i + 2); } polyData->SetPolys(triangles); triangles->Delete(); vtkPolyDataNormals* polyDataNormals = vtkPolyDataNormals::New(); polyDataNormals->ComputeCellNormalsOff(); polyDataNormals->SetInput(polyData); polyDataNormals->SplittingOff(); vtkPolyDataMapper* polyDataMapper = vtkPolyDataMapper::New(); polyDataMapper->SetInput(polyDataNormals->GetOutput()); vtkActor* actor = vtkActor::New(); actor->SetMapper(polyDataMapper); actor->SetScale(Simulation::ScaleFactor); vtkProperty* property = actor->GetProperty(); this->InitProperty(property); property->SetColor(color.x(), color.y(), color.z()); m_VtkObjects.push_back(polyData); m_VtkObjects.push_back(polyDataMapper); m_VtkObjects.push_back(polyDataNormals); m_Actors.push_back(actor); } void mitk::SimulationDrawTool::drawTriangles(const std::vector& points, const Vector3 normal, const Vec4f color) { if (!m_Update || points.empty()) return; unsigned int numPoints = points.size(); vtkPoints* vtkPoints = vtkPoints::New(); vtkPoints->SetNumberOfPoints(numPoints); for (unsigned int i = 0; i < numPoints; ++i) vtkPoints->SetPoint(i, points[i].elems); vtkPolyData* polyData = vtkPolyData::New(); polyData->SetPoints(vtkPoints); vtkPoints->Delete(); vtkCellArray* triangles = vtkCellArray::New(); for (unsigned int i = 0; i < points.size(); i += 3) { triangles->InsertNextCell(3); triangles->InsertCellPoint(i); triangles->InsertCellPoint(i + 1); triangles->InsertCellPoint(i + 2); } polyData->SetPolys(triangles); triangles->Delete(); vtkFloatArray* normals = vtkFloatArray::New(); normals->SetNumberOfComponents(3); normals->SetName("Normals"); for (int i = 0; i < numPoints; i += 3) normals->InsertNextTuple(normal.elems); polyData->GetCellData()->SetNormals(normals); normals->Delete(); vtkPolyDataMapper* polyDataMapper = vtkPolyDataMapper::New(); polyDataMapper->SetInput(polyData); vtkActor* actor = vtkActor::New(); actor->SetMapper(polyDataMapper); actor->SetScale(Simulation::ScaleFactor); vtkProperty* property = actor->GetProperty(); this->InitProperty(property); property->SetColor(color.x(), color.y(), color.z()); m_VtkObjects.push_back(polyData); m_VtkObjects.push_back(polyDataMapper); m_Actors.push_back(actor); } void mitk::SimulationDrawTool::drawTriangles(const std::vector& points, const std::vector& indices, const std::vector& normals, const Vec4f color) { if (!m_Update || points.empty() || indices.empty() || normals.empty()) return; unsigned int numPoints = points.size(); vtkPoints* vtkPoints = vtkPoints::New(); vtkPoints->SetNumberOfPoints(numPoints); for (unsigned int i = 0; i < numPoints; ++i) vtkPoints->SetPoint(i, points[i].elems); vtkPolyData* polyData = vtkPolyData::New(); polyData->SetPoints(vtkPoints); vtkPoints->Delete(); vtkCellArray* triangles = vtkCellArray::New(); unsigned int numIndices = indices.size(); for (unsigned int i = 0; i < numIndices; ++i) { triangles->InsertNextCell(3); triangles->InsertCellPoint(indices[i].elems[0]); triangles->InsertCellPoint(indices[i].elems[1]); triangles->InsertCellPoint(indices[i].elems[2]); } polyData->SetPolys(triangles); triangles->Delete(); unsigned int numNormals = normals.size(); vtkFloatArray* vtkNormals = vtkFloatArray::New(); vtkNormals->SetNumberOfComponents(3); vtkNormals->SetName("Normals"); for (int i = 0; i < numNormals; ++i) vtkNormals->InsertNextTuple(normals[i].elems); polyData->GetCellData()->SetNormals(vtkNormals); vtkNormals->Delete(); vtkPolyDataMapper* polyDataMapper = vtkPolyDataMapper::New(); polyDataMapper->SetInput(polyData); vtkActor* actor = vtkActor::New(); actor->SetMapper(polyDataMapper); actor->SetScale(Simulation::ScaleFactor); vtkProperty* property = actor->GetProperty(); this->InitProperty(property); property->SetColor(color.x(), color.y(), color.z()); m_VtkObjects.push_back(polyData); m_VtkObjects.push_back(polyDataMapper); m_Actors.push_back(actor); } void mitk::SimulationDrawTool::drawTriangles(const std::vector&, const std::vector&, const std::vector&) { } void mitk::SimulationDrawTool::drawTriangleStrip(const std::vector&, const std::vector&, const Vec4f) { } void mitk::SimulationDrawTool::drawTriangleFan(const std::vector&, const std::vector&, const Vec4f) { } void mitk::SimulationDrawTool::drawFrame(const Vector3& position, const Quaternion& orientation, const Vec3f& size) { if (!m_Update) return; const float radius = 0.05f; bool wireframeBackup = m_Wireframe; m_Wireframe = false; std::vector colors; colors.push_back(Vec4f(0.0f, 0.0f, 1.0f, 1.0f)); colors.push_back(Vec4f(0.0f, 1.0f, 0.0f, 1.0f)); colors.push_back(Vec4f(1.0f, 0.0f, 0.0f, 1.0f)); if (size.x() != 0.0f) { Vector3 point2 = position + orientation.rotate(Vec3f(size.x(), 0.0f, 0.0f)); this->drawArrow(position, point2, radius, colors.back()); colors.pop_back(); } if (size.y() != 0.0f) { Vector3 point2 = position + orientation.rotate(Vec3f(0.0f, size.y(), 0.0f)); this->drawArrow(position, point2, radius, colors.back()); colors.pop_back(); } if (size.z() != 0.0f) { Vector3 point2 = position + orientation.rotate(Vec3f(0.0f, 0.0f, size.z())); this->drawArrow(position, point2, radius, colors.back()); } m_Wireframe = wireframeBackup; } void mitk::SimulationDrawTool::drawSpheres(const std::vector& points, const std::vector& radii, const Vec4f color) { if (!m_Update || points.empty()) return; unsigned int numSpheres = points.size(); for (unsigned int i = 0; i < numSpheres; ++i) { vtkSphereSource *sphereSource = vtkSphereSource::New(); sphereSource->SetCenter(const_cast(points[i].elems)); sphereSource->SetRadius(radii[i]); sphereSource->SetPhiResolution(16); sphereSource->SetThetaResolution(32); sphereSource->LatLongTessellationOn(); vtkPolyDataMapper* polyDataMapper = vtkPolyDataMapper::New(); polyDataMapper->SetInput(sphereSource->GetOutput()); vtkActor* actor = vtkActor::New(); actor->SetMapper(polyDataMapper); actor->SetScale(Simulation::ScaleFactor); vtkProperty* property = actor->GetProperty(); this->InitProperty(property); property->SetColor(color.x(), color.y(), color.z()); m_VtkObjects.push_back(sphereSource); m_VtkObjects.push_back(polyDataMapper); m_Actors.push_back(actor); } } void mitk::SimulationDrawTool::drawSpheres(const std::vector& points, float radius, const Vec4f color) { if (!m_Update || points.empty()) return; unsigned int numPoints = points.size(); std::vector radii(numPoints, radius); this->drawSpheres(points, radii, color); } void mitk::SimulationDrawTool::drawCone(const Vector3& point1, const Vector3& point2, float radius1, float radius2, const Vec4f color, int subdivisions) { if (!m_Update) return; vtkPoints* points = vtkPoints::New(); points->SetNumberOfPoints(2); points->SetPoint(0, point1.elems); points->SetPoint(1, point2.elems); vtkCellArray* line = vtkCellArray::New(); line->InsertNextCell(2); line->InsertCellPoint(0); line->InsertCellPoint(1); vtkPolyData* polyData = vtkPolyData::New(); polyData->SetPoints(points); polyData->SetLines(line); points->Delete(); line->Delete(); const char* radiiName = "Radii"; vtkFloatArray* radii = vtkFloatArray::New(); radii->SetName(radiiName); radii->SetNumberOfTuples(2); radii->SetTuple1(0, radius1); radii->SetTuple1(1, radius2); vtkPointData* pointData = polyData->GetPointData(); pointData->AddArray(radii); pointData->SetActiveScalars(radiiName); radii->Delete(); vtkTubeFilter* tubeFilter = vtkTubeFilter::New(); tubeFilter->SetInput(polyData); tubeFilter->CappingOn(); tubeFilter->SetNumberOfSides(subdivisions); tubeFilter->SetVaryRadiusToVaryRadiusByAbsoluteScalar(); vtkPolyDataMapper* polyDataMapper = vtkPolyDataMapper::New(); polyDataMapper->SetInput(tubeFilter->GetOutput()); polyDataMapper->ScalarVisibilityOff(); vtkActor* actor = vtkActor::New(); actor->SetMapper(polyDataMapper); actor->SetScale(Simulation::ScaleFactor); vtkProperty* property = actor->GetProperty(); this->InitProperty(property); property->SetColor(color.x(), color.y(), color.z()); m_VtkObjects.push_back(polyData); m_VtkObjects.push_back(tubeFilter); m_VtkObjects.push_back(polyDataMapper); m_Actors.push_back(actor); } void mitk::SimulationDrawTool::drawCube(const float&, const Vec4f&, const int&) { } void mitk::SimulationDrawTool::drawCylinder(const Vector3& point1, const Vector3& point2, float radius, const Vec4f color, int subdivisions) { if (!m_Update) return; this->drawCone(point1, point2, radius, radius, color, subdivisions); } +void mitk::SimulationDrawTool::drawCapsule(const Vector3&, const Vector3&, float, const Vec4f, int) +{ +} + void mitk::SimulationDrawTool::drawArrow(const Vector3& point1, const Vector3& point2, float radius, const Vec4f color, int subdivisions) { if (!m_Update) return; Vector3 point3 = point1 * 0.2f + point2 * 0.8f; this->drawCylinder(point1, point3, radius, color, subdivisions); this->drawCone(point3, point2, radius * 2.5f, 0.0f, color, subdivisions); } void mitk::SimulationDrawTool::drawPlus(const float& edgeRadius, const Vec4f& color, const int& subdivisions) { if (!m_Update) return; this->drawCylinder(Vector3(-1.0, 0.0, 0.0), Vector3(1.0, 0.0, 0.0), edgeRadius, color, subdivisions); this->drawCylinder(Vector3(0.0, -1.0, 0.0), Vector3(0.0, 1.0, 0.0), edgeRadius, color, subdivisions); this->drawCylinder(Vector3(0.0, 0.0, -1.0), Vector3(0.0, 0.0, 1.0), edgeRadius, color, subdivisions); } void mitk::SimulationDrawTool::drawPoint(const Vector3&, const Vec4f&) { } void mitk::SimulationDrawTool::drawPoint(const Vector3&, const Vector3&, const Vec4f&) { } +void mitk::SimulationDrawTool::drawTriangle(const Vector3&, const Vector3&, const Vector3&, const Vector3&) +{ +} + void mitk::SimulationDrawTool::drawTriangle(const Vector3&, const Vector3&, const Vector3&, const Vector3&, const Vec4f&) { } void mitk::SimulationDrawTool::drawTriangle(const Vector3&, const Vector3&, const Vector3&, const Vector3&, const Vec4f&, const Vec4f&, const Vec4f&) { } void mitk::SimulationDrawTool::drawSphere(const Vector3&, float) { } void mitk::SimulationDrawTool::pushMatrix() { } void mitk::SimulationDrawTool::popMatrix() { } void mitk::SimulationDrawTool::multMatrix(float*) { } void mitk::SimulationDrawTool::scale(float) { } void mitk::SimulationDrawTool::setMaterial(const Vec4f&, std::string) { } void mitk::SimulationDrawTool::resetMaterial(const Vec4f&, std::string) { } void mitk::SimulationDrawTool::setPolygonMode(int mode, bool wireframe) { if (!m_Update) return; m_PolygonMode = mode; m_Wireframe = wireframe; } void mitk::SimulationDrawTool::setLightingEnabled(bool) { } -void mitk::SimulationDrawTool::clear() +void mitk::SimulationDrawTool::writeOverlayText(int, int, unsigned int, const Vec4f&, const char*) { } diff --git a/Modules/Simulation/mitkSimulationDrawTool.h b/Modules/Simulation/mitkSimulationDrawTool.h index 0cfbb8f947..519b39c82b 100644 --- a/Modules/Simulation/mitkSimulationDrawTool.h +++ b/Modules/Simulation/mitkSimulationDrawTool.h @@ -1,107 +1,109 @@ /*=================================================================== The Medical Imaging Interaction Toolkit (MITK) Copyright (c) German Cancer Research Center, Division of Medical and Biological Informatics. All rights reserved. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See LICENSE.txt or http://www.mitk.org for details. ===================================================================*/ #ifndef mitkSimulationDrawTool_h #define mitkSimulationDrawTool_h #include #include class vtkActor; class vtkObjectBase; class vtkProperty; namespace mitk { /** \brief Utility class used by SOFA classes to draw objects other than visual models. * * Implements the sofa::core::visual::DrawTool interface and replaces the default SOFA OpenGL implementation sofa::core::visual::DrawToolGL. * All draw methods create a VTK actor and append it to an internal list which can be queried by calling GetActors() to finally draw them. * In contrary to the original concept of DrawToolGL, which is set once during initialization of SOFA applications, every mitk::Simulation has its own exclusive copy of mitk::SimulationDrawTool. * Since SOFA can handle only a single DrawTool at once it must be ensured that the correct mitk::SimulationDrawTool is set when switching the active simulation. * * Each draw method checks if it is necessary to generate a new up-to-date VTK actor, i.e. after a simulation step, or if it is sufficient to use the already generated one. * This decision is controlled through the methods Reset() and DisableUpdate(). * The former method must be called right before a simulation step and mitk::SimulationMapper3D calls the latter method during rendering to disable unnecessary updates until the next simulation step. */ class Simulation_EXPORT SimulationDrawTool : public sofa::core::visual::DrawTool { public: SimulationDrawTool(); ~SimulationDrawTool(); /** \brief Disables creation of new VTK actors when calling draw methods. */ void DisableUpdate(); /** \brief Returns current list of VTK actors which were generated by draw methods since the last reset. * * \note Do not delete the VTK actors returned by this method. */ std::vector GetActors() const; /** \brief Clears internal lists of current VTK objects and enables creation of new VTK actors when calling draw methods. */ void Reset(); void drawPoints(const std::vector& points, float pointSize, const Vec4f color = Vec4f(1.0f, 1.0f, 1.0f, 1.0f)); void drawLines(const std::vector& points, float lineWidth, const Vec4f color = Vec4f(1.0f, 1.0f, 1.0f, 1.0f)); void drawLines(const std::vector& points, const std::vector& indices, float lineWidth, const Vec4f color = Vec4f(1.0f, 1.0f, 1.0f, 1.0f)); void drawTriangles(const std::vector& points, const Vec4f color = Vec4f(1.0f, 1.0f, 1.0f, 1.0f)); void drawTriangles(const std::vector& points, const Vector3 normal, const Vec4f color = Vec4f(1.0f, 1.0f, 1.0f, 1.0f)); void drawTriangles(const std::vector& points, const std::vector& indices, const std::vector& normals, const Vec4f color = Vec4f(1.0f, 1.0f, 1.0f, 1.0f)); void drawTriangles(const std::vector& points, const std::vector& normals, const std::vector& colors); void drawTriangleStrip(const std::vector& points, const std::vector& normals, const Vec4f color = Vec4f(1.0f, 1.0f, 1.0f, 1.0f)); void drawTriangleFan(const std::vector& points, const std::vector& normals, const Vec4f color = Vec4f(1.0f, 1.0f, 1.0f, 1.0f)); void drawFrame(const Vector3& position, const Quaternion& orientation, const Vec3f& size); void drawSpheres(const std::vector& points, const std::vector& radii, const Vec4f color = Vec4f(1.0f, 1.0f, 1.0f, 1.0f)); void drawSpheres(const std::vector& points, float radius, const Vec4f color = Vec4f(1.0f, 1.0f, 1.0f, 1.0f)); void drawCone(const Vector3& point1, const Vector3& point2, float radius1, float radius2, const Vec4f color = Vec4f(1.0f, 1.0f, 1.0f, 1.0f), int subdivisions = 16); void drawCube(const float& edgeRadius, const Vec4f& color = Vec4f(1.0f, 1.0f, 1.0f, 1.0f), const int& subdivisions = 16); void drawCylinder(const Vector3& point1, const Vector3& point2, float radius, const Vec4f color = Vec4f(1.0f, 1.0f, 1.0f, 1.0f), int subdivisions = 16); + void drawCapsule(const Vector3& point1, const Vector3& point2, float radius, const Vec4f color = Vec4f(1.0f, 1.0f, 1.0f, 1.0f), int subdivisions = 16); void drawArrow(const Vector3& point1, const Vector3& point2, float radius, const Vec4f color = Vec4f(1.0f, 1.0f, 1.0f, 1.0f), int subdivisions = 16); void drawPlus(const float& edgeRadius, const Vec4f& color = Vec4f(1.0f, 1.0f, 1.0f, 1.0f), const int& subdivisions = 16); void drawPoint(const Vector3& position, const Vec4f& color = Vec4f(1.0f, 1.0f, 1.0f, 1.0f)); void drawPoint(const Vector3& position, const Vector3& normal, const Vec4f& color = Vec4f(1.0f, 1.0f, 1.0f, 1.0f)); + void drawTriangle(const Vector3& point1, const Vector3& point2, const Vector3& point3, const Vector3& normal); void drawTriangle(const Vector3& point1, const Vector3& point2, const Vector3& point3, const Vector3& normal, const Vec4f& color = Vec4f(1.0f, 1.0f, 1.0f, 1.0f)); void drawTriangle(const Vector3& point1, const Vector3& point2, const Vector3& point3, const Vector3& normal, const Vec4f& color1, const Vec4f& color2, const Vec4f& color3); void drawSphere(const Vector3& position, float radius); void pushMatrix(); void popMatrix(); void multMatrix(float* matrix); void scale(float factor); void setMaterial(const Vec4f& color, std::string name = ""); void resetMaterial(const Vec4f& color, std::string name = ""); void setPolygonMode(int mode, bool wireframe); void setLightingEnabled(bool isEnabled); - void clear(); + void writeOverlayText(int x, int y, unsigned int fontSize, const Vec4f& color, const char* text); private: SimulationDrawTool(const SimulationDrawTool&); SimulationDrawTool& operator=(const SimulationDrawTool&); void DeleteVtkObjects(); void InitProperty(vtkProperty* property) const; std::vector m_VtkObjects; std::vector m_Actors; int m_PolygonMode; bool m_Wireframe; bool m_Update; }; } #endif diff --git a/Modules/Simulation/mitkSimulationMapper3D.cpp b/Modules/Simulation/mitkSimulationMapper3D.cpp index 51be5f65d0..fc65b28ae7 100644 --- a/Modules/Simulation/mitkSimulationMapper3D.cpp +++ b/Modules/Simulation/mitkSimulationMapper3D.cpp @@ -1,241 +1,242 @@ /*=================================================================== The Medical Imaging Interaction Toolkit (MITK) Copyright (c) German Cancer Research Center, Division of Medical and Biological Informatics. All rights reserved. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See LICENSE.txt or http://www.mitk.org for details. ===================================================================*/ #include "mitkSimulation.h" #include "mitkSimulationMapper3D.h" #include "mitkSimulationModel.h" #include "mitkSimulationPropAssemblyVisitor.h" #include +#include mitk::SimulationMapper3D::LocalStorage::LocalStorage() : m_VtkProp(vtkSmartPointer::New()) { } mitk::SimulationMapper3D::LocalStorage::~LocalStorage() { } void mitk::SimulationMapper3D::SetDefaultProperties(DataNode* node, BaseRenderer* renderer, bool overwrite) { if (node != NULL) { mitk::Simulation* simulation = dynamic_cast(node->GetData()); if (simulation != NULL) { sofa::simulation::Node::SPtr rootNode = simulation->GetRootNode(); sofa::component::visualmodel::VisualStyle::SPtr visualStyle; rootNode->get(visualStyle); if (!visualStyle) { visualStyle = sofa::core::objectmodel::New(); sofa::core::visual::DisplayFlags* displayFlags = visualStyle->displayFlags.beginEdit(); displayFlags->setShowVisualModels(); visualStyle->displayFlags.endEdit(); rootNode->addObject(visualStyle); } const sofa::core::visual::DisplayFlags& displayFlags = visualStyle->displayFlags.getValue(); node->AddProperty("Simulation.Behavior.Behavior Models", BoolProperty::New(displayFlags.getShowBehaviorModels()), renderer, overwrite); node->AddProperty("Simulation.Behavior.Force Fields", BoolProperty::New(displayFlags.getShowForceFields()), renderer, overwrite); node->AddProperty("Simulation.Behavior.Interactions", BoolProperty::New(displayFlags.getShowInteractionForceFields()), renderer, overwrite); node->AddProperty("Simulation.Collision.Bounding Trees", BoolProperty::New(displayFlags.getShowBoundingCollisionModels()), renderer, overwrite); node->AddProperty("Simulation.Collision.Collision Models", BoolProperty::New(displayFlags.getShowCollisionModels()), renderer, overwrite); node->AddProperty("Simulation.Mapping.Mechanical Mappings", BoolProperty::New(displayFlags.getShowMechanicalMappings()), renderer, overwrite); node->AddProperty("Simulation.Mapping.Visual Mappings", BoolProperty::New(displayFlags.getShowMappings()), renderer, overwrite); node->AddProperty("Simulation.Options.Normals", BoolProperty::New(displayFlags.getShowNormals()), renderer, overwrite); node->AddProperty("Simulation.Options.Wire Frame", BoolProperty::New(displayFlags.getShowWireFrame()), renderer, overwrite); node->AddProperty("Simulation.Visual.Visual Models", BoolProperty::New(displayFlags.getShowVisualModels()), renderer, overwrite); } Superclass::SetDefaultProperties(node, renderer, overwrite); } } mitk::SimulationMapper3D::SimulationMapper3D() { } mitk::SimulationMapper3D::~SimulationMapper3D() { } void mitk::SimulationMapper3D::ApplyProperties(vtkActor* actor, mitk::BaseRenderer* renderer) { if (actor == NULL) { mitk::DataNode* node = this->GetDataNode(); bool showBehaviorModels; bool showForceFields; bool showInteractionForceFields; bool showBoundingCollisionModels; bool showCollisionModels; bool showMechanicalMappings; bool showMappings; bool showNormals; bool showWireFrame; bool showVisualModels; node->GetBoolProperty("Simulation.Behavior.Behavior Models", showBehaviorModels, renderer); node->GetBoolProperty("Simulation.Behavior.Force Fields", showForceFields, renderer); node->GetBoolProperty("Simulation.Behavior.Interactions", showInteractionForceFields, renderer); node->GetBoolProperty("Simulation.Collision.Bounding Trees", showBoundingCollisionModels, renderer); node->GetBoolProperty("Simulation.Collision.Collision Models", showCollisionModels, renderer); node->GetBoolProperty("Simulation.Mapping.Mechanical Mappings", showMechanicalMappings, renderer); node->GetBoolProperty("Simulation.Mapping.Visual Mappings", showMappings, renderer); node->GetBoolProperty("Simulation.Options.Normals", showNormals, renderer); node->GetBoolProperty("Simulation.Options.Wire Frame", showWireFrame, renderer); node->GetBoolProperty("Simulation.Visual.Visual Models", showVisualModels, renderer); mitk::Simulation* simulation = static_cast(this->GetData()); sofa::component::visualmodel::VisualStyle::SPtr visualStyle; simulation->GetRootNode()->get(visualStyle); bool update = false; sofa::core::visual::DisplayFlags* displayFlags = visualStyle->displayFlags.beginEdit(); if (showBehaviorModels != displayFlags->getShowBehaviorModels()) { displayFlags->setShowBehaviorModels(showBehaviorModels); update = true; } if (showForceFields != displayFlags->getShowForceFields()) { displayFlags->setShowForceFields(showForceFields); update = true; } if (showInteractionForceFields != displayFlags->getShowInteractionForceFields()) { displayFlags->setShowInteractionForceFields(showInteractionForceFields); update = true; } if (showBoundingCollisionModels != displayFlags->getShowBoundingCollisionModels()) { displayFlags->setShowBoundingCollisionModels(showBoundingCollisionModels); update = true; } if (showCollisionModels != displayFlags->getShowCollisionModels()) { displayFlags->setShowCollisionModels(showCollisionModels); update = true; } if (showMechanicalMappings != displayFlags->getShowMechanicalMappings()) { displayFlags->setShowMechanicalMappings(showMechanicalMappings); update = true; } if (showMappings != displayFlags->getShowMappings()) { displayFlags->setShowMappings(showMappings); update = true; } displayFlags->setShowNormals(showNormals); if (showWireFrame != displayFlags->getShowWireFrame()) { displayFlags->setShowWireFrame(showWireFrame); update = true; } displayFlags->setShowVisualModels(showVisualModels); visualStyle->displayFlags.endEdit(); if (update) simulation->GetDrawTool()->Reset(); } } void mitk::SimulationMapper3D::GenerateDataForRenderer(mitk::BaseRenderer* renderer) { mitk::Simulation* simulation = dynamic_cast(this->GetData()); if (sofa::simulation::getSimulation() == NULL) { if (simulation != NULL) { simulation->SetAsActiveSimulation(); simulation->GetDrawTool()->Reset(); } else { return; } } LocalStorage* localStorage = m_LocalStorageHandler.GetLocalStorage(renderer); localStorage->m_VtkProp = vtkSmartPointer::New(); if (simulation != NULL) { sofa::simulation::Simulation::SPtr sofaSimulation = simulation->GetSimulation(); sofa::simulation::Node::SPtr rootNode = simulation->GetRootNode(); sofa::core::visual::VisualParams* vParams = sofa::core::visual::VisualParams::defaultInstance(); SimulationDrawTool* drawTool = simulation->GetDrawTool(); sofa::simulation::Simulation* backupSimulation = NULL; sofa::core::visual::DrawTool* backupDrawTool = NULL; if (sofa::simulation::getSimulation() != sofaSimulation.get()) { backupSimulation = sofa::simulation::getSimulation(); backupDrawTool = vParams->drawTool(); sofa::simulation::setSimulation(sofaSimulation.get()); vParams->drawTool() = drawTool; } this->ApplyProperties(NULL, renderer); sofaSimulation->updateVisual(rootNode.get()); sofaSimulation->draw(vParams, rootNode.get()); drawTool->DisableUpdate(); SimulationPropAssemblyVisitor propAssemblyVisitor(localStorage->m_VtkProp); rootNode->executeVisitor(&propAssemblyVisitor); std::vector actors = drawTool->GetActors(); for (std::vector::const_iterator actor = actors.begin(); actor != actors.end(); ++actor) localStorage->m_VtkProp->AddPart(*actor); if (backupSimulation != NULL) { sofa::simulation::setSimulation(backupSimulation); vParams->drawTool() = backupDrawTool; } } } vtkProp* mitk::SimulationMapper3D::GetVtkProp(mitk::BaseRenderer* renderer) { return m_LocalStorageHandler.GetLocalStorage(renderer)->m_VtkProp; } diff --git a/Modules/Simulation/mitkSimulationModel.cpp b/Modules/Simulation/mitkSimulationModel.cpp index 0da8b91eb0..cebf7e866a 100644 --- a/Modules/Simulation/mitkSimulationModel.cpp +++ b/Modules/Simulation/mitkSimulationModel.cpp @@ -1,336 +1,337 @@ /*=================================================================== The Medical Imaging Interaction Toolkit (MITK) Copyright (c) German Cancer Research Center, Division of Medical and Biological Informatics. All rights reserved. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See LICENSE.txt or http://www.mitk.org for details. ===================================================================*/ #include "mitkSimulation.h" #include "mitkSimulationModel.h" #include +#include #include #include #include #include #include #include #include #include #include #include mitk::SimulationModel::SimulationModel() : m_LastTime(-1.0), m_LastShowNormals(false), m_LastShowVisualModels(true), m_LastShowWireFrame(false) { } mitk::SimulationModel::~SimulationModel() { this->DeleteVtkTextures(); this->DeleteVtkObjects(); } void mitk::SimulationModel::DeleteVtkObjects() { for (std::vector::const_iterator object = m_VtkObjects.begin(); object != m_VtkObjects.end(); ++object) (*object)->Delete(); m_VtkObjects.clear(); for (std::vector::const_iterator actor = m_Actors.begin(); actor != m_Actors.end(); ++actor) (*actor)->Delete(); m_Actors.clear(); } void mitk::SimulationModel::DeleteVtkTextures() { for (std::map::const_iterator texture = m_Textures.begin(); texture != m_Textures.end(); ++texture) texture->second->Delete(); m_Textures.clear(); } void mitk::SimulationModel::DrawGroup(int ig, const sofa::core::visual::VisualParams* vparams, bool transparent) { const sofa::defaulttype::ResizableExtVector& triangles = this->getTriangles(); const sofa::defaulttype::ResizableExtVector& quads = this->getQuads(); FaceGroup g; if (ig < 0) { g.materialId = -1; g.tri0 = 0; g.nbt = triangles.size(); g.quad0 = 0; g.nbq = quads.size(); } else { g = groups.getValue()[ig]; } const sofa::defaulttype::ResizableExtVector& vertices = this->getVertices(); unsigned int numVertices = vertices.size(); vtkPoints* points = vtkPoints::New(); points->SetNumberOfPoints(numVertices); for (unsigned int i = 0; i < numVertices; ++i) points->SetPoint(i, vertices[i].elems); vtkPolyData* polyData = vtkPolyData::New(); polyData->SetPoints(points); points->Delete(); vtkCellArray* polys = vtkCellArray::New(); int numTriangles = g.tri0 + g.nbt; int numQuads = g.quad0 + g.nbq; for (int i = g.tri0; i < numTriangles; ++i) { polys->InsertNextCell(3); polys->InsertCellPoint(triangles[i].elems[0]); polys->InsertCellPoint(triangles[i].elems[1]); polys->InsertCellPoint(triangles[i].elems[2]); } for (int i = g.quad0; i < numQuads; ++i) { polys->InsertNextCell(4); polys->InsertCellPoint(quads[i].elems[0]); polys->InsertCellPoint(quads[i].elems[1]); polys->InsertCellPoint(quads[i].elems[2]); polys->InsertCellPoint(quads[i].elems[3]); } polyData->SetPolys(polys); polys->Delete(); const sofa::defaulttype::ResizableExtVector& normals = this->getVnormals(); unsigned int numNormals = normals.size(); vtkFloatArray* vtkNormals = vtkFloatArray::New(); vtkNormals->SetNumberOfComponents(3); for (unsigned int i = 0; i < numNormals; ++i) vtkNormals->InsertNextTuple(normals[i].elems); polyData->GetPointData()->SetNormals(vtkNormals); vtkNormals->Delete(); sofa::core::loader::Material m = g.materialId >= 0 ? materials.getValue()[g.materialId] : material.getValue(); if (m.useTexture && m.activated) { const sofa::defaulttype::ResizableExtVector& texCoords = this->getVtexcoords(); unsigned int numTexCoords = texCoords.size(); vtkFloatArray* vtkTexCoords = vtkFloatArray::New(); vtkTexCoords->SetNumberOfComponents(2); for (unsigned int i = 0; i < numTexCoords; ++i) vtkTexCoords->InsertNextTuple(texCoords[i].elems); polyData->GetPointData()->SetTCoords(vtkTexCoords); vtkTexCoords->Delete(); } vtkPolyDataMapper* polyDataMapper = vtkPolyDataMapper::New(); polyDataMapper->SetInput(polyData); vtkActor* actor = vtkActor::New(); actor->SetMapper(polyDataMapper); actor->SetScale(Simulation::ScaleFactor); if (m.useTexture && m.activated) actor->SetTexture(m_Textures[g.materialId]); sofa::defaulttype::Vec4f ambient = !m.useAmbient ? sofa::defaulttype::Vec4f() : m.ambient; sofa::defaulttype::Vec4f diffuse = !m.useDiffuse ? sofa::defaulttype::Vec4f() : m.diffuse; sofa::defaulttype::Vec4f specular = !m.useSpecular ? sofa::defaulttype::Vec4f() : m.specular; float shininess = m.useShininess ? m.shininess : 45.0f; if (shininess == 0.0f) { specular.clear(); shininess = 1.0f; } vtkProperty* property = actor->GetProperty(); property->SetAmbientColor(ambient.x(), ambient.y(), ambient.z()); property->SetDiffuseColor(diffuse.x(), diffuse.y(), diffuse.z()); property->SetSpecular(1.0); property->SetSpecularColor(specular.x(), specular.y(), specular.z()); property->SetSpecularPower(shininess); if (vparams->displayFlags().getShowWireFrame()) property->SetRepresentationToWireframe(); m_VtkObjects.push_back(polyData); m_VtkObjects.push_back(polyDataMapper); m_Actors.push_back(actor); if (!m_LastShowNormals) return; points = vtkPoints::New(); points->SetNumberOfPoints(numVertices * 2); vtkCellArray* lines = vtkCellArray::New(); for (unsigned int i = 0; i < numVertices; ++i) { unsigned int j = 2 * i; unsigned int k = j + 1; points->SetPoint(j, vertices[i].elems); points->SetPoint(k, (vertices[i] + normals[i]).elems); lines->InsertNextCell(2); lines->InsertCellPoint(j); lines->InsertCellPoint(k); } polyData = vtkPolyData::New(); polyData->SetPoints(points); polyData->SetLines(lines); points->Delete(); lines->Delete(); polyDataMapper = vtkPolyDataMapper::New(); polyDataMapper->SetInput(polyData); actor = vtkActor::New(); actor->SetMapper(polyDataMapper); actor->SetScale(Simulation::ScaleFactor); m_VtkObjects.push_back(polyData); m_VtkObjects.push_back(polyDataMapper); m_Actors.push_back(actor); } std::vector mitk::SimulationModel::GetActors() const { return m_Actors; } void mitk::SimulationModel::internalDraw(const sofa::core::visual::VisualParams* vparams, bool transparent) { double time = this->getContext()->getTime(); const sofa::core::visual::DisplayFlags& displayFlags = vparams->displayFlags(); bool showNormals = displayFlags.getShowNormals(); bool showVisualModels = displayFlags.getShowVisualModels(); bool showWireFrame = displayFlags.getShowWireFrame(); if (time == m_LastTime && showNormals == m_LastShowNormals && showVisualModels == m_LastShowVisualModels && showWireFrame == m_LastShowWireFrame) return; m_LastTime = time; m_LastShowNormals = showNormals; m_LastShowVisualModels = showVisualModels; m_LastShowWireFrame = showWireFrame; if (transparent) return; this->DeleteVtkObjects(); if (!vparams->displayFlags().getShowVisualModels()) return; sofa::helper::ReadAccessor > > groups = this->groups; if (groups.empty()) { this->DrawGroup(-1, vparams, transparent); } else { for (unsigned int i = 0; i < groups.size(); ++i) this->DrawGroup(i, vparams, transparent); } } bool mitk::SimulationModel::loadTexture(const std::string& filename) { return false; } bool mitk::SimulationModel::loadTextures() { this->DeleteVtkTextures(); std::vector activatedTextures; const sofa::helper::vector& materials = this->materials.getValue(); unsigned int numMaterials = materials.size(); for (unsigned int i = 0; i < numMaterials; ++i) { const sofa::core::loader::Material& material = materials[i]; if (material.useTexture && material.activated) activatedTextures.push_back(i); } unsigned int numActivatedTextures = activatedTextures.size(); for (unsigned int i = 0; i < numActivatedTextures; ++i) { std::string textureFilename = materials[activatedTextures[i]].textureFilename; if (!sofa::helper::system::DataRepository.findFile(textureFilename)) return false; vtkImageReader2* imageReader = vtkImageReader2Factory::CreateImageReader2(textureFilename.c_str()); if (imageReader == NULL) return false; imageReader->SetFileName(textureFilename.c_str()); vtkTexture* texture = vtkTexture::New(); texture->SetInput(imageReader->GetOutputDataObject(0)); texture->InterpolateOn(); imageReader->Delete(); m_Textures.insert(std::make_pair(activatedTextures[i], texture)); } return true; } diff --git a/Modules/Simulation/mitkSimulationReader.cpp b/Modules/Simulation/mitkSimulationReader.cpp index 59228c28f5..c2f1c84b1f 100644 --- a/Modules/Simulation/mitkSimulationReader.cpp +++ b/Modules/Simulation/mitkSimulationReader.cpp @@ -1,113 +1,114 @@ /*=================================================================== The Medical Imaging Interaction Toolkit (MITK) Copyright (c) German Cancer Research Center, Division of Medical and Biological Informatics. All rights reserved. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See LICENSE.txt or http://www.mitk.org for details. ===================================================================*/ #include "mitkSimulation.h" #include "mitkSimulationReader.h" #include +#include #include bool mitk::SimulationReader::CanReadFile(const std::string& filename, const std::string&, const std::string&) { std::string::size_type length = filename.length(); if (length < 5) return false; std::string ext = filename.substr(length - 4); std::transform(ext.begin(), ext.end(), ext.begin(), tolower); if (ext == ".scn" || ext == ".xml") return true; return false; } mitk::SimulationReader::SimulationReader() { mitk::Simulation::Pointer output = mitk::Simulation::New(); this->SetNumberOfRequiredOutputs(1); this->SetNthOutput(0, output.GetPointer()); } mitk::SimulationReader::~SimulationReader() { } void mitk::SimulationReader::GenerateData() { Simulation::Pointer simulation = dynamic_cast(this->GetOutput(0)); sofa::simulation::Simulation::SPtr sofaSimulation = simulation->GetSimulation(); sofa::simulation::Simulation::SPtr currentSofaSimulation = sofa::simulation::getSimulation(); sofa::core::visual::VisualParams* visualParams = sofa::core::visual::VisualParams::defaultInstance(); sofa::core::visual::DrawTool* currentDrawTool = visualParams->drawTool(); simulation->SetAsActiveSimulation(); std::string path = sofa::helper::system::SetDirectory::GetParentDir(m_FileName.c_str()); sofa::helper::system::DataRepository.addFirstPath(path); - sofa::simulation::Node::SPtr rootNode = sofa::core::objectmodel::SPtr_dynamic_cast(sofaSimulation->loadFromFile(m_FileName.c_str())); + sofa::simulation::Node::SPtr rootNode = sofa::core::objectmodel::SPtr_dynamic_cast(sofaSimulation->load(m_FileName.c_str())); if (rootNode == NULL) { sofa::helper::system::DataRepository.removePath(path); mitkThrow() << "Could not load '" << m_FileName << "'!"; } simulation->SetRootNode(rootNode.get()); simulation->SetDefaultDT(rootNode->getDt()); sofaSimulation->init(rootNode.get()); sofa::helper::system::DataRepository.removePath(path); sofa::simulation::setSimulation(currentSofaSimulation.get()); visualParams->drawTool() = currentDrawTool; } void mitk::SimulationReader::GenerateOutputInformation() { } const char* mitk::SimulationReader::GetFileName() const { return m_FileName.c_str(); } void mitk::SimulationReader::SetFileName(const char* aFileName) { m_FileName = aFileName; } const char* mitk::SimulationReader::GetFilePattern() const { return m_FilePattern.c_str(); } void mitk::SimulationReader::SetFilePattern(const char* aFilePattern) { m_FilePattern = aFilePattern; } const char* mitk::SimulationReader::GetFilePrefix() const { return m_FilePrefix.c_str(); } void mitk::SimulationReader::SetFilePrefix(const char* aFilePrefix) { m_FilePrefix = aFilePrefix; }