├── .gitattributes ├── .gitignore ├── LICENSE.txt ├── README.md ├── src ├── Application │ ├── Analysis │ │ ├── AnalysisTool.cc │ │ ├── AnalysisTool.h │ │ └── AnalysisTool.ui │ ├── CMakeLists.txt │ ├── Data │ │ ├── ItkToVtk.h │ │ ├── Mesh.cc │ │ ├── Mesh.h │ │ ├── MeshCache.cc │ │ ├── MeshCache.h │ │ ├── MeshGenerator.cc │ │ ├── MeshGenerator.h │ │ ├── MeshManager.cc │ │ ├── MeshManager.h │ │ ├── MeshSettings.cc │ │ ├── MeshSettings.h │ │ ├── MeshWorkQueue.cc │ │ ├── MeshWorkQueue.h │ │ ├── MeshWorker.cc │ │ ├── MeshWorker.h │ │ ├── Preferences.cc │ │ ├── Preferences.h │ │ ├── PreferencesWindow.cc │ │ ├── PreferencesWindow.h │ │ ├── PreferencesWindow.ui │ │ ├── Project.cc │ │ ├── Project.h │ │ ├── RegressionTool.ui │ │ ├── Shape.cc │ │ ├── Shape.h │ │ ├── itkParticlePositionReader.h │ │ ├── itkParticlePositionReader.txx │ │ ├── itkParticlePositionWriter.h │ │ ├── itkParticlePositionWriter.txx │ │ ├── itkParticleShapeStatistics.h │ │ └── itkParticleShapeStatistics.txx │ ├── Groom │ │ ├── GroomTool.cc │ │ ├── GroomTool.h │ │ ├── GroomTool.ui │ │ ├── QGroom.cpp │ │ └── QGroom.h │ ├── Optimize │ │ ├── OptimizeTool.cc │ │ ├── OptimizeTool.h │ │ ├── OptimizeTool.ui │ │ ├── QOptimize.cpp │ │ └── QOptimize.h │ ├── Resources │ │ ├── Images │ │ │ ├── 1395370627_flow_free.png │ │ │ ├── 1395370653_question-type-one-correct.png │ │ │ ├── Analysis.png │ │ │ ├── Application.png │ │ │ ├── AutoView.png │ │ │ ├── AutoViewOff.png │ │ │ ├── DataPanel.png │ │ │ ├── DownArrow.png │ │ │ ├── DownArrowWhite.png │ │ │ ├── Groom.png │ │ │ ├── IsosurfaceVisible.png │ │ │ ├── IsosurfaceVisibleOff.png │ │ │ ├── Optimize.png │ │ │ ├── Render.png │ │ │ ├── RightArrow.png │ │ │ ├── RightArrowWhite.png │ │ │ ├── Visible.png │ │ │ ├── VisibleOff.png │ │ │ ├── acorn.png │ │ │ ├── add.png │ │ │ ├── blocks.png │ │ │ ├── blocks2.png │ │ │ ├── blue_ball.png │ │ │ ├── bug.png │ │ │ ├── chart.png │ │ │ ├── circle.png │ │ │ ├── data.png │ │ │ ├── dots.png │ │ │ ├── gear.png │ │ │ ├── gear2.png │ │ │ ├── grey_ball.png │ │ │ ├── hammer.png │ │ │ ├── hammer2.png │ │ │ ├── injection.png │ │ │ ├── palette.png │ │ │ ├── pencil.png │ │ │ ├── pref-general.png │ │ │ ├── purple_ball.png │ │ │ ├── pyramid.png │ │ │ ├── red_dots.png │ │ │ ├── remove.png │ │ │ ├── run.png │ │ │ ├── screwdriver.png │ │ │ ├── select.png │ │ │ ├── shapes-icon.ico │ │ │ ├── shapes-icon.png │ │ │ ├── snowflake.png │ │ │ ├── spinner.png │ │ │ ├── star.png │ │ │ ├── star2.png │ │ │ ├── studio.png │ │ │ ├── tools.png │ │ │ ├── unselect.png │ │ │ ├── wand.png │ │ │ ├── wand2.png │ │ │ ├── wrench.png │ │ │ └── wrench2.png │ │ ├── ShapeWorksStudio.icns │ │ ├── ShapeWorksStudio.qrc │ │ ├── ShapeWorksStudio.rc │ │ └── resource.h │ ├── Visualization │ │ ├── ColorSchemes.h │ │ ├── DisplayObject.cc │ │ ├── DisplayObject.h │ │ ├── Lightbox.cc │ │ ├── Lightbox.h │ │ ├── ShapeWorksStudioApp.cc │ │ ├── ShapeWorksStudioApp.h │ │ ├── ShapeWorksStudioApp.ui │ │ ├── ShapeworksWorker.cc │ │ ├── ShapeworksWorker.h │ │ ├── StudioInteractorStyle.cc │ │ ├── StudioInteractorStyle.h │ │ ├── Viewer.cc │ │ ├── Viewer.h │ │ ├── Visualizer.cc │ │ ├── Visualizer.h │ │ ├── WheelEventForwarder.cc │ │ ├── WheelEventForwarder.h │ │ ├── bargraph.cpp │ │ └── bargraph.h │ └── main.cc ├── CLT │ ├── CMakeLists.txt │ └── ShapeworksCLT.cpp ├── CMakeLists.txt ├── CTestConfig.cmake ├── Doxyfile.in ├── Groom │ ├── CMakeLists.txt │ ├── ShapeWorksGroom.cxx │ ├── ShapeWorksGroom.h │ ├── bounding_box.h │ ├── bounding_box.txx │ └── tool.h ├── Optimize │ ├── CMakeLists.txt │ ├── ShapeWorksOptimize.cxx │ └── ShapeWorksOptimize.h ├── ParticleShapeworks │ ├── CMakeLists.txt │ ├── Examples │ │ ├── .DS_Store │ │ ├── CMakeLists.txt │ │ ├── itkPSMCommandLineClass.h │ │ ├── itkPSMCommandLineClass.hxx │ │ ├── psmCommandLineTool.cxx │ │ └── psmPreprocessor.cxx │ ├── LICENSE │ ├── Notes.txt │ ├── README.md │ ├── include │ │ ├── .DS_Store │ │ ├── itkPSMAttribute.h │ │ ├── itkPSMCleanAndCenterLabelMapImageFilter.h │ │ ├── itkPSMCleanAndCenterLabelMapImageFilter.hxx │ │ ├── itkPSMContainer.h │ │ ├── itkPSMContainerArrayAttribute.h │ │ ├── itkPSMCostFunction.h │ │ ├── itkPSMDOMNode.h │ │ ├── itkPSMDOMNodeXMLReader.h │ │ ├── itkPSMDomain.h │ │ ├── itkPSMDomain.hxx │ │ ├── itkPSMEntropyMixedEffectsModelFilter.h │ │ ├── itkPSMEntropyModelFilter.h │ │ ├── itkPSMEntropyModelFilter.hxx │ │ ├── itkPSMEntropyRegressionModelFilter.h │ │ ├── itkPSMEvents.h │ │ ├── itkPSMGradientDescentOptimizer.h │ │ ├── itkPSMGradientDescentOptimizer.hxx │ │ ├── itkPSMImageDomain.h │ │ ├── itkPSMImageDomainWithCurvature.h │ │ ├── itkPSMImageDomainWithGradients.h │ │ ├── itkPSMImageDomainWithHessians.h │ │ ├── itkPSMImplicitSurfaceDomain.h │ │ ├── itkPSMImplicitSurfaceDomain.hxx │ │ ├── itkPSMImplicitSurfaceImageFilter.h │ │ ├── itkPSMImplicitSurfaceImageFilter.hxx │ │ ├── itkPSMMeanCurvatureAttribute.h │ │ ├── itkPSMMeanCurvatureAttribute.hxx │ │ ├── itkPSMMixedEffectsShapeMatrixAttribute.h │ │ ├── itkPSMMixedEffectsShapeMatrixAttribute.hxx │ │ ├── itkPSMNeighborhood.h │ │ ├── itkPSMParticleEntropyFunction.h │ │ ├── itkPSMParticleEntropyFunction.hxx │ │ ├── itkPSMParticleSystem.h │ │ ├── itkPSMParticleSystem.hxx │ │ ├── itkPSMPointIndexPair.h │ │ ├── itkPSMPointTree.h │ │ ├── itkPSMPointTree.hxx │ │ ├── itkPSMProcrustesFunction.h │ │ ├── itkPSMProcrustesRegistration.h │ │ ├── itkPSMProject.h │ │ ├── itkPSMProjectReader.h │ │ ├── itkPSMProjectWriter.h │ │ ├── itkPSMRBFCorrespondenceInterpolator.h │ │ ├── itkPSMRBFCorrespondenceInterpolator.hxx │ │ ├── itkPSMRegionDomain.h │ │ ├── itkPSMRegionNeighborhood.h │ │ ├── itkPSMRegionNeighborhood.hxx │ │ ├── itkPSMRegressionShapeMatrixAttribute.h │ │ ├── itkPSMRegressionShapeMatrixAttribute.hxx │ │ ├── itkPSMShapeEntropyFunction.h │ │ ├── itkPSMShapeEntropyFunction.hxx │ │ ├── itkPSMShapeMatrixAttribute.h │ │ ├── itkPSMShapeMatrixAttribute.hxx │ │ ├── itkPSMSurfaceNeighborhood.h │ │ ├── itkPSMSurfaceNeighborhood.hxx │ │ ├── itkPSMTrimLabelMapImageFilter.h │ │ ├── itkPSMTrimLabelMapImageFilter.hxx │ │ ├── itkPSMTwoCostFunction.h │ │ └── itkPSMTwoCostFunction.hxx │ ├── src │ │ ├── .DS_Store │ │ ├── itkIncludeRequiredIOFactories.h │ │ ├── itkPSMDOMNodeXMLReader.cxx │ │ ├── itkPSMParticleSystem.cxx │ │ ├── itkPSMProcrustesFunction.cxx │ │ ├── itkPSMProcrustesRegistration.cxx │ │ ├── itkPSMProject.cxx │ │ ├── itkPSMProjectReader.cxx │ │ └── itkPSMProjectWriter.cxx │ └── test │ │ ├── .DS_Store │ │ ├── CMakeLists.txt │ │ ├── itkPSMCleanAndCenterLabelMapImageFilterTest.cxx │ │ ├── itkPSMCommandLineClass2DTest.cxx │ │ ├── itkPSMContainerArrayAttributeTest.cxx │ │ ├── itkPSMContainerTest.cxx │ │ ├── itkPSMCostFunctionTest.cxx │ │ ├── itkPSMEntropyMixedEffectsModelFilterTest.cxx │ │ ├── itkPSMEntropyModelFilter2DMultiscaleTest.cxx │ │ ├── itkPSMEntropyModelFilter2DTest.cxx │ │ ├── itkPSMEntropyModelFilterMultiscaleTest.cxx │ │ ├── itkPSMEntropyModelFilterTest.cxx │ │ ├── itkPSMEntropyRegressionModel2DFilterMultiscaleTest.cxx │ │ ├── itkPSMEntropyRegressionModel2DFilterTest.cxx │ │ ├── itkPSMEntropyRegressionModelFilterTest.cxx │ │ ├── itkPSMGradientDescentOptimizerTest.cxx │ │ ├── itkPSMImplicitSurfaceImage2DFilterTest.cxx │ │ ├── itkPSMImplicitSurfaceImageFilterTest.cxx │ │ ├── itkPSMMeanCurvatureAttributeTest.cxx │ │ ├── itkPSMParticleSystemTest.cxx │ │ ├── itkPSMPointTreeTest.cxx │ │ ├── itkPSMProcrustesFunction2DTest.cxx │ │ ├── itkPSMProcrustesFunctionTest.cxx │ │ ├── itkPSMProcrustesRegistration2DTest.cxx │ │ ├── itkPSMProcrustesRegistrationTest.cxx │ │ ├── itkPSMProjectTest.cxx │ │ ├── itkPSMRBFCorrespondenceInterpolatorTest.cxx │ │ ├── itkPSMRegionNeighborhoodTest.cxx │ │ ├── itkPSMShapeEntropyFunctionTest.cxx │ │ ├── itkPSMSurfaceNeighborhoodTest.cxx │ │ ├── itkPSMTrimLabelMapImageFilterTest.cxx │ │ └── itkPSMTwoCostFunctionTest.cxx ├── Surfworks │ ├── CMakeLists.txt │ ├── Eigen │ │ ├── Array │ │ ├── CMakeLists.txt │ │ ├── Cholesky │ │ ├── CholmodSupport │ │ ├── Core │ │ ├── Dense │ │ ├── Eigen │ │ ├── Eigen2Support │ │ ├── Eigenvalues │ │ ├── Geometry │ │ ├── Householder │ │ ├── IterativeLinearSolvers │ │ ├── Jacobi │ │ ├── LU │ │ ├── LeastSquares │ │ ├── MetisSupport │ │ ├── OrderingMethods │ │ ├── PaStiXSupport │ │ ├── PardisoSupport │ │ ├── QR │ │ ├── QtAlignedMalloc │ │ ├── SPQRSupport │ │ ├── SVD │ │ ├── Sparse │ │ ├── SparseCholesky │ │ ├── SparseCore │ │ ├── SparseLU │ │ ├── SparseQR │ │ ├── StdDeque │ │ ├── StdList │ │ ├── StdVector │ │ ├── SuperLUSupport │ │ ├── UmfPackSupport │ │ └── src │ │ │ ├── CMakeLists.txt │ │ │ ├── Cholesky │ │ │ ├── CMakeLists.txt │ │ │ ├── LDLT.h │ │ │ ├── LLT.h │ │ │ └── LLT_MKL.h │ │ │ ├── CholmodSupport │ │ │ ├── CMakeLists.txt │ │ │ └── CholmodSupport.h │ │ │ ├── Core │ │ │ ├── Array.h │ │ │ ├── ArrayBase.h │ │ │ ├── ArrayWrapper.h │ │ │ ├── Assign.h │ │ │ ├── Assign_MKL.h │ │ │ ├── BandMatrix.h │ │ │ ├── Block.h │ │ │ ├── BooleanRedux.h │ │ │ ├── CMakeLists.txt │ │ │ ├── CommaInitializer.h │ │ │ ├── CoreIterators.h │ │ │ ├── CwiseBinaryOp.h │ │ │ ├── CwiseNullaryOp.h │ │ │ ├── CwiseUnaryOp.h │ │ │ ├── CwiseUnaryView.h │ │ │ ├── DenseBase.h │ │ │ ├── DenseCoeffsBase.h │ │ │ ├── DenseStorage.h │ │ │ ├── Diagonal.h │ │ │ ├── DiagonalMatrix.h │ │ │ ├── DiagonalProduct.h │ │ │ ├── Dot.h │ │ │ ├── EigenBase.h │ │ │ ├── Flagged.h │ │ │ ├── ForceAlignedAccess.h │ │ │ ├── Functors.h │ │ │ ├── Fuzzy.h │ │ │ ├── GeneralProduct.h │ │ │ ├── GenericPacketMath.h │ │ │ ├── GlobalFunctions.h │ │ │ ├── IO.h │ │ │ ├── Map.h │ │ │ ├── MapBase.h │ │ │ ├── MathFunctions.h │ │ │ ├── Matrix.h │ │ │ ├── MatrixBase.h │ │ │ ├── NestByValue.h │ │ │ ├── NoAlias.h │ │ │ ├── NumTraits.h │ │ │ ├── PermutationMatrix.h │ │ │ ├── PlainObjectBase.h │ │ │ ├── ProductBase.h │ │ │ ├── Random.h │ │ │ ├── Redux.h │ │ │ ├── Ref.h │ │ │ ├── Replicate.h │ │ │ ├── ReturnByValue.h │ │ │ ├── Reverse.h │ │ │ ├── Select.h │ │ │ ├── SelfAdjointView.h │ │ │ ├── SelfCwiseBinaryOp.h │ │ │ ├── SolveTriangular.h │ │ │ ├── StableNorm.h │ │ │ ├── Stride.h │ │ │ ├── Swap.h │ │ │ ├── Transpose.h │ │ │ ├── Transpositions.h │ │ │ ├── TriangularMatrix.h │ │ │ ├── VectorBlock.h │ │ │ ├── VectorwiseOp.h │ │ │ ├── Visitor.h │ │ │ ├── arch │ │ │ │ ├── AltiVec │ │ │ │ │ ├── CMakeLists.txt │ │ │ │ │ ├── Complex.h │ │ │ │ │ └── PacketMath.h │ │ │ │ ├── CMakeLists.txt │ │ │ │ ├── Default │ │ │ │ │ ├── CMakeLists.txt │ │ │ │ │ └── Settings.h │ │ │ │ ├── NEON │ │ │ │ │ ├── CMakeLists.txt │ │ │ │ │ ├── Complex.h │ │ │ │ │ └── PacketMath.h │ │ │ │ └── SSE │ │ │ │ │ ├── CMakeLists.txt │ │ │ │ │ ├── Complex.h │ │ │ │ │ ├── MathFunctions.h │ │ │ │ │ └── PacketMath.h │ │ │ ├── products │ │ │ │ ├── CMakeLists.txt │ │ │ │ ├── CoeffBasedProduct.h │ │ │ │ ├── GeneralBlockPanelKernel.h │ │ │ │ ├── GeneralMatrixMatrix.h │ │ │ │ ├── GeneralMatrixMatrixTriangular.h │ │ │ │ ├── GeneralMatrixMatrixTriangular_MKL.h │ │ │ │ ├── GeneralMatrixMatrix_MKL.h │ │ │ │ ├── GeneralMatrixVector.h │ │ │ │ ├── GeneralMatrixVector_MKL.h │ │ │ │ ├── Parallelizer.h │ │ │ │ ├── SelfadjointMatrixMatrix.h │ │ │ │ ├── SelfadjointMatrixMatrix_MKL.h │ │ │ │ ├── SelfadjointMatrixVector.h │ │ │ │ ├── SelfadjointMatrixVector_MKL.h │ │ │ │ ├── SelfadjointProduct.h │ │ │ │ ├── SelfadjointRank2Update.h │ │ │ │ ├── TriangularMatrixMatrix.h │ │ │ │ ├── TriangularMatrixMatrix_MKL.h │ │ │ │ ├── TriangularMatrixVector.h │ │ │ │ ├── TriangularMatrixVector_MKL.h │ │ │ │ ├── TriangularSolverMatrix.h │ │ │ │ ├── TriangularSolverMatrix_MKL.h │ │ │ │ └── TriangularSolverVector.h │ │ │ └── util │ │ │ │ ├── BlasUtil.h │ │ │ │ ├── CMakeLists.txt │ │ │ │ ├── Constants.h │ │ │ │ ├── DisableStupidWarnings.h │ │ │ │ ├── ForwardDeclarations.h │ │ │ │ ├── MKL_support.h │ │ │ │ ├── Macros.h │ │ │ │ ├── Memory.h │ │ │ │ ├── Meta.h │ │ │ │ ├── NonMPL2.h │ │ │ │ ├── ReenableStupidWarnings.h │ │ │ │ ├── StaticAssert.h │ │ │ │ └── XprHelper.h │ │ │ ├── Eigen2Support │ │ │ ├── Block.h │ │ │ ├── CMakeLists.txt │ │ │ ├── Cwise.h │ │ │ ├── CwiseOperators.h │ │ │ ├── Geometry │ │ │ │ ├── AlignedBox.h │ │ │ │ ├── All.h │ │ │ │ ├── AngleAxis.h │ │ │ │ ├── CMakeLists.txt │ │ │ │ ├── Hyperplane.h │ │ │ │ ├── ParametrizedLine.h │ │ │ │ ├── Quaternion.h │ │ │ │ ├── Rotation2D.h │ │ │ │ ├── RotationBase.h │ │ │ │ ├── Scaling.h │ │ │ │ ├── Transform.h │ │ │ │ └── Translation.h │ │ │ ├── LU.h │ │ │ ├── Lazy.h │ │ │ ├── LeastSquares.h │ │ │ ├── Macros.h │ │ │ ├── MathFunctions.h │ │ │ ├── Memory.h │ │ │ ├── Meta.h │ │ │ ├── Minor.h │ │ │ ├── QR.h │ │ │ ├── SVD.h │ │ │ ├── TriangularSolver.h │ │ │ └── VectorBlock.h │ │ │ ├── Eigenvalues │ │ │ ├── CMakeLists.txt │ │ │ ├── ComplexEigenSolver.h │ │ │ ├── ComplexSchur.h │ │ │ ├── ComplexSchur_MKL.h │ │ │ ├── EigenSolver.h │ │ │ ├── GeneralizedEigenSolver.h │ │ │ ├── GeneralizedSelfAdjointEigenSolver.h │ │ │ ├── HessenbergDecomposition.h │ │ │ ├── MatrixBaseEigenvalues.h │ │ │ ├── RealQZ.h │ │ │ ├── RealSchur.h │ │ │ ├── RealSchur_MKL.h │ │ │ ├── SelfAdjointEigenSolver.h │ │ │ ├── SelfAdjointEigenSolver_MKL.h │ │ │ └── Tridiagonalization.h │ │ │ ├── Geometry │ │ │ ├── AlignedBox.h │ │ │ ├── AngleAxis.h │ │ │ ├── CMakeLists.txt │ │ │ ├── EulerAngles.h │ │ │ ├── Homogeneous.h │ │ │ ├── Hyperplane.h │ │ │ ├── OrthoMethods.h │ │ │ ├── ParametrizedLine.h │ │ │ ├── Quaternion.h │ │ │ ├── Rotation2D.h │ │ │ ├── RotationBase.h │ │ │ ├── Scaling.h │ │ │ ├── Transform.h │ │ │ ├── Translation.h │ │ │ ├── Umeyama.h │ │ │ └── arch │ │ │ │ ├── CMakeLists.txt │ │ │ │ └── Geometry_SSE.h │ │ │ ├── Householder │ │ │ ├── BlockHouseholder.h │ │ │ ├── CMakeLists.txt │ │ │ ├── Householder.h │ │ │ └── HouseholderSequence.h │ │ │ ├── IterativeLinearSolvers │ │ │ ├── BasicPreconditioners.h │ │ │ ├── BiCGSTAB.h │ │ │ ├── CMakeLists.txt │ │ │ ├── ConjugateGradient.h │ │ │ ├── IncompleteLUT.h │ │ │ └── IterativeSolverBase.h │ │ │ ├── Jacobi │ │ │ ├── CMakeLists.txt │ │ │ └── Jacobi.h │ │ │ ├── LU │ │ │ ├── CMakeLists.txt │ │ │ ├── Determinant.h │ │ │ ├── FullPivLU.h │ │ │ ├── Inverse.h │ │ │ ├── PartialPivLU.h │ │ │ ├── PartialPivLU_MKL.h │ │ │ └── arch │ │ │ │ ├── CMakeLists.txt │ │ │ │ └── Inverse_SSE.h │ │ │ ├── MetisSupport │ │ │ ├── CMakeLists.txt │ │ │ └── MetisSupport.h │ │ │ ├── OrderingMethods │ │ │ ├── Amd.h │ │ │ ├── CMakeLists.txt │ │ │ ├── Eigen_Colamd.h │ │ │ └── Ordering.h │ │ │ ├── PaStiXSupport │ │ │ ├── CMakeLists.txt │ │ │ └── PaStiXSupport.h │ │ │ ├── PardisoSupport │ │ │ ├── CMakeLists.txt │ │ │ └── PardisoSupport.h │ │ │ ├── QR │ │ │ ├── CMakeLists.txt │ │ │ ├── ColPivHouseholderQR.h │ │ │ ├── ColPivHouseholderQR_MKL.h │ │ │ ├── FullPivHouseholderQR.h │ │ │ ├── HouseholderQR.h │ │ │ └── HouseholderQR_MKL.h │ │ │ ├── SPQRSupport │ │ │ ├── CMakeLists.txt │ │ │ └── SuiteSparseQRSupport.h │ │ │ ├── SVD │ │ │ ├── CMakeLists.txt │ │ │ ├── JacobiSVD.h │ │ │ ├── JacobiSVD_MKL.h │ │ │ └── UpperBidiagonalization.h │ │ │ ├── SparseCholesky │ │ │ ├── CMakeLists.txt │ │ │ ├── SimplicialCholesky.h │ │ │ └── SimplicialCholesky_impl.h │ │ │ ├── SparseCore │ │ │ ├── AmbiVector.h │ │ │ ├── CMakeLists.txt │ │ │ ├── CompressedStorage.h │ │ │ ├── ConservativeSparseSparseProduct.h │ │ │ ├── MappedSparseMatrix.h │ │ │ ├── SparseBlock.h │ │ │ ├── SparseColEtree.h │ │ │ ├── SparseCwiseBinaryOp.h │ │ │ ├── SparseCwiseUnaryOp.h │ │ │ ├── SparseDenseProduct.h │ │ │ ├── SparseDiagonalProduct.h │ │ │ ├── SparseDot.h │ │ │ ├── SparseFuzzy.h │ │ │ ├── SparseMatrix.h │ │ │ ├── SparseMatrixBase.h │ │ │ ├── SparsePermutation.h │ │ │ ├── SparseProduct.h │ │ │ ├── SparseRedux.h │ │ │ ├── SparseSelfAdjointView.h │ │ │ ├── SparseSparseProductWithPruning.h │ │ │ ├── SparseTranspose.h │ │ │ ├── SparseTriangularView.h │ │ │ ├── SparseUtil.h │ │ │ ├── SparseVector.h │ │ │ ├── SparseView.h │ │ │ └── TriangularSolver.h │ │ │ ├── SparseLU │ │ │ ├── CMakeLists.txt │ │ │ ├── SparseLU.h │ │ │ ├── SparseLUImpl.h │ │ │ ├── SparseLU_Memory.h │ │ │ ├── SparseLU_Structs.h │ │ │ ├── SparseLU_SupernodalMatrix.h │ │ │ ├── SparseLU_Utils.h │ │ │ ├── SparseLU_column_bmod.h │ │ │ ├── SparseLU_column_dfs.h │ │ │ ├── SparseLU_copy_to_ucol.h │ │ │ ├── SparseLU_gemm_kernel.h │ │ │ ├── SparseLU_heap_relax_snode.h │ │ │ ├── SparseLU_kernel_bmod.h │ │ │ ├── SparseLU_panel_bmod.h │ │ │ ├── SparseLU_panel_dfs.h │ │ │ ├── SparseLU_pivotL.h │ │ │ ├── SparseLU_pruneL.h │ │ │ └── SparseLU_relax_snode.h │ │ │ ├── SparseQR │ │ │ ├── CMakeLists.txt │ │ │ └── SparseQR.h │ │ │ ├── StlSupport │ │ │ ├── CMakeLists.txt │ │ │ ├── StdDeque.h │ │ │ ├── StdList.h │ │ │ ├── StdVector.h │ │ │ └── details.h │ │ │ ├── SuperLUSupport │ │ │ ├── CMakeLists.txt │ │ │ └── SuperLUSupport.h │ │ │ ├── UmfPackSupport │ │ │ ├── CMakeLists.txt │ │ │ └── UmfPackSupport.h │ │ │ ├── misc │ │ │ ├── CMakeLists.txt │ │ │ ├── Image.h │ │ │ ├── Kernel.h │ │ │ ├── Solve.h │ │ │ ├── SparseSolve.h │ │ │ └── blas.h │ │ │ └── plugins │ │ │ ├── ArrayCwiseBinaryOps.h │ │ │ ├── ArrayCwiseUnaryOps.h │ │ │ ├── BlockMethods.h │ │ │ ├── CMakeLists.txt │ │ │ ├── CommonCwiseBinaryOps.h │ │ │ ├── CommonCwiseUnaryOps.h │ │ │ ├── MatrixCwiseBinaryOps.h │ │ │ └── MatrixCwiseUnaryOps.h │ ├── ITKVTK │ │ ├── itkImageToVTKImageFilter.h │ │ ├── itkImageToVTKImageFilter.hxx │ │ ├── itkVTKImageToImageFilter.h │ │ └── itkVTKImageToImageFilter.hxx │ ├── PreViewMeshQC │ │ ├── FEAutoMesher.cpp │ │ ├── FEAutoMesher.h │ │ ├── FECVDDecimationModifier.cpp │ │ ├── FECVDDecimationModifier.h │ │ ├── FECoreMesh.cpp │ │ ├── FECoreMesh.h │ │ ├── FEElement.cpp │ │ ├── FEElement.h │ │ ├── FEFillHole.cpp │ │ ├── FEFillHole.h │ │ ├── FEFixMesh.cpp │ │ ├── FEFixMesh.h │ │ ├── FEMesh.cpp │ │ ├── FEMesh.h │ │ ├── FEMeshSmoothingModifier.cpp │ │ ├── FEMeshSmoothingModifier.h │ │ ├── FENodeElementList.cpp │ │ ├── FENodeElementList.h │ │ ├── FENodeFaceList.cpp │ │ ├── FENodeFaceList.h │ │ ├── FENodeNodeList.cpp │ │ ├── FENodeNodeList.h │ │ ├── FEVTKExport.cpp │ │ ├── FEVTKExport.h │ │ ├── FEVTKImport.cpp │ │ ├── FEVTKImport.h │ │ ├── OptionParser.cpp │ │ ├── OptionParser.h │ │ ├── PreviewCmd.cxx │ │ ├── math3d.cpp │ │ ├── math3d.h │ │ └── stdafx.h │ ├── Reconstruction.cc │ ├── Reconstruction.h │ ├── itkCompactlySupportedRBFSparseKernelTransform.h │ ├── itkCompactlySupportedRBFSparseKernelTransform.hxx │ ├── itkSparseKernelTransform.h │ └── itkSparseKernelTransform.hxx └── TinyXML │ ├── CMakeLists.txt │ ├── tinystr.cpp │ ├── tinystr.h │ ├── tinyxml.cpp │ ├── tinyxml.h │ ├── tinyxmlerror.cpp │ └── tinyxmlparser.cpp └── user_guide ├── ShapeWorksStudioLab_v2.pdf ├── ShapeWorksStudioLab_v2.tex ├── figs_v2 ├── ._add.png ├── ._ellipsoid_relative_weighting.png ├── ._filemenu.png ├── ._groomed.png ├── ._grooming.png ├── ._import.png ├── ._qtwin.png ├── ._reconstructed.png ├── ._reconstructing.png ├── ._remove.png ├── ._render.png ├── ._save.png ├── ._set_dir.png ├── ._spectrums.png ├── ._zoom.png ├── add.png ├── analysis.png ├── close.png ├── ellipsoid_images.png ├── ellipsoid_relative_weighting.png ├── ellipsoid_w001_corr_qc_1.png ├── ellipsoid_w001_corr_qc_2.png ├── ellipsoid_w1_corr_qc_1.png ├── ellipsoid_w1_corr_qc_2.png ├── femur_analyze_mean.png ├── femur_analyze_mode1_mean.png ├── femur_analyze_mode1_neg2std.png ├── femur_analyze_mode1_pos2std.png ├── femur_analyze_mode2_neg2std.png ├── femur_analyze_mode2_pos2std.png ├── femur_analyze_mode3_neg2std.png ├── femur_analyze_mode3_pos2std.png ├── femur_analyze_mode4_mean.png ├── femur_analyze_mode4_neg2std.png ├── femur_analyze_mode4_pos2std.png ├── femur_data.png ├── femur_groom.png ├── femur_optimize.png ├── femur_optimize_reconstructed.png ├── femur_optimize_reconstructed1.png ├── femur_optimize_reconstructed_hover1.png ├── femur_optimize_reconstructed_hover2.png ├── filemenu.png ├── groom.png ├── groomed.png ├── grooming.png ├── imagefiles.png ├── import.png ├── optimize.png ├── overview.png ├── pref.png ├── qtwin.png ├── reconstructed.png ├── reconstructing.png ├── remove.png ├── render.png ├── save.png ├── set_dir.png ├── spectrums.png ├── studio.bmp ├── studio.png ├── torus_analyze_mean.png ├── torus_analyze_mode1_neg2std.png ├── torus_analyze_mode1_pos2std.png ├── torus_analyze_mode2_neg2std.png ├── torus_analyze_mode2_pos2std.png ├── torus_data.png ├── torus_groom.png ├── torus_optimize_reconstructed.png ├── torus_optimize_reconstructed_hover1.png ├── torus_optimize_reconstructed_hover2.png └── zoom.png ├── osajnl.bst ├── osajnl2.rtx ├── osajnl2.sty └── references.bib /.gitattributes: -------------------------------------------------------------------------------- 1 | # Set the default behavior, in case people don't have core.autocrlf set. 2 | * text=auto 3 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | msvc* 2 | *.swp 3 | *~ 4 | */bin/* 5 | bin* 6 | build-*/ 7 | build* 8 | *build* 9 | *.user 10 | -------------------------------------------------------------------------------- /LICENSE.txt: -------------------------------------------------------------------------------- 1 | For more information, please see: http://software.sci.utah.edu 2 | 3 | The MIT License 4 | 5 | Copyright (c) 2014 Scientific Computing and Imaging Institute, 6 | University of Utah. 7 | 8 | 9 | Permission is hereby granted, free of charge, to any person obtaining a 10 | copy of this software and associated documentation files (the "Software"), 11 | to deal in the Software without restriction, including without limitation 12 | the rights to use, copy, modify, merge, publish, distribute, sublicense, 13 | and/or sell copies of the Software, and to permit persons to whom the 14 | Software is furnished to do so, subject to the following conditions: 15 | 16 | The above copyright notice and this permission notice shall be included 17 | in all copies or substantial portions of the Software. 18 | 19 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS 20 | OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 21 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 22 | THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 23 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 24 | FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER 25 | DEALINGS IN THE SOFTWARE. 26 | -------------------------------------------------------------------------------- /src/Application/Analysis/AnalysisTool.h: -------------------------------------------------------------------------------- 1 | #ifndef STUDIO_ANALYSIS_ANALYSISTOOL_H 2 | #define STUDIO_ANALYSIS_ANALYSISTOOL_H 3 | 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include "Data/Preferences.h" 9 | #include 10 | #include 11 | 12 | class Project; 13 | class Lightbox; 14 | class ShapeWorksStudioApp; 15 | class Ui_AnalysisTool; 16 | 17 | class AnalysisTool : public QWidget { 18 | Q_OBJECT; 19 | public: 20 | 21 | AnalysisTool(Preferences& prefs); 22 | ~AnalysisTool(); 23 | 24 | /// set the pointer to the project 25 | void set_project( QSharedPointer project ); 26 | 27 | /// set the pointer to the application 28 | void set_app( ShapeWorksStudioApp* app ); 29 | 30 | void set_shapes( ShapeList shapes ); 31 | 32 | void activate(); 33 | 34 | std::string getAnalysisMode(); 35 | 36 | void setAnalysisMode(std::string i); 37 | 38 | void setLabels(QString which, QString value); 39 | 40 | int getPCAMode(); 41 | 42 | double get_pca_value(); 43 | 44 | bool pcaAnimate(); 45 | 46 | int getSampleNumber(); 47 | 48 | bool compute_stats(); 49 | 50 | void updateSlider(); 51 | 52 | void reset_stats(); 53 | 54 | const vnl_vector & getMean(); 55 | 56 | const vnl_vector & getShape(int mode, double value); 57 | 58 | ParticleShapeStatistics<3> getStats(); 59 | 60 | 61 | public Q_SLOTS: 62 | void handle_analysis_options(); 63 | void handle_median(); 64 | 65 | // PCA 66 | void on_pcaSlider_valueChanged(); 67 | void on_pcaModeSpinBox_valueChanged(int i); 68 | 69 | void handle_pca_animate_state_changed(); 70 | void handle_pca_timer(); 71 | 72 | void on_linear_radio_toggled(bool b); 73 | 74 | signals: 75 | void update_view(); 76 | void pca_update(); 77 | 78 | private: 79 | //private methods 80 | void pca_labels_changed( QString value, QString eigen, QString lambda ); 81 | void compute_mode_shape(); 82 | void update_analysis_mode(); 83 | //private members 84 | Preferences & preferences_; 85 | Ui_AnalysisTool* ui_; 86 | QSharedPointer project_; 87 | ShapeWorksStudioApp* app_; 88 | 89 | VisualizerHandle visualizer_; 90 | 91 | /// itk particle shape statistics 92 | ParticleShapeStatistics<3> stats_; 93 | bool stats_ready_; 94 | 95 | vnl_vector empty_shape_; 96 | vnl_vector temp_shape_; 97 | 98 | bool pcaAnimateDirection; 99 | QTimer pcaAnimateTimer; 100 | BarGraph *chart_; 101 | 102 | 103 | }; 104 | 105 | #endif /* STUDIO_ANALYSIS_ANALYSISTOOL_H */ 106 | -------------------------------------------------------------------------------- /src/Application/Data/ItkToVtk.h: -------------------------------------------------------------------------------- 1 | #ifndef STUDIO_DATA_ITKTOVTK_H 2 | #define STUDIO_DATA_ITKTOVTK_H 3 | 4 | /** 5 | * This function will connect the given itk::VTKImageExport filter to 6 | * the given vtkImageImport filter. 7 | */ 8 | template 9 | void ConnectPipelines( ITK_Exporter exporter, VTK_Importer* importer ) 10 | { 11 | importer->SetUpdateInformationCallback( exporter->GetUpdateInformationCallback() ); 12 | importer->SetPipelineModifiedCallback( exporter->GetPipelineModifiedCallback() ); 13 | importer->SetWholeExtentCallback( exporter->GetWholeExtentCallback() ); 14 | importer->SetSpacingCallback( exporter->GetSpacingCallback() ); 15 | importer->SetOriginCallback( exporter->GetOriginCallback() ); 16 | importer->SetScalarTypeCallback( exporter->GetScalarTypeCallback() ); 17 | importer->SetNumberOfComponentsCallback( exporter->GetNumberOfComponentsCallback() ); 18 | importer->SetPropagateUpdateExtentCallback( exporter->GetPropagateUpdateExtentCallback() ); 19 | importer->SetUpdateDataCallback( exporter->GetUpdateDataCallback() ); 20 | importer->SetDataExtentCallback( exporter->GetDataExtentCallback() ); 21 | importer->SetBufferPointerCallback( exporter->GetBufferPointerCallback() ); 22 | importer->SetCallbackUserData( exporter->GetCallbackUserData() ); 23 | } 24 | 25 | #endif /* STUDIO_DATA_ITKTOVTK_H */ 26 | -------------------------------------------------------------------------------- /src/Application/Data/Mesh.h: -------------------------------------------------------------------------------- 1 | #ifndef STUDIO_DATA_MESH_H 2 | #define STUDIO_DATA_MESH_H 3 | 4 | #include 5 | #include 6 | 7 | #include 8 | #include 9 | #include 10 | #include 11 | 12 | #include 13 | #include 14 | 15 | class Mesh; 16 | typedef QSharedPointer< Mesh > MeshHandle; 17 | //! Representation of a single mesh. 18 | /*! 19 | * The Mesh class represents a single mesh generated from an image file. 20 | * It is responsible for loading the image and generating a mesh from it. 21 | * 22 | */ 23 | class Mesh 24 | { 25 | public: 26 | 27 | /// Constructor 28 | Mesh(); 29 | 30 | /// Destructor 31 | ~Mesh(); 32 | 33 | /// Create a mesh from an image 34 | ImageType::Pointer create_from_file(std::string filename, double iso_value); 35 | void create_from_image(ImageType::Pointer img, double iso_value); 36 | 37 | /// Get the dimensions as a string for display (if loaded from an image) 38 | QString get_dimension_string(); 39 | 40 | /// Get the mesh polydata 41 | vtkSmartPointer get_poly_data(); 42 | 43 | /// Get the center transform 44 | vnl_vector get_center_transform(); 45 | 46 | void set_poly_data(vtkSmartPointer poly_data); 47 | 48 | private: 49 | 50 | vtkSmartPointer poly_data_; 51 | 52 | int dimensions_[3]; 53 | 54 | vnl_vector center_transform_; 55 | }; 56 | 57 | #endif /* STUDIO_DATA_MESH_H */ 58 | -------------------------------------------------------------------------------- /src/Application/Data/MeshCache.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Shapeworks license 3 | */ 4 | 5 | /** 6 | * @file MeshCache.h 7 | * @brief Thread safe cache for meshes index by shape 8 | * 9 | * The MeshCache implements a std::map keyed by shape (list of points) with vtkPolyData values. 10 | * It is thread-safe and can be used from any thread. 11 | */ 12 | 13 | #ifndef MESH_CACHE_H 14 | #define MESH_CACHE_H 15 | 16 | #include 17 | #include 18 | 19 | #include 20 | 21 | #include 22 | 23 | #include 24 | 25 | #include "Data/Preferences.h" 26 | 27 | //#include "itkParticleShapeStatistics.h" 28 | 29 | class vtkPolyData; 30 | 31 | class CacheListItem 32 | { 33 | public: 34 | vnl_vector key; 35 | size_t memorySize; 36 | }; 37 | 38 | // comparison class for vnl_vectors (for cache) 39 | class vnl_vector_compare 40 | { 41 | public: 42 | bool operator()( const vnl_vector &a, const vnl_vector &b) const; 43 | }; 44 | 45 | // mesh cache type 46 | typedef std::map< const vnl_vector, vtkSmartPointer, vnl_vector_compare > CacheMap; 47 | 48 | // LRC list 49 | typedef std::list< CacheListItem > CacheList; 50 | 51 | class MeshCache 52 | { 53 | 54 | public: 55 | 56 | MeshCache(Preferences& prefs); 57 | 58 | vtkSmartPointer getMesh( const vnl_vector& vector ); 59 | 60 | void insertMesh( const vnl_vector& shape, vtkSmartPointer mesh ); 61 | 62 | void clear(); 63 | 64 | static Preferences * pref_ref_; 65 | 66 | private: 67 | 68 | void freeSpaceForAmount( size_t allocation ); 69 | 70 | static long long getTotalPhysicalMemory(); 71 | static long long getTotalAddressibleMemory(); 72 | static long long getTotalAddressiblePhysicalMemory(); 73 | 74 | Preferences &preferences_; 75 | // mesh cache 76 | CacheMap meshCache; 77 | 78 | // lrc list 79 | CacheList cacheList; 80 | 81 | // size of memory in use by the cache 82 | size_t memorySize; 83 | 84 | // maximum memory 85 | long long maxMemory; 86 | 87 | // for concurrent access 88 | QMutex mutex; 89 | }; 90 | 91 | #endif // ifndef MESH_CACHE_H 92 | -------------------------------------------------------------------------------- /src/Application/Data/MeshGenerator.cc: -------------------------------------------------------------------------------- 1 | /* 2 | * Shapeworks license 3 | */ 4 | 5 | #include 6 | #include 7 | #include 8 | 9 | MeshGenerator::MeshGenerator(Preferences& prefs, 10 | Reconstruction& construct) : prefs_(prefs), construct_(construct) {} 11 | 12 | MeshGenerator::~MeshGenerator() {} 13 | 14 | vtkSmartPointer MeshGenerator::buildMesh( 15 | const vnl_vector& shape ) { 16 | std::vector > pts; 17 | for (size_t i = 0; i < shape.size(); i += 3) { 18 | float arr[] = {static_cast(shape[i]), 19 | static_cast(shape[i + 1]), 20 | static_cast(shape[i + 2]) }; 21 | itk::Point pt(arr); 22 | pts.push_back(pt); 23 | } 24 | return this->construct_.getMesh(pts); 25 | } 26 | -------------------------------------------------------------------------------- /src/Application/Data/MeshGenerator.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Shapeworks license 3 | */ 4 | 5 | /** 6 | * @file MeshGenerator.h 7 | * @brief Mesh generation 8 | * 9 | * The MeshGenerator performs the actual work of reconstructing 10 | * a mesh from a shape (list of points). 11 | */ 12 | 13 | #ifndef MESH_GENERATOR_H 14 | #define MESH_GENERATOR_H 15 | 16 | #include "vnl/vnl_vector.h" 17 | #include 18 | #include 19 | 20 | class MeshGenerator 21 | { 22 | public: 23 | MeshGenerator(Preferences& prefs_, Reconstruction& construct); 24 | ~MeshGenerator(); 25 | vtkSmartPointer buildMesh(const vnl_vector& shape); 26 | 27 | private: 28 | Preferences& prefs_; 29 | Reconstruction& construct_; 30 | }; 31 | 32 | #endif // ifndef MESH_GENERATOR_H 33 | -------------------------------------------------------------------------------- /src/Application/Data/MeshManager.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Shapeworks license 3 | */ 4 | 5 | /** 6 | * @file MeshManager.h 7 | * @brief Class to manage meshes 8 | * 9 | * The MeshManager handles all aspects of mesh generation and caching. 10 | * It houses the cache and manages threads to work on mesh generation 11 | * in the background. 12 | */ 13 | 14 | #ifndef MESH_MANAGER_H 15 | #define MESH_MANAGER_H 16 | 17 | #include 18 | 19 | #include 20 | 21 | #include 22 | #include 23 | #include 24 | #include 25 | #include 26 | #include 27 | 28 | class MeshManager : public QObject 29 | { 30 | Q_OBJECT 31 | 32 | public: 33 | MeshManager(Preferences& prefs); 34 | ~MeshManager(); 35 | 36 | void initializeReconstruction( 37 | std::vector > > local_pts, 38 | std::vector > > global_pts, 39 | std::vector distance_transform, 40 | double maxAngle, 41 | float decimationPecent, 42 | int numClusters); 43 | bool hasDenseMean(); 44 | void setMean(vtkSmartPointer sparseMean, 45 | vtkSmartPointer denseMean, 46 | std::vector goodPoints); 47 | 48 | void writeMeanInfo(std::string baseName); 49 | void readMeanInfo(std::string dense, 50 | std::string sparse, std::string goodPoints); 51 | 52 | // pre-generate and cache a mesh for this shape 53 | void generateMesh( const vnl_vector& shape ); 54 | void resetReconstruct(); 55 | 56 | vtkSmartPointer getMesh( const vnl_vector& shape ); 57 | 58 | void clear_cache(); 59 | 60 | public Q_SLOTS: 61 | void handle_thread_complete(); 62 | 63 | signals: 64 | void new_mesh(); 65 | 66 | private: 67 | 68 | Preferences& prefs_; 69 | 70 | // cache of shape meshes 71 | MeshCache meshCache_; 72 | 73 | // our own mesh generator 74 | MeshGenerator meshGenerator_; 75 | 76 | // queue of meshes to build 77 | MeshWorkQueue workQueue_; 78 | 79 | // the workers 80 | std::vector threads_; 81 | 82 | size_t thread_count_; 83 | 84 | //reconstruction object 85 | Reconstruction construct_; 86 | }; 87 | 88 | #endif // ifndef MESH_Manager_H 89 | -------------------------------------------------------------------------------- /src/Application/Data/MeshSettings.cc: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | MeshSettings::MeshSettings() 4 | {} 5 | 6 | MeshSettings::~MeshSettings() 7 | {} 8 | -------------------------------------------------------------------------------- /src/Application/Data/MeshSettings.h: -------------------------------------------------------------------------------- 1 | #ifndef STUDIO_DATA_MESHSETTINGS_H 2 | #define STUDIO_DATA_MESHSETTINGS_H 3 | 4 | #include 5 | #include 6 | 7 | #include 8 | #include 9 | 10 | #include 11 | 12 | class MeshSettings; 13 | typedef QSharedPointer< MeshSettings > MeshSettingsHandle; 14 | 15 | //! Settings for creating a mesh. 16 | /*! 17 | * The MeshSettings class represents a set of settings used it creating a mesh. 18 | * 19 | */ 20 | class MeshSettings 21 | { 22 | 23 | public: 24 | 25 | /// Constructor 26 | MeshSettings(); 27 | 28 | /// Destructor 29 | ~MeshSettings(); 30 | 31 | private: 32 | }; 33 | 34 | #endif /* STUDIO_DATA_MESHSETTINGS_H */ 35 | -------------------------------------------------------------------------------- /src/Application/Data/MeshWorkQueue.cc: -------------------------------------------------------------------------------- 1 | /* 2 | * Shapeworks license 3 | */ 4 | 5 | #include 6 | 7 | MeshWorkQueue::MeshWorkQueue() 8 | {} 9 | 10 | MeshWorkQueue::~MeshWorkQueue() 11 | {} 12 | 13 | void MeshWorkQueue::push( const vnl_vector &item ) 14 | { 15 | QMutexLocker locker( &this->mutex ); 16 | this->workList.push_back( item ); 17 | } 18 | 19 | MeshWorkItem* MeshWorkQueue::pop() 20 | { 21 | QMutexLocker locker( &this->mutex ); 22 | MeshWorkItem* item = new MeshWorkItem; 23 | 24 | if ( this->workList.empty() ) 25 | { 26 | return NULL; 27 | } 28 | 29 | item->shape = this->workList.front(); 30 | this->workList.pop_front(); 31 | return item; 32 | } 33 | 34 | bool MeshWorkQueue::isInside( const vnl_vector &item ) 35 | { 36 | QMutexLocker locker( &this->mutex ); 37 | 38 | for ( WorkList::iterator it = this->workList.begin(); it != this->workList.end(); ++it ) 39 | { 40 | if ( *it == item ) 41 | { 42 | return true; 43 | } 44 | } 45 | return false; 46 | } 47 | 48 | void MeshWorkQueue::remove( const vnl_vector &item ) 49 | { 50 | QMutexLocker locker( &this->mutex ); 51 | 52 | this->workList.remove( item ); 53 | } 54 | 55 | bool MeshWorkQueue::isEmpty() 56 | { 57 | QMutexLocker locker( &this->mutex ); 58 | return this->workList.empty(); 59 | } 60 | -------------------------------------------------------------------------------- /src/Application/Data/MeshWorkQueue.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Shapeworks license 3 | */ 4 | 5 | /** 6 | * @file MeshWorkQueue.h 7 | * @brief Provides concurrent access to a list of shapes to work needing reconstruction 8 | * 9 | */ 10 | 11 | #ifndef MESH_WORK_QUEUE_H 12 | #define MESH_WORK_QUEUE_H 13 | 14 | // stl 15 | #include 16 | 17 | // qt 18 | #include 19 | 20 | // vnl 21 | #include "vnl/vnl_vector.h" 22 | 23 | class MeshWorkItem 24 | { 25 | public: 26 | vnl_vector shape; 27 | }; 28 | 29 | class MeshWorkQueue 30 | { 31 | 32 | public: 33 | MeshWorkQueue(); 34 | ~MeshWorkQueue(); 35 | 36 | void push( const vnl_vector &item ); 37 | 38 | MeshWorkItem* pop(); 39 | 40 | bool isInside( const vnl_vector &item ); 41 | 42 | void remove( const vnl_vector &item ); 43 | 44 | bool isEmpty(); 45 | 46 | private: 47 | 48 | // for concurrent access 49 | QMutex mutex; 50 | 51 | typedef std::list< vnl_vector > WorkList; 52 | 53 | WorkList workList; 54 | }; 55 | 56 | #endif // ifndef MESH_WORK_QUEUE_H 57 | -------------------------------------------------------------------------------- /src/Application/Data/MeshWorker.cc: -------------------------------------------------------------------------------- 1 | /* 2 | * Shapeworks license 3 | */ 4 | 5 | // vtk 6 | #include 7 | 8 | #include 9 | 10 | MeshWorker::MeshWorker(Preferences& prefs, 11 | const vnl_vector shape, 12 | Reconstruction& construct, 13 | MeshWorkQueue *queue, 14 | MeshCache * cache) 15 | : prefs_(prefs), meshGenerator_(prefs, construct), 16 | shape_(shape), queue_(queue), cache_(cache) {} 17 | 18 | MeshWorker::~MeshWorker() {} 19 | 20 | void MeshWorker::process() 21 | { 22 | // build the mesh using our MeshGenerator 23 | vtkSmartPointer mesh = this->meshGenerator_.buildMesh(this->shape_); 24 | this->queue_->remove(this->shape_); 25 | this->cache_->insertMesh(this->shape_, mesh); 26 | emit result_ready(); 27 | } -------------------------------------------------------------------------------- /src/Application/Data/MeshWorker.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Shapeworks license 3 | */ 4 | 5 | /** 6 | * @file MeshWorker.h 7 | * @brief Worker class for parallel mesh reconstruction 8 | * 9 | * The MeshWorker implements each threads mesh construction management 10 | */ 11 | 12 | #ifndef MESH_WORKER_H 13 | #define MESH_WORKER_H 14 | 15 | #include 16 | #include 17 | 18 | #include 19 | #include 20 | #include 21 | #include 22 | 23 | class MeshWorker : public QObject 24 | { 25 | Q_OBJECT 26 | 27 | public: 28 | MeshWorker(Preferences& prefs, 29 | const vnl_vector shape, 30 | Reconstruction& construct, 31 | MeshWorkQueue *queue, 32 | MeshCache * cache); 33 | ~MeshWorker(); 34 | MeshGenerator* getMeshGenerator(); 35 | 36 | public Q_SLOTS: 37 | void process(); 38 | 39 | Q_SIGNALS: 40 | void result_ready(); 41 | void finished(); 42 | 43 | private: 44 | Preferences& prefs_; 45 | MeshGenerator meshGenerator_; 46 | vnl_vector shape_; 47 | MeshWorkQueue *queue_; 48 | MeshCache * cache_; 49 | }; 50 | 51 | #endif // ifndef MESH_WORKER_H 52 | -------------------------------------------------------------------------------- /src/Application/Data/Preferences.h: -------------------------------------------------------------------------------- 1 | #ifndef STUDIO_APPLICATION_PREFERENCES_H 2 | #define STUDIO_APPLICATION_PREFERENCES_H 3 | 4 | #include 5 | #include 6 | 7 | //! Application preferences 8 | /*! 9 | * The Preferences singleton controls all preferences for the application. 10 | * Values persist via the QSettings class. 11 | */ 12 | class Preferences : public QObject 13 | { 14 | Q_OBJECT; 15 | 16 | public: 17 | 18 | enum { MAX_RECENT_FILES = 4 }; 19 | Preferences(); 20 | void restore_defaults(bool force = false); 21 | void delete_entry(std::string entry); 22 | void add_recent_file(QString file); 23 | QStringList get_recent_files(); 24 | bool not_saved(); 25 | void set_saved(bool saved = true); 26 | std::map getAllPreferences(); 27 | template 28 | T get_preference(std::string name, T default_val) { 29 | return this->settings_.value(QString::fromStdString(name), 30 | QVariant(default_val)).template value(); 31 | } 32 | 33 | template 34 | void set_preference(std::string name, T value) { 35 | this->settings_.setValue(QString::fromStdString(name), QVariant(value)); 36 | this->saved_ = false; 37 | } 38 | 39 | Q_SIGNALS: 40 | void color_scheme_changed( int newIndex ); 41 | void glyph_properties_changed(); 42 | void threading_changed_signal(); 43 | void sliders_changed_signal(); 44 | 45 | private: 46 | /// the QSettings object 47 | QSettings settings_; 48 | bool saved_; 49 | }; 50 | 51 | #endif // ifndef STUDIO_APPLICATION_PREFERENCES_H 52 | -------------------------------------------------------------------------------- /src/Application/Data/PreferencesWindow.h: -------------------------------------------------------------------------------- 1 | #ifndef STUDIO_APPLICATION_PREFERENCES_WINDOW_H 2 | #define STUDIO_APPLICATION_PREFERENCES_WINDOW_H 3 | 4 | #include 5 | #include "Data/Preferences.h" 6 | 7 | class Ui_PreferencesWindow; 8 | class QAbstractButton; 9 | 10 | //! Qt UI dialog to control preferences 11 | /*! 12 | * The PreferenceWindow provides controls over preferences for the 13 | * application. It is synchronized with the singleton Preference object 14 | */ 15 | class PreferencesWindow : public QDialog 16 | { 17 | Q_OBJECT 18 | 19 | public: 20 | PreferencesWindow(QWidget* parent, Preferences& prefs); 21 | 22 | void set_values_from_preferences(); 23 | 24 | public Q_SLOTS: 25 | void on_mesh_cache_enabled_stateChanged( int state ); 26 | void on_mesh_cache_memory_valueChanged( int value ); 27 | void on_color_scheme_currentIndexChanged( int index ); 28 | void on_pca_range_valueChanged( double value ); 29 | void on_pca_steps_valueChanged( int value ); 30 | void on_parallel_enabled_toggled(bool b); 31 | void on_num_threads_valueChanged(int i); 32 | void on_caching_epsilon_valueChanged(int i); 33 | 34 | void restore_defaults(); 35 | signals: 36 | void clear_cache(); 37 | void update_view(); 38 | void slider_update(); 39 | 40 | private: 41 | Preferences &preferences_; 42 | Ui_PreferencesWindow* ui_; 43 | }; 44 | 45 | #endif // STUDIO_APPLICATION_PREFERENCES_WINDOW_H 46 | -------------------------------------------------------------------------------- /src/Application/Data/itkParticlePositionReader.txx: -------------------------------------------------------------------------------- 1 | /*========================================================================= 2 | Program: ShapeWorks: Particle-based Shape Correspondence & Visualization 3 | Module: $RCSfile: itkParticlePositionReader.txx,v $ 4 | Date: $Date: 2011/03/24 01:17:33 $ 5 | Version: $Revision: 1.2 $ 6 | Author: $Author: wmartin $ 7 | 8 | Copyright (c) 2009 Scientific Computing and Imaging Institute. 9 | See ShapeWorksLicense.txt for details. 10 | 11 | This software is distributed WITHOUT ANY WARRANTY; without even 12 | the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR 13 | PURPOSE. See the above copyright notices for more information. 14 | =========================================================================*/ 15 | #ifndef __itkParticlePositionReader_txx 16 | #define __itkParticlePositionReader_txx 17 | 18 | #include 19 | 20 | namespace itk 21 | { 22 | 23 | template 24 | void ParticlePositionReader::Update() 25 | { 26 | int counter = 0; 27 | // Open the ascii file. 28 | std::ifstream in( m_FileName.c_str() ); 29 | if ( !in ) 30 | { 31 | itkExceptionMacro( "Could not open point file for input: " << m_FileName.c_str() ); 32 | } 33 | 34 | // in >> num_points; 35 | 36 | // Read all of the points, one point per line. 37 | while ( in ) 38 | { 39 | PointType pt; 40 | for ( unsigned int d = 0; d < VDimension; d++ ) 41 | { 42 | in >> pt[d]; 43 | } 44 | 45 | m_Output.push_back( pt ); 46 | counter++; 47 | } 48 | // this algorithm pushes the last point twice 49 | m_Output.pop_back(); 50 | // std::cout << "Read " << counter-1 << " points. " << std::endl; 51 | in.close(); 52 | } 53 | } 54 | 55 | #endif /* ifndef __itkParticlePositionReader_txx */ 56 | -------------------------------------------------------------------------------- /src/Application/Data/itkParticlePositionWriter.txx: -------------------------------------------------------------------------------- 1 | /*========================================================================= 2 | Program: ShapeWorks: Particle-based Shape Correspondence & Visualization 3 | Module: $RCSfile: itkParticlePositionWriter.txx,v $ 4 | Date: $Date: 2011/03/24 01:17:33 $ 5 | Version: $Revision: 1.2 $ 6 | Author: $Author: wmartin $ 7 | 8 | Copyright (c) 2009 Scientific Computing and Imaging Institute. 9 | See ShapeWorksLicense.txt for details. 10 | 11 | This software is distributed WITHOUT ANY WARRANTY; without even 12 | the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR 13 | PURPOSE. See the above copyright notices for more information. 14 | =========================================================================*/ 15 | #ifndef __itkParticlePositionWriter_txx 16 | #define __itkParticlePositionWriter_txx 17 | 18 | #include 19 | 20 | namespace itk 21 | { 22 | 23 | template 24 | void ParticlePositionWriter::Update() 25 | { 26 | // Open the output file. 27 | std::ofstream out( m_FileName.c_str() ); 28 | 29 | if ( !out ) 30 | { 31 | itkExceptionMacro( "Could not open point file for output: " << m_FileName.c_str() ); 32 | } 33 | 34 | // out << num_points; 35 | 36 | // Write points. 37 | for ( typename std::vector::const_iterator it = m_Input.begin(); 38 | it != m_Input.end(); it++ ) 39 | { 40 | for ( unsigned int i = 0; i < VDimension; i++ ) 41 | { 42 | out << ( *it )[i] << " "; 43 | } 44 | out << std::endl; 45 | } 46 | 47 | out.close(); 48 | } 49 | } 50 | 51 | #endif /* ifndef __itkParticlePositionWriter_txx */ 52 | -------------------------------------------------------------------------------- /src/Application/Groom/GroomTool.h: -------------------------------------------------------------------------------- 1 | #ifndef STUDIO_GROOM_GROOMTOOL_H 2 | #define STUDIO_GROOM_GROOMTOOL_H 3 | 4 | #include 5 | #include 6 | #include 7 | #include "Data/Preferences.h" 8 | #include 9 | #include 10 | 11 | class Project; 12 | class Ui_GroomTool; 13 | class ShapeWorksStudioApp; 14 | 15 | Q_DECLARE_METATYPE(std::string) 16 | 17 | class GroomTool : public QWidget 18 | { 19 | Q_OBJECT; 20 | public: 21 | 22 | GroomTool(Preferences& prefs, std::vector& files); 23 | ~GroomTool(); 24 | 25 | /// set the pointer to the project 26 | void set_project( QSharedPointer project ); 27 | 28 | void update_preferences(); 29 | void set_preferences(); 30 | void disableActions(); 31 | void enableActions(); 32 | 33 | Q_SIGNALS: 34 | void groom_complete(); 35 | void error_message(std::string); 36 | void message(std::string); 37 | void progress(size_t); 38 | 39 | public Q_SLOTS: 40 | 41 | void on_antialias_checkbox_stateChanged( int state ); 42 | void on_blur_checkbox_stateChanged(int state); 43 | void on_autopad_checkbox_stateChanged(int state); 44 | void on_skipButton_clicked(); 45 | void handle_thread_complete(); 46 | void handle_progress(int val); 47 | void on_restoreDefaults_clicked(); 48 | void handle_error(std::string msg); 49 | 50 | /// Run groom tool 51 | void on_run_groom_button_clicked(); 52 | 53 | private: 54 | 55 | Ui_GroomTool* ui_; 56 | QSharedPointer project_; 57 | Preferences& preferences_; 58 | std::vector& files_; 59 | QGroom * groom_; 60 | }; 61 | 62 | #endif /* STUDIO_GROOM_GROOMTOOL_H */ 63 | -------------------------------------------------------------------------------- /src/Application/Groom/QGroom.cpp: -------------------------------------------------------------------------------- 1 | #include "QGroom.h" 2 | 3 | QGroom::QGroom(QObject * parent, 4 | std::vector inputs, 5 | double background, double foreground, 6 | double sigma, size_t padding, 7 | size_t iterations, bool verbose) 8 | : QObject(parent), ShapeWorksGroom(inputs, 9 | background, foreground, sigma, 10 | padding, iterations, verbose) {} 11 | 12 | void QGroom::run() { 13 | this->seed_.Fill(0); 14 | size_t ran = 0, total = this->runTools_.size() * this->images_.size(); 15 | if (this->runTools_.count("center")) { 16 | for (size_t i = 0; i < this->images_.size(); i++) { 17 | this->center(static_cast(i)); 18 | emit progress(++ran * 100 / total); 19 | } 20 | } 21 | if (this->runTools_.count("isolate")) { 22 | for (size_t i = 0; i < this->images_.size(); i++) { 23 | this->isolate(static_cast(i)); 24 | emit progress(++ran * 100 / total); 25 | } 26 | } 27 | if (this->runTools_.count("hole_fill")) { 28 | for (size_t i = 0; i < this->images_.size(); i++) { 29 | this->hole_fill(static_cast(i)); 30 | emit progress(++ran * 100 / total); 31 | } 32 | } 33 | if (this->runTools_.count("auto_pad")) { 34 | for (size_t i = 0; i < this->images_.size(); i++) { 35 | this->auto_pad(static_cast(i)); 36 | emit progress(++ran * 100 / total); 37 | } 38 | } 39 | if (this->runTools_.count("antialias")) { 40 | for (size_t i = 0; i < this->images_.size(); i++) { 41 | this->antialias(static_cast(i)); 42 | emit progress(++ran * 100 / total); 43 | } 44 | } 45 | if (this->runTools_.count("fastmarching")) { 46 | for (size_t i = 0; i < this->images_.size(); i++) { 47 | this->fastmarching(static_cast(i)); 48 | emit progress(++ran * 100 / total); 49 | } 50 | } 51 | if (this->runTools_.count("blur")) { 52 | for (size_t i = 0; i < this->images_.size(); i++) { 53 | this->blur(static_cast(i)); 54 | emit progress(++ran * 100 / total); 55 | } 56 | } 57 | } 58 | -------------------------------------------------------------------------------- /src/Application/Groom/QGroom.h: -------------------------------------------------------------------------------- 1 | #ifndef __QSHAPEWORKSGROOM_H__ 2 | #define __QSHAPEWORKSGROOM_H__ 3 | 4 | #include 5 | #include 6 | 7 | class QGroom : public QObject, public ShapeWorksGroom { 8 | Q_OBJECT; 9 | public: 10 | QGroom(QObject *parent = nullptr, 11 | std::vector inputs = std::vector(), 12 | double background = 0., double foreground = 0., 13 | double sigma = 2.0, size_t padding = 0, 14 | size_t iterations = 100, bool verbose = false); 15 | signals: 16 | void progress(int); 17 | public: 18 | virtual void run(); 19 | }; 20 | 21 | #endif -------------------------------------------------------------------------------- /src/Application/Optimize/OptimizeTool.h: -------------------------------------------------------------------------------- 1 | #ifndef STUDIO_OPTIMIZE_OPTIMIZETOOL_H 2 | #define STUDIO_OPTIMIZE_OPTIMIZETOOL_H 3 | 4 | #include 5 | #include 6 | #include 7 | #include "Data/Preferences.h" 8 | #include "QOptimize.h" 9 | 10 | class Project; 11 | class Ui_OptimizeTool; 12 | 13 | class OptimizeTool : public QWidget 14 | { 15 | Q_OBJECT; 16 | public: 17 | 18 | OptimizeTool(Preferences& prefs); 19 | ~OptimizeTool(); 20 | 21 | /// set the pointer to the project 22 | void set_project( QSharedPointer project ); 23 | 24 | void set_preferences(bool setScales = false); 25 | 26 | void update_preferences(); 27 | void enableActions(); 28 | void disableActions(); 29 | void setCutPlanesFile(std::string file); 30 | std::string getCutPlanesFile(); 31 | 32 | public Q_SLOTS: 33 | 34 | /// Run optimize tool 35 | void on_run_optimize_button_clicked(); 36 | void on_cutPlanesFile_editingFinished(); 37 | void on_reconstructionButton_clicked(); 38 | void on_cutPlanesFileButton_clicked(); 39 | void on_restoreDefaults_clicked(); 40 | void on_number_of_particles_valueChanged(int val); 41 | void handle_optimize_complete(); 42 | void handle_reconstruction_complete(); 43 | void handle_progress(int val); 44 | void handle_error(std::string); 45 | void handle_warning(std::string); 46 | void on_meshDecimation_valueChanged(double v); 47 | void on_numClusters_valueChanged(int v); 48 | void on_weight_valueChanged(double v); 49 | void on_maxAngle_valueChanged(double v); 50 | void on_starting_regularization_valueChanged(double v); 51 | void on_ending_regularization_valueChanged(double v); 52 | void on_iterations_valueChanged(int v); 53 | void on_decay_span_valueChanged(int v); 54 | void on_procrustes_interval_valueChanged(int v); 55 | void handle_message(std::string); 56 | private: 57 | void loadCutPlanesFile(std::string file); 58 | signals: 59 | void optimize_complete(); 60 | void reconstruction_complete(); 61 | void error_message(std::string); 62 | void warning_message(std::string); 63 | void progress(size_t); 64 | void message(std::string); 65 | 66 | private: 67 | QOptimize * optimize_; 68 | Preferences& preferences_; 69 | Ui_OptimizeTool* ui_; 70 | QSharedPointer project_; 71 | std::vector, 3 > > cutPlanes_; 72 | }; 73 | 74 | #endif /* STUDIO_OPTIMIZE_OPTIMIZETOOL_H */ 75 | -------------------------------------------------------------------------------- /src/Application/Optimize/QOptimize.cpp: -------------------------------------------------------------------------------- 1 | #include "QOptimize.h" 2 | 3 | QOptimize::QOptimize(QObject * parent, 4 | std::vector inputs, 5 | std::vector, 3 > > cutPlanes, 6 | size_t numScales, std::vector start_reg, 7 | std::vector end_reg, std::vector iters, 8 | std::vector decay_span, std::vector procrustes_interval, double weight, bool verbose) 9 | : QObject(parent), ShapeWorksOptimize(inputs, cutPlanes, numScales, 10 | start_reg, end_reg, iters, decay_span, procrustes_interval, weight, verbose) {} 11 | 12 | void QOptimize::iterateCallback(itk::Object * caller, const itk::EventObject &e) { 13 | itk::PSMEntropyModelFilter *o = 14 | reinterpret_cast *>(caller); 15 | ShapeWorksOptimize::iterateCallback(caller, e); 16 | auto transform = o->GetParticleSystem()->GetTransform(); 17 | //throw on NaN 18 | if (transform(0,0) != transform(0,0)) { 19 | throw std::runtime_error("Optimize failed! Please try changing parameters."); 20 | } 21 | if (o->GetNumberOfElapsedIterations() % this->reportInterval_ == 0) { 22 | this->iterCount_ += this->reportInterval_; 23 | emit progress(this->iterCount_ * 100 / this->totalIters_); 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /src/Application/Optimize/QOptimize.h: -------------------------------------------------------------------------------- 1 | #ifndef __QSHAPEWORKSOPTIMIZE_H__ 2 | #define __QSHAPEWORKSOPTIMIZE_H__ 3 | 4 | #include 5 | #include 6 | #include 7 | 8 | class QOptimize : public QObject, public ShapeWorksOptimize { 9 | Q_OBJECT; 10 | public: 11 | QOptimize(QObject* parent = nullptr, 12 | std::vector inputs = 13 | std::vector(), 14 | std::vector, 3 > > cutPlanes = 15 | std::vector, 3 > >(), 16 | size_t numScales = 1, 17 | std::vector start_reg = std::vector(), 18 | std::vector end_reg = std::vector(), 19 | std::vector iters = std::vector(), 20 | std::vector decay_span = std::vector(), 21 | std::vector procrustes_interval = std::vector(), 22 | double weight = 1.0, 23 | bool verbose = false); 24 | protected: 25 | virtual void iterateCallback( 26 | itk::Object *caller, const itk::EventObject &); 27 | signals: 28 | void progress(int); 29 | }; 30 | 31 | #endif 32 | 33 | -------------------------------------------------------------------------------- /src/Application/Resources/Images/1395370627_flow_free.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SCIInstitute/ShapeWorksStudio/795388bdd6b167a61114b839208af185421c46df/src/Application/Resources/Images/1395370627_flow_free.png -------------------------------------------------------------------------------- /src/Application/Resources/Images/1395370653_question-type-one-correct.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SCIInstitute/ShapeWorksStudio/795388bdd6b167a61114b839208af185421c46df/src/Application/Resources/Images/1395370653_question-type-one-correct.png -------------------------------------------------------------------------------- /src/Application/Resources/Images/Analysis.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SCIInstitute/ShapeWorksStudio/795388bdd6b167a61114b839208af185421c46df/src/Application/Resources/Images/Analysis.png -------------------------------------------------------------------------------- /src/Application/Resources/Images/Application.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SCIInstitute/ShapeWorksStudio/795388bdd6b167a61114b839208af185421c46df/src/Application/Resources/Images/Application.png -------------------------------------------------------------------------------- /src/Application/Resources/Images/AutoView.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SCIInstitute/ShapeWorksStudio/795388bdd6b167a61114b839208af185421c46df/src/Application/Resources/Images/AutoView.png -------------------------------------------------------------------------------- /src/Application/Resources/Images/AutoViewOff.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SCIInstitute/ShapeWorksStudio/795388bdd6b167a61114b839208af185421c46df/src/Application/Resources/Images/AutoViewOff.png -------------------------------------------------------------------------------- /src/Application/Resources/Images/DataPanel.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SCIInstitute/ShapeWorksStudio/795388bdd6b167a61114b839208af185421c46df/src/Application/Resources/Images/DataPanel.png -------------------------------------------------------------------------------- /src/Application/Resources/Images/DownArrow.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SCIInstitute/ShapeWorksStudio/795388bdd6b167a61114b839208af185421c46df/src/Application/Resources/Images/DownArrow.png -------------------------------------------------------------------------------- /src/Application/Resources/Images/DownArrowWhite.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SCIInstitute/ShapeWorksStudio/795388bdd6b167a61114b839208af185421c46df/src/Application/Resources/Images/DownArrowWhite.png -------------------------------------------------------------------------------- /src/Application/Resources/Images/Groom.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SCIInstitute/ShapeWorksStudio/795388bdd6b167a61114b839208af185421c46df/src/Application/Resources/Images/Groom.png -------------------------------------------------------------------------------- /src/Application/Resources/Images/IsosurfaceVisible.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SCIInstitute/ShapeWorksStudio/795388bdd6b167a61114b839208af185421c46df/src/Application/Resources/Images/IsosurfaceVisible.png -------------------------------------------------------------------------------- /src/Application/Resources/Images/IsosurfaceVisibleOff.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SCIInstitute/ShapeWorksStudio/795388bdd6b167a61114b839208af185421c46df/src/Application/Resources/Images/IsosurfaceVisibleOff.png -------------------------------------------------------------------------------- /src/Application/Resources/Images/Optimize.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SCIInstitute/ShapeWorksStudio/795388bdd6b167a61114b839208af185421c46df/src/Application/Resources/Images/Optimize.png -------------------------------------------------------------------------------- /src/Application/Resources/Images/Render.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SCIInstitute/ShapeWorksStudio/795388bdd6b167a61114b839208af185421c46df/src/Application/Resources/Images/Render.png -------------------------------------------------------------------------------- /src/Application/Resources/Images/RightArrow.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SCIInstitute/ShapeWorksStudio/795388bdd6b167a61114b839208af185421c46df/src/Application/Resources/Images/RightArrow.png -------------------------------------------------------------------------------- /src/Application/Resources/Images/RightArrowWhite.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SCIInstitute/ShapeWorksStudio/795388bdd6b167a61114b839208af185421c46df/src/Application/Resources/Images/RightArrowWhite.png -------------------------------------------------------------------------------- /src/Application/Resources/Images/Visible.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SCIInstitute/ShapeWorksStudio/795388bdd6b167a61114b839208af185421c46df/src/Application/Resources/Images/Visible.png -------------------------------------------------------------------------------- /src/Application/Resources/Images/VisibleOff.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SCIInstitute/ShapeWorksStudio/795388bdd6b167a61114b839208af185421c46df/src/Application/Resources/Images/VisibleOff.png -------------------------------------------------------------------------------- /src/Application/Resources/Images/acorn.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SCIInstitute/ShapeWorksStudio/795388bdd6b167a61114b839208af185421c46df/src/Application/Resources/Images/acorn.png -------------------------------------------------------------------------------- /src/Application/Resources/Images/add.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SCIInstitute/ShapeWorksStudio/795388bdd6b167a61114b839208af185421c46df/src/Application/Resources/Images/add.png -------------------------------------------------------------------------------- /src/Application/Resources/Images/blocks.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SCIInstitute/ShapeWorksStudio/795388bdd6b167a61114b839208af185421c46df/src/Application/Resources/Images/blocks.png -------------------------------------------------------------------------------- /src/Application/Resources/Images/blocks2.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SCIInstitute/ShapeWorksStudio/795388bdd6b167a61114b839208af185421c46df/src/Application/Resources/Images/blocks2.png -------------------------------------------------------------------------------- /src/Application/Resources/Images/blue_ball.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SCIInstitute/ShapeWorksStudio/795388bdd6b167a61114b839208af185421c46df/src/Application/Resources/Images/blue_ball.png -------------------------------------------------------------------------------- /src/Application/Resources/Images/bug.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SCIInstitute/ShapeWorksStudio/795388bdd6b167a61114b839208af185421c46df/src/Application/Resources/Images/bug.png -------------------------------------------------------------------------------- /src/Application/Resources/Images/chart.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SCIInstitute/ShapeWorksStudio/795388bdd6b167a61114b839208af185421c46df/src/Application/Resources/Images/chart.png -------------------------------------------------------------------------------- /src/Application/Resources/Images/circle.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SCIInstitute/ShapeWorksStudio/795388bdd6b167a61114b839208af185421c46df/src/Application/Resources/Images/circle.png -------------------------------------------------------------------------------- /src/Application/Resources/Images/data.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SCIInstitute/ShapeWorksStudio/795388bdd6b167a61114b839208af185421c46df/src/Application/Resources/Images/data.png -------------------------------------------------------------------------------- /src/Application/Resources/Images/dots.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SCIInstitute/ShapeWorksStudio/795388bdd6b167a61114b839208af185421c46df/src/Application/Resources/Images/dots.png -------------------------------------------------------------------------------- /src/Application/Resources/Images/gear.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SCIInstitute/ShapeWorksStudio/795388bdd6b167a61114b839208af185421c46df/src/Application/Resources/Images/gear.png -------------------------------------------------------------------------------- /src/Application/Resources/Images/gear2.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SCIInstitute/ShapeWorksStudio/795388bdd6b167a61114b839208af185421c46df/src/Application/Resources/Images/gear2.png -------------------------------------------------------------------------------- /src/Application/Resources/Images/grey_ball.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SCIInstitute/ShapeWorksStudio/795388bdd6b167a61114b839208af185421c46df/src/Application/Resources/Images/grey_ball.png -------------------------------------------------------------------------------- /src/Application/Resources/Images/hammer.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SCIInstitute/ShapeWorksStudio/795388bdd6b167a61114b839208af185421c46df/src/Application/Resources/Images/hammer.png -------------------------------------------------------------------------------- /src/Application/Resources/Images/hammer2.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SCIInstitute/ShapeWorksStudio/795388bdd6b167a61114b839208af185421c46df/src/Application/Resources/Images/hammer2.png -------------------------------------------------------------------------------- /src/Application/Resources/Images/injection.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SCIInstitute/ShapeWorksStudio/795388bdd6b167a61114b839208af185421c46df/src/Application/Resources/Images/injection.png -------------------------------------------------------------------------------- /src/Application/Resources/Images/palette.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SCIInstitute/ShapeWorksStudio/795388bdd6b167a61114b839208af185421c46df/src/Application/Resources/Images/palette.png -------------------------------------------------------------------------------- /src/Application/Resources/Images/pencil.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SCIInstitute/ShapeWorksStudio/795388bdd6b167a61114b839208af185421c46df/src/Application/Resources/Images/pencil.png -------------------------------------------------------------------------------- /src/Application/Resources/Images/pref-general.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SCIInstitute/ShapeWorksStudio/795388bdd6b167a61114b839208af185421c46df/src/Application/Resources/Images/pref-general.png -------------------------------------------------------------------------------- /src/Application/Resources/Images/purple_ball.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SCIInstitute/ShapeWorksStudio/795388bdd6b167a61114b839208af185421c46df/src/Application/Resources/Images/purple_ball.png -------------------------------------------------------------------------------- /src/Application/Resources/Images/pyramid.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SCIInstitute/ShapeWorksStudio/795388bdd6b167a61114b839208af185421c46df/src/Application/Resources/Images/pyramid.png -------------------------------------------------------------------------------- /src/Application/Resources/Images/red_dots.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SCIInstitute/ShapeWorksStudio/795388bdd6b167a61114b839208af185421c46df/src/Application/Resources/Images/red_dots.png -------------------------------------------------------------------------------- /src/Application/Resources/Images/remove.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SCIInstitute/ShapeWorksStudio/795388bdd6b167a61114b839208af185421c46df/src/Application/Resources/Images/remove.png -------------------------------------------------------------------------------- /src/Application/Resources/Images/run.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SCIInstitute/ShapeWorksStudio/795388bdd6b167a61114b839208af185421c46df/src/Application/Resources/Images/run.png -------------------------------------------------------------------------------- /src/Application/Resources/Images/screwdriver.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SCIInstitute/ShapeWorksStudio/795388bdd6b167a61114b839208af185421c46df/src/Application/Resources/Images/screwdriver.png -------------------------------------------------------------------------------- /src/Application/Resources/Images/select.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SCIInstitute/ShapeWorksStudio/795388bdd6b167a61114b839208af185421c46df/src/Application/Resources/Images/select.png -------------------------------------------------------------------------------- /src/Application/Resources/Images/shapes-icon.ico: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SCIInstitute/ShapeWorksStudio/795388bdd6b167a61114b839208af185421c46df/src/Application/Resources/Images/shapes-icon.ico -------------------------------------------------------------------------------- /src/Application/Resources/Images/shapes-icon.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SCIInstitute/ShapeWorksStudio/795388bdd6b167a61114b839208af185421c46df/src/Application/Resources/Images/shapes-icon.png -------------------------------------------------------------------------------- /src/Application/Resources/Images/snowflake.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SCIInstitute/ShapeWorksStudio/795388bdd6b167a61114b839208af185421c46df/src/Application/Resources/Images/snowflake.png -------------------------------------------------------------------------------- /src/Application/Resources/Images/spinner.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SCIInstitute/ShapeWorksStudio/795388bdd6b167a61114b839208af185421c46df/src/Application/Resources/Images/spinner.png -------------------------------------------------------------------------------- /src/Application/Resources/Images/star.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SCIInstitute/ShapeWorksStudio/795388bdd6b167a61114b839208af185421c46df/src/Application/Resources/Images/star.png -------------------------------------------------------------------------------- /src/Application/Resources/Images/star2.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SCIInstitute/ShapeWorksStudio/795388bdd6b167a61114b839208af185421c46df/src/Application/Resources/Images/star2.png -------------------------------------------------------------------------------- /src/Application/Resources/Images/studio.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SCIInstitute/ShapeWorksStudio/795388bdd6b167a61114b839208af185421c46df/src/Application/Resources/Images/studio.png -------------------------------------------------------------------------------- /src/Application/Resources/Images/tools.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SCIInstitute/ShapeWorksStudio/795388bdd6b167a61114b839208af185421c46df/src/Application/Resources/Images/tools.png -------------------------------------------------------------------------------- /src/Application/Resources/Images/unselect.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SCIInstitute/ShapeWorksStudio/795388bdd6b167a61114b839208af185421c46df/src/Application/Resources/Images/unselect.png -------------------------------------------------------------------------------- /src/Application/Resources/Images/wand.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SCIInstitute/ShapeWorksStudio/795388bdd6b167a61114b839208af185421c46df/src/Application/Resources/Images/wand.png -------------------------------------------------------------------------------- /src/Application/Resources/Images/wand2.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SCIInstitute/ShapeWorksStudio/795388bdd6b167a61114b839208af185421c46df/src/Application/Resources/Images/wand2.png -------------------------------------------------------------------------------- /src/Application/Resources/Images/wrench.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SCIInstitute/ShapeWorksStudio/795388bdd6b167a61114b839208af185421c46df/src/Application/Resources/Images/wrench.png -------------------------------------------------------------------------------- /src/Application/Resources/Images/wrench2.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SCIInstitute/ShapeWorksStudio/795388bdd6b167a61114b839208af185421c46df/src/Application/Resources/Images/wrench2.png -------------------------------------------------------------------------------- /src/Application/Resources/ShapeWorksStudio.icns: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SCIInstitute/ShapeWorksStudio/795388bdd6b167a61114b839208af185421c46df/src/Application/Resources/ShapeWorksStudio.icns -------------------------------------------------------------------------------- /src/Application/Resources/ShapeWorksStudio.qrc: -------------------------------------------------------------------------------- 1 | 2 | 3 | Images/shapes-icon.png 4 | Images/acorn.png 5 | Images/circle.png 6 | Images/hammer.png 7 | Images/bug.png 8 | Images/pencil.png 9 | Images/palette.png 10 | Images/red_dots.png 11 | Images/wand.png 12 | Images/injection.png 13 | Images/hammer2.png 14 | Images/wand2.png 15 | Images/star.png 16 | Images/star2.png 17 | Images/snowflake.png 18 | Images/grey_ball.png 19 | Images/run.png 20 | Images/blocks.png 21 | Images/blocks2.png 22 | Images/blue_ball.png 23 | Images/purple_ball.png 24 | Images/dots.png 25 | Images/wrench.png 26 | Images/wrench2.png 27 | Images/gear2.png 28 | Images/add.png 29 | Images/remove.png 30 | Images/select.png 31 | Images/unselect.png 32 | Images/data.png 33 | Images/chart.png 34 | Images/gear.png 35 | Images/tools.png 36 | Images/studio.png 37 | Images/DownArrow.png 38 | Images/DownArrowWhite.png 39 | Images/RightArrow.png 40 | Images/RightArrowWhite.png 41 | Images/AutoView.png 42 | Images/AutoViewOff.png 43 | Images/IsosurfaceVisible.png 44 | Images/IsosurfaceVisibleOff.png 45 | Images/Visible.png 46 | Images/VisibleOff.png 47 | Images/spinner.png 48 | 49 | 50 | -------------------------------------------------------------------------------- /src/Application/Resources/ShapeWorksStudio.rc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SCIInstitute/ShapeWorksStudio/795388bdd6b167a61114b839208af185421c46df/src/Application/Resources/ShapeWorksStudio.rc -------------------------------------------------------------------------------- /src/Application/Resources/resource.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SCIInstitute/ShapeWorksStudio/795388bdd6b167a61114b839208af185421c46df/src/Application/Resources/resource.h -------------------------------------------------------------------------------- /src/Application/Visualization/DisplayObject.h: -------------------------------------------------------------------------------- 1 | #ifndef STUDIO_VISUALIZATION_DISPLAYOBJECT_H 2 | #define STUDIO_VISUALIZATION_DISPLAYOBJECT_H 3 | 4 | #include 5 | #include 6 | 7 | #include 8 | 9 | #include 10 | 11 | class Mesh; 12 | 13 | class DisplayObject; 14 | typedef QSharedPointer< DisplayObject > DisplayObjectHandle; 15 | 16 | //! Representation of everything displayed in a single Viewer 17 | /*! 18 | * The DisplayObject class encapsulates all the data displayed by a single viewer 19 | * 20 | */ 21 | class DisplayObject 22 | { 23 | public: 24 | DisplayObject(); 25 | ~DisplayObject(); 26 | 27 | void set_mesh( QSharedPointer mesh ); 28 | QSharedPointer get_mesh(); 29 | 30 | void set_annotations( QStringList annotations ); 31 | QStringList get_annotations(); 32 | 33 | void set_correspondence_points( vnl_vector points ); 34 | vnl_vector get_correspondence_points(); 35 | 36 | void set_transform( const vnl_vector& transform ); 37 | vnl_vector get_transform(); 38 | 39 | QList get_exclusion_sphere_centers(); 40 | void set_exclusion_sphere_centers(QList centers); 41 | 42 | QList get_exclusion_sphere_radii(); 43 | void set_exclusion_sphere_radii(QList radii); 44 | 45 | private: 46 | QSharedPointer mesh_; 47 | vnl_vector correspondence_points_; 48 | QStringList corner_annotations_; 49 | vnl_vector transform_; 50 | 51 | QList exclusion_sphere_centers_; 52 | QList exclusion_sphere_radii_; 53 | 54 | }; 55 | 56 | #endif /* STUDIO_VISUALIZATION_DISPLAYOBJECT_H */ 57 | -------------------------------------------------------------------------------- /src/Application/Visualization/ShapeworksWorker.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Shapeworks license 3 | */ 4 | 5 | /** 6 | * @file MeshWorker.h 7 | * @brief Worker class for parallel mesh reconstruction 8 | * 9 | * The MeshWorker implements each threads mesh construction management 10 | */ 11 | 12 | #ifndef SHAPEWORKS_WORKER_H 13 | #define SHAPEWORKS_WORKER_H 14 | 15 | #include 16 | #include 17 | #include 18 | #include 19 | #include 20 | 21 | class ShapeworksWorker : public QObject 22 | { 23 | Q_OBJECT 24 | 25 | public: 26 | enum ThreadType { Groom, Optimize, Reconstruct }; 27 | ShapeworksWorker(ThreadType type, ShapeWorksGroom* groom, 28 | ShapeWorksOptimize* optimize, 29 | QSharedPointer project, 30 | std::vector > > local_pts = 31 | std::vector > >(), 32 | std::vector > > global_pts = 33 | std::vector > >(), 34 | std::vector distance_transform = 35 | std::vector(), 36 | double maxAngle = 45., 37 | float decimationPercent = 0.3f, 38 | int numClusters = 5); 39 | ~ShapeworksWorker(); 40 | 41 | public Q_SLOTS: 42 | void process(); 43 | 44 | Q_SIGNALS: 45 | void result_ready(); 46 | void error_message(std::string); 47 | void warning_message(std::string); 48 | void step_made(int val); 49 | void finished(); 50 | void message(std::string); 51 | 52 | private: 53 | ShapeWorksGroom* groom_; 54 | ShapeWorksOptimize*optimize_; 55 | QSharedPointer project_; 56 | ThreadType type_; 57 | std::vector > > local_pts_; 58 | std::vector > > global_pts_; 59 | std::vector distance_transform_; 60 | float decimationPercent_; 61 | double maxAngle_; 62 | int numClusters_; 63 | }; 64 | 65 | #endif // ifndef SHAPEWORKS_WORKER_H -------------------------------------------------------------------------------- /src/Application/Visualization/StudioInteractorStyle.cc: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | 6 | vtkStandardNewMacro( StudioInteractorStyle ); 7 | 8 | StudioInteractorStyle::StudioInteractorStyle() 9 | {} 10 | 11 | StudioInteractorStyle::~StudioInteractorStyle() 12 | {} 13 | 14 | void StudioInteractorStyle::OnLeftButtonDown() 15 | { 16 | /* 17 | std::cerr << "left button down\n"; 18 | if ( this->Interactor->GetAltKey() ) 19 | //if ( 1 ) 20 | { 21 | std::cerr << "ctrl down too\n"; 22 | int* clickPos = this->GetInteractor()->GetEventPosition(); 23 | this->lightbox_->handle_pick( clickPos ); 24 | } 25 | */ 26 | // forward events 27 | vtkInteractorStyleTrackballCamera::OnLeftButtonDown(); 28 | this->GetCurrentRenderer()->ResetCameraClippingRange(); 29 | } 30 | 31 | void StudioInteractorStyle::OnRightButtonDown() 32 | { 33 | /* 34 | int* clickPos = this->GetInteractor()->GetEventPosition(); 35 | this->lightbox_->handle_pick( clickPos ); 36 | */ 37 | // forward events 38 | vtkInteractorStyleTrackballCamera::OnRightButtonDown(); 39 | this->GetCurrentRenderer()->ResetCameraClippingRange(); 40 | } 41 | 42 | void StudioInteractorStyle::set_lightbox( Lightbox* lightbox ) 43 | { 44 | this->lightbox_ = lightbox; 45 | } 46 | 47 | void StudioInteractorStyle::OnMouseWheelForward() 48 | { 49 | // do nothing so that it will be passed on to Qt 50 | } 51 | 52 | void StudioInteractorStyle::OnMouseWheelBackward() 53 | { 54 | // do nothing so that it will be passed on to Qt 55 | } 56 | 57 | void StudioInteractorStyle::OnKeyDown() 58 | { 59 | int* click_pos = this->GetInteractor()->GetEventPosition(); 60 | 61 | char keycode = this->GetInteractor()->GetKeyCode(); 62 | 63 | switch ( keycode ) 64 | { 65 | case '1': 66 | this->lightbox_->handle_pick( click_pos, true ); 67 | break; 68 | 69 | case '2': 70 | this->lightbox_->handle_pick( click_pos, false ); 71 | break; 72 | } 73 | 74 | this->GetInteractor()->Render(); 75 | 76 | // forward events 77 | vtkInteractorStyleTrackballCamera::OnKeyDown(); 78 | } 79 | -------------------------------------------------------------------------------- /src/Application/Visualization/StudioInteractorStyle.h: -------------------------------------------------------------------------------- 1 | #ifndef STUDIO_VISUALIZATION_STUDIOINTERACTORSTYLE_H 2 | #define STUDIO_VISUALIZATION_STUDIOINTERACTORSTYLE_H 3 | 4 | #include 5 | #include 6 | #include 7 | 8 | class Lightbox; 9 | 10 | // Handle mouse events 11 | class StudioInteractorStyle : public vtkInteractorStyleTrackballCamera 12 | { 13 | public: 14 | static StudioInteractorStyle* New(); 15 | vtkTypeMacro( StudioInteractorStyle, vtkInteractorStyleTrackballCamera ); 16 | 17 | void set_lightbox( Lightbox* lightbox ); 18 | 19 | StudioInteractorStyle(); 20 | 21 | virtual ~StudioInteractorStyle(); 22 | 23 | virtual void OnLeftButtonDown(); 24 | virtual void OnRightButtonDown(); 25 | 26 | virtual void OnMouseWheelForward(); 27 | virtual void OnMouseWheelBackward(); 28 | 29 | virtual void OnKeyDown(); 30 | 31 | private: 32 | 33 | Lightbox* lightbox_; 34 | }; 35 | 36 | #endif /* STUDIO_VISUALIZATION_STUDIOINTERACTORSTYLE_H */ 37 | -------------------------------------------------------------------------------- /src/Application/Visualization/Visualizer.h: -------------------------------------------------------------------------------- 1 | #ifndef STUDIO_VISUALIZATION_VISUALIZER_H 2 | #define STUDIO_VISUALIZATION_VISUALIZER_H 3 | 4 | #include 5 | #include 6 | #include 7 | #include "Data/Preferences.h" 8 | #include 9 | #include 10 | 11 | class Visualizer; 12 | typedef QSharedPointer< Visualizer > VisualizerHandle; 13 | 14 | //! Controls display of objects in viewers 15 | /*! 16 | * The Visualizer class maintains state and control over viewer properties. 17 | * Additionally, it performs all shape-based statistical functions. 18 | */ 19 | class Visualizer : public QObject 20 | { 21 | Q_OBJECT; 22 | 23 | public: 24 | Visualizer(Preferences &prefs); 25 | ~Visualizer(); 26 | 27 | /// set the lightbox 28 | void set_lightbox( LightboxHandle lightbox ); 29 | 30 | /// set the project 31 | void set_project( ProjectHandle project ); 32 | 33 | /// set display mode (original, groomed, reconstructed) 34 | void set_display_mode( std::string mode ); 35 | 36 | /// turn automatic centering on/off 37 | void set_center( bool center ); 38 | 39 | /// turn on/off glyph display 40 | void set_show_glyphs( bool show ); 41 | 42 | /// turn on/off surface display 43 | void set_show_surface( bool show ); 44 | 45 | /// update the display using the current settings 46 | void display_samples(); 47 | 48 | void display_sample(size_t i); 49 | 50 | void display_shape( const vnl_vector &points); 51 | 52 | void set_selected_point_one( int id ); 53 | void set_selected_point_two( int id ); 54 | 55 | static const std::string MODE_ORIGINAL_C; 56 | static const std::string MODE_GROOMED_C; 57 | static const std::string MODE_RECONSTRUCTION_C; 58 | 59 | void setMean(const vnl_vector &mean); 60 | 61 | void reset_camera(); 62 | 63 | void update_lut(); 64 | 65 | vnl_vector getCurrentShape(); 66 | 67 | public Q_SLOTS: 68 | 69 | /// update viewer properties (e.g. glyph size, quality, etc) 70 | void update_viewer_properties(); 71 | 72 | private: 73 | QVector * getList( const vnl_vector &points); 74 | std::map > disp_handles_; 75 | Preferences &preferences_; 76 | 77 | 78 | void compute_measurements(); 79 | 80 | std::string display_mode_; 81 | bool center_; 82 | 83 | bool show_glyphs_; 84 | bool show_surface_; 85 | 86 | LightboxHandle lightbox_; 87 | ProjectHandle project_; 88 | 89 | vtkSmartPointer glyph_lut_; 90 | int selected_point_one_; 91 | int selected_point_two_; 92 | 93 | vnl_vector cached_mean_; 94 | vnl_vector currentShape_; 95 | }; 96 | 97 | #endif /* STUDIO_VISUALIZATION_VISUALIZER_H */ 98 | -------------------------------------------------------------------------------- /src/Application/Visualization/WheelEventForwarder.cc: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | 6 | WheelEventForwarder::WheelEventForwarder( QScrollBar* target ) : 7 | QObject(), 8 | target_( target ) 9 | {} 10 | 11 | WheelEventForwarder::~WheelEventForwarder() 12 | { 13 | this->target_ = NULL; 14 | } 15 | 16 | bool WheelEventForwarder::eventFilter( QObject* obj, QEvent* event ) 17 | { 18 | Q_UNUSED( obj ); 19 | 20 | static bool recursion_protection = false; 21 | 22 | if ( recursion_protection ) { return false; } 23 | 24 | if ( !this->target_ ) { return false; } 25 | 26 | if ( event->type() == QEvent::Wheel ) 27 | { 28 | recursion_protection = true; 29 | this->target_->event( event ); 30 | recursion_protection = false; 31 | } 32 | 33 | // do not filter the event 34 | return false; 35 | } 36 | -------------------------------------------------------------------------------- /src/Application/Visualization/WheelEventForwarder.h: -------------------------------------------------------------------------------- 1 | #ifndef WHEELEVENTFORWARDER_H 2 | #define WHEELEVENTFORWARDER_H 3 | 4 | #include 5 | 6 | class QScrollBar; 7 | 8 | class WheelEventForwarder : public QObject 9 | { 10 | Q_OBJECT 11 | public: 12 | explicit WheelEventForwarder( QScrollBar* target ); 13 | ~WheelEventForwarder(); 14 | 15 | bool eventFilter( QObject* obj, QEvent* event ); 16 | 17 | private: 18 | QScrollBar* target_; 19 | }; 20 | 21 | #endif // WHEELEVENTFORWARDER_H 22 | -------------------------------------------------------------------------------- /src/Application/Visualization/bargraph.h: -------------------------------------------------------------------------------- 1 | #ifndef BARGRAPH_H 2 | #define BARGRAPH_H 3 | 4 | #include 5 | #include 6 | #include 7 | 8 | class BarGraph : public QWidget 9 | { 10 | Q_OBJECT 11 | public: 12 | BarGraph(QWidget *parent = 0); 13 | ~BarGraph(); 14 | void setData(std::vector values); 15 | void paintBargraph(QPainter& painter); 16 | QBrush getBrush() const; 17 | void setBrush(const QBrush &value); 18 | void setLogScale(bool b); 19 | private: 20 | virtual void paintEvent(QPaintEvent *event); 21 | virtual void resizeEvent(QResizeEvent *event); 22 | void recalcBasicValues(); 23 | //members 24 | std::vector values; 25 | double max_val,min_val; 26 | int barwidth,margin; 27 | std::vector bars; 28 | bool use_log_; 29 | }; 30 | 31 | #endif // BARGRAPH_H 32 | -------------------------------------------------------------------------------- /src/Application/main.cc: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | 6 | #include 7 | 8 | int main(int argc, char** argv) { 9 | try { 10 | 11 | std::cerr << "ShapeWorksStudio initializing...\n"; 12 | 13 | QApplication app(argc, argv); 14 | 15 | QSharedPointer studio_app = 16 | QSharedPointer(new ShapeWorksStudioApp(argc, argv)); 17 | QResource::registerResource(RSCS_FILE); 18 | studio_app->setWindowIcon(QIcon(ICON_FILE)); 19 | studio_app->show(); 20 | 21 | // do this after "show" for mac initialization 22 | studio_app->initialize_vtk(); 23 | 24 | QStringList files; 25 | 26 | if (argc == 2) { 27 | studio_app->open_project(QString(argv[1])); 28 | } 29 | return app.exec(); 30 | } catch (itk::ExceptionObject & excep) { 31 | std::cerr << excep << std::endl; 32 | } catch (std::exception e) { 33 | std::cerr << "Exception caught!" << std::endl; 34 | std::cerr << e.what() << "\n"; 35 | } 36 | } 37 | -------------------------------------------------------------------------------- /src/CLT/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | 2 | cmake_policy(SET CMP0020 NEW) 3 | 4 | FILE(GLOB SRCS *.cpp) 5 | FILE(GLOB HDRS *.h) 6 | 7 | INCLUDE_DIRECTORIES( ${CMAKE_SOURCE_DIR}/TinyXML ) 8 | INCLUDE_DIRECTORIES( ${CMAKE_SOURCE_DIR}/Groom ) 9 | INCLUDE_DIRECTORIES( ${CMAKE_SOURCE_DIR}/Optimize ) 10 | include_directories(${CMAKE_SOURCE_DIR}/ParticleShapeworks/include) 11 | 12 | ADD_EXECUTABLE(ShapeworksCLT ${SRCS} ${HDRS}) 13 | 14 | TARGET_LINK_LIBRARIES(ShapeworksCLT 15 | ${ITK_LIBRARIES} 16 | ${VTK_LIBRARIES} 17 | TinyXML 18 | ShapeWorksGroom 19 | ShapeWorksOptimize) -------------------------------------------------------------------------------- /src/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | PROJECT( ShapeWorksStudio ) 2 | 3 | cmake_minimum_required(VERSION 2.8) 4 | 5 | set(CMAKE_BUILD_TYPE Debug) 6 | IF (WIN32 AND MSVC) 7 | ADD_DEFINITIONS(-D_SCL_SECURE_NO_WARNINGS) 8 | ADD_DEFINITIONS(-D_CRT_SECURE_NO_WARNINGS) 9 | ENDIF (WIN32 AND MSVC) 10 | 11 | #-------------------------------------------------------------------------------- 12 | # ITK, VTK 13 | #-------------------------------------------------------------------------------- 14 | FIND_PACKAGE(VTK COMPONENTS 15 | vtkCommonCore 16 | vtkInfovisCore 17 | vtkInteractionStyle 18 | vtkViewsQt 19 | vtkFiltersCore 20 | vtkGUISupportQt 21 | vtkRenderingQt 22 | vtkIOLegacy 23 | ) 24 | INCLUDE( ${VTK_USE_FILE} ) 25 | MESSAGE(STATUS "** VTK_DIR: ${VTK_DIR}") 26 | 27 | FIND_PACKAGE(ITK REQUIRED) 28 | IF (ITK_FOUND) 29 | INCLUDE (${ITK_USE_FILE}) 30 | ENDIF(ITK_FOUND) 31 | MESSAGE(STATUS "** ITK_DIR: ${ITK_DIR}") 32 | 33 | if (NOT WIN32) 34 | set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11 -fPIC") 35 | endif() 36 | 37 | #-------------------------------------------------------------------------------- 38 | ### Projects 39 | #-------------------------------------------------------------------------------- 40 | 41 | add_subdirectory(ParticleShapeworks) 42 | add_subdirectory(Groom) 43 | add_subdirectory(Optimize) 44 | add_subdirectory(Surfworks) 45 | add_subdirectory(TinyXML) 46 | add_subdirectory(Application) 47 | add_subdirectory(CLT) 48 | -------------------------------------------------------------------------------- /src/CTestConfig.cmake: -------------------------------------------------------------------------------- 1 | ## This file should be placed in the root directory of your project. 2 | ## Then modify the CMakeLists.txt file in the root directory of your 3 | ## project to incorporate the testing dashboard. 4 | ## # The following are required to uses Dart and the Cdash dashboard 5 | ## ENABLE_TESTING() 6 | ## INCLUDE(CTest) 7 | set(CTEST_PROJECT_NAME "ShapeWorksStudio") 8 | set(CTEST_NIGHTLY_START_TIME "01:00:00 UTC") 9 | 10 | set(CTEST_DROP_METHOD "http") 11 | set(CTEST_DROP_SITE "capulet.med.utah.edu") 12 | set(CTEST_DROP_LOCATION "/cdash/submit.php?project=ShapeWorksStudio") 13 | set(CTEST_DROP_SITE_CDASH TRUE) 14 | -------------------------------------------------------------------------------- /src/Groom/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | include_directories(${CMAKE_CURRENT_SOURCE_DIR}) 2 | include_directories(${CMAKE_SOURCE_DIR}/TinyXML) 3 | include_directories(${CMAKE_SOURCE_DIR}/Application) 4 | 5 | FILE(GLOB SRCS "*.txx" "*.h" "*.cxx") 6 | 7 | ADD_LIBRARY(ShapeWorksGroom ${SRCS}) 8 | -------------------------------------------------------------------------------- /src/Groom/ShapeWorksGroom.h: -------------------------------------------------------------------------------- 1 | #ifndef __SHAPEWORKSGROOM_H__ 2 | #define __SHAPEWORKSGROOM_H__ 3 | 4 | #include 5 | #include 6 | #include 7 | #include "itkConnectedThresholdImageFilter.h" 8 | #include "itkTranslationTransform.h" 9 | #include "itkImage.h" 10 | #include "itkImageFileReader.h" 11 | #include "itkImageFileWriter.h" 12 | #include 13 | #include 14 | //#include 15 | typedef float PixelType; 16 | typedef itk::Image< PixelType, 3 > ImageType; 17 | typedef itk::ImageFileReader< ImageType > ReaderType; 18 | typedef itk::ImageFileWriter< ImageType > WriterType; 19 | typedef itk::ConnectedThresholdImageFilter flood_fill_filter_type; 20 | typedef itk::TranslationTransform::ParametersType transform_type; 21 | 22 | class ShapeWorksGroom { 23 | public: 24 | ShapeWorksGroom( 25 | std::vector inputs = std::vector(), 26 | double background = 0., double foreground = 0., 27 | double sigma = 2.0, 28 | size_t padding = 0, size_t iterations = 100, 29 | bool verbose = false); 30 | virtual void run(); 31 | void queueTool(std::string tool); 32 | std::vector getImages(); 33 | double foreground(); 34 | std::map tools(); 35 | protected: 36 | void isolate(int which = -1); 37 | void hole_fill(int which = -1); 38 | void center(int which = -1); 39 | void antialias(int which = -1); 40 | void fastmarching(int which = -1); 41 | void blur(int which = -1); 42 | void auto_pad(int which = -1); 43 | //member variables 44 | std::vector images_; 45 | bool verbose_; 46 | double background_, foreground_, blurSigma_; 47 | flood_fill_filter_type::IndexType seed_; 48 | transform_type transform_; 49 | size_t padding_, iterations_; 50 | std::map runTools_; 51 | ImageType::IndexType upper_; 52 | ImageType::IndexType lower_; 53 | bool paddingInit_; 54 | }; 55 | 56 | #endif 57 | 58 | -------------------------------------------------------------------------------- /src/Groom/bounding_box.h: -------------------------------------------------------------------------------- 1 | /*========================================================================= 2 | Program: ShapeWorks: Particle-based Shape Correspondence & Visualization 3 | Module: $RCSfile: bounding_box.h,v $ 4 | Date: $Date: 2011/03/24 01:17:36 $ 5 | Version: $Revision: 1.2 $ 6 | Author: $Author: wmartin $ 7 | 8 | Copyright (c) 2009 Scientific Computing and Imaging Institute. 9 | See ShapeWorksLicense.txt for details. 10 | 11 | This software is distributed WITHOUT ANY WARRANTY; without even 12 | the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR 13 | PURPOSE. See the above copyright notices for more information. 14 | =========================================================================*/ 15 | #ifndef __st_bounding_box_h 16 | #define __st_bounding_box_h 17 | 18 | #include "itkImage.h" 19 | #include "tinyxml.h" 20 | #include 21 | #include 22 | #include "tool.h" 23 | #include "itkImageRegion.h" 24 | 25 | namespace shapetools 26 | { 27 | /** 28 | * \class bounding_box 29 | * 30 | * Computes the smallest bounding box around the foreground (in pixel coordinates). 31 | */ 32 | template 33 | class bounding_box : public tool 34 | { 35 | public: 36 | typedef T pixel_type; 37 | typedef itk::Image image_type; 38 | typedef typename image_type::RegionType region_type; 39 | 40 | bounding_box(const char *fname); 41 | bounding_box() {} 42 | virtual ~bounding_box() {} 43 | 44 | virtual void operator()(typename image_type::Pointer); 45 | 46 | /** */ 47 | const pixel_type background() const 48 | { return m_background; } 49 | pixel_type &background() 50 | { return m_background; } 51 | 52 | /** */ 53 | const region_type& region() const 54 | { return m_region; } 55 | region_type ®ion() 56 | { return m_region; } 57 | 58 | private: 59 | pixel_type m_background; 60 | 61 | region_type m_region; 62 | }; 63 | 64 | 65 | } // end namespace 66 | #endif 67 | 68 | #ifndef ST_MANUAL_INSTANTIATION 69 | #include "bounding_box.txx" 70 | #endif 71 | -------------------------------------------------------------------------------- /src/Groom/tool.h: -------------------------------------------------------------------------------- 1 | /*========================================================================= 2 | Program: ShapeWorks: Particle-based Shape Correspondence & Visualization 3 | Module: $RCSfile: tool.h,v $ 4 | Date: $Date: 2011/03/24 01:17:36 $ 5 | Version: $Revision: 1.2 $ 6 | Author: $Author: wmartin $ 7 | 8 | Copyright (c) 2009 Scientific Computing and Imaging Institute. 9 | See ShapeWorksLicense.txt for details. 10 | 11 | This software is distributed WITHOUT ANY WARRANTY; without even 12 | the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR 13 | PURPOSE. See the above copyright notices for more information. 14 | =========================================================================*/ 15 | #ifndef __st__tool_h 16 | #define __st__tool_h 17 | 18 | #include "itkImage.h" 19 | 20 | namespace shapetools 21 | { 22 | /** 23 | * \class tool 24 | * 25 | * A generic interface for a shape tool. 26 | * 27 | */ 28 | template 29 | class tool 30 | { 31 | public: 32 | typedef T PixelType; 33 | typedef itk::Image ImageType; 34 | 35 | tool() {} 36 | virtual ~tool() {} 37 | 38 | virtual void operator()(typename ImageType::Pointer) = 0; 39 | 40 | private: 41 | tool &operator=(const tool &); // purposely unimplemented 42 | tool(const tool &); // purposely unimplemented 43 | }; 44 | 45 | 46 | }// end namespace 47 | 48 | #endif 49 | -------------------------------------------------------------------------------- /src/Optimize/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | include_directories(${CMAKE_CURRENT_SOURCE_DIR}) 2 | include_directories(${CMAKE_SOURCE_DIR}/TinyXML) 3 | include_directories(${CMAKE_SOURCE_DIR}/Application) 4 | include_directories(${CMAKE_SOURCE_DIR}/Groom) 5 | include_directories(${CMAKE_SOURCE_DIR}/ParticleShapeworks/include) 6 | 7 | FILE(GLOB SRCS "*.h" "*.cxx") 8 | 9 | ADD_LIBRARY(ShapeWorksOptimize ${SRCS}) 10 | TARGET_LINK_LIBRARIES(ShapeWorksOptimize ShapeWorksGroom 11 | itkParticleShapeModeling ${ITK_LIBRARIES}) 12 | -------------------------------------------------------------------------------- /src/Optimize/ShapeWorksOptimize.h: -------------------------------------------------------------------------------- 1 | #ifndef __SHAPEWORKSOPTIMIZE_H__ 2 | #define __SHAPEWORKSOPTIMIZE_H__ 3 | 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include "itkImage.h" 10 | #include "itkPSMProcrustesRegistration.h" 11 | #include "itkImageFileReader.h" 12 | #include "itkPSMEntropyModelFilter.h" 13 | #include "itkPSMProject.h" 14 | #include "itkPSMProjectReader.h" 15 | #include "itkPSMParticleSystem.h" 16 | #include "itkCommand.h" 17 | 18 | class ShapeWorksOptimize { 19 | public: 20 | ShapeWorksOptimize( 21 | std::vector inputs = 22 | std::vector(), 23 | std::vector, 3 > > cutPlanes = 24 | std::vector, 3 > >(), 25 | size_t numScales = 1, 26 | std::vector start_reg = std::vector(), 27 | std::vector end_reg = std::vector(), 28 | std::vector iters = std::vector(), 29 | std::vector decay_span = std::vector(), 30 | std::vector procrustes_interval = std::vector(), 31 | double weighting = 1., 32 | bool verbose = false); 33 | void run(); 34 | std::vector getImages(); 35 | std::vector > > localPoints(); 36 | std::vector > > globalPoints(); 37 | protected: 38 | virtual void iterateCallback( 39 | itk::Object *caller, const itk::EventObject &); 40 | protected: 41 | std::vector images_; 42 | bool verbose_; 43 | size_t numScales_; 44 | double weighting_; 45 | std::vector maxIter_; 46 | std::vector decaySpan_, 47 | regularizationInitial_, regularizationFinal_; 48 | itk::PSMEntropyModelFilter::Pointer psmFilter_; 49 | std::vector > > localPoints_, globalPoints_; 50 | itk::MemberCommand::Pointer iterateCmd_; 51 | itk::PSMProcrustesRegistration<3>::Pointer procrustesRegistration_; 52 | size_t reportInterval_, procrustesCounter_, totalIters_, iterCount_; 53 | std::vector procrustesInterval_; 54 | std::vector, 3 > > cutPlanes_; 55 | }; 56 | 57 | #endif 58 | 59 | -------------------------------------------------------------------------------- /src/ParticleShapeworks/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | project(ITKParticleShapeModeling) 2 | cmake_minimum_required(VERSION 2.6) 3 | 4 | # Compile with c++11 functionality. 5 | if(UNIX) 6 | SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -std=gnu++11") # gcc >= 4.7 7 | endif(UNIX) 8 | 9 | file( 10 | GLOB 11 | source_files 12 | src/*.txt 13 | src/*.cxx 14 | include/*.txt 15 | include/*.h 16 | include/*.hxx 17 | ) 18 | OPTION(PSM_BUILD_EXAMPLES "Build PSM Examples" OFF) 19 | IF (PSM_BUILD_EXAMPLES) 20 | add_subdirectory(Examples) 21 | ENDIF (PSM_BUILD_EXAMPLES) 22 | OPTION(PSM_BUILD_TESTS "Build PSM Tests" OFF) 23 | IF (PSM_BUILD_TESTS) 24 | add_subdirectory(test) 25 | ENDIF (PSM_BUILD_TESTS) 26 | 27 | INCLUDE_DIRECTORIES(include src) 28 | 29 | #create a library to link to 30 | ADD_LIBRARY(itkParticleShapeModeling ${source_files}) 31 | TARGET_LINK_LIBRARIES(itkParticleShapeModeling ${ITK_LIBRARIES}) 32 | -------------------------------------------------------------------------------- /src/ParticleShapeworks/Examples/.DS_Store: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SCIInstitute/ShapeWorksStudio/795388bdd6b167a61114b839208af185421c46df/src/ParticleShapeworks/Examples/.DS_Store -------------------------------------------------------------------------------- /src/ParticleShapeworks/Examples/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | ADD_EXECUTABLE(psmCommandLineTool psmCommandLineTool.cxx) 2 | TARGET_LINK_LIBRARIES(psmCommandLineTool ITKIOMeta ITKIOGDCM ITKIONRRD ITKParticleShapeModeling ITKIOXML ${ITKIOImageBase_LIBRARIES} ${ITKstatistics_LIBRARIES} ${ITKTransform_LIBRARIES}) 3 | -------------------------------------------------------------------------------- /src/ParticleShapeworks/Examples/psmPreprocessor.cxx: -------------------------------------------------------------------------------- 1 | /*========================================================================= 2 | * 3 | * Copyright Insight Software Consortium 4 | * 5 | * Licensed under the Apache License, Version 2.0 (the "License"); 6 | * you may not use this file except in compliance with the License. 7 | * You may obtain a copy of the License at 8 | * 9 | * http://www.apache.org/licenses/LICENSE-2.0.txt 10 | * 11 | * Unless required by applicable law or agreed to in writing, software 12 | * distributed under the License is distributed on an "AS IS" BASIS, 13 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 | * See the License for the specific language governing permissions and 15 | * limitations under the License. 16 | * 17 | *=========================================================================*/ 18 | #include 19 | #include 20 | #include 21 | //#include 22 | #include 23 | 24 | int main_ (int argc, char *argv[]) 25 | { 26 | if (argc < 5) 27 | { 28 | std::cout << "Usage:" << argv[0] 29 | << "output_prefix smoothing_sigma isosurface_value input_file_1 input_file_2 ..." << std::endl; 30 | return 1; 31 | } 32 | 33 | double sigma = 0.0; 34 | double isosurface_value = 0.5; 35 | if (argc > 3) 36 | { sigma = atof(argv[3]); } 37 | if (argc >4) 38 | { isosurface_value = atof(argv[4]); } 39 | 40 | 41 | typedef itk::Image image_type; 42 | 43 | try { 44 | 45 | 46 | // First read all of the files one by one and compute the bounding box. 47 | 48 | 49 | 50 | std::cout << "Reading " << argv[4] << std::endl; 51 | itk::ImageFileReader::Pointer reader 52 | = itk::ImageFileReader::New(); 53 | reader->SetFileName(argv[4]); 54 | reader->Update(); 55 | 56 | itk::ImageFileWriter::Pointer fwriter 57 | = itk::ImageFileWriter::New(); 58 | // fwriter->SetInput(filt->GetOutput()); 59 | // fwriter->SetFileName("tmp.nrrd"); 60 | // fwriter->Update(); 61 | 62 | } 63 | catch (itk::ExceptionObject &e) 64 | { 65 | std::cerr << e << std::endl; 66 | return 1; 67 | } 68 | catch( ...) 69 | { 70 | std::cerr << "Unknown error" << std::endl; 71 | return 2; 72 | } 73 | 74 | return 0; 75 | } 76 | 77 | -------------------------------------------------------------------------------- /src/ParticleShapeworks/Notes.txt: -------------------------------------------------------------------------------- 1 | *****To fix linker errors:***** 2 | Try running ccmake and then make. If that doesn't work, delete the build directory for PSM from /ITK-4.4.1-build/Modules/External/ and rerun ccmake, and then make. For reader image type errors, add include_directories(${ITK_USE_FILE}) at the beginning of cmakelists. 3 | 4 | Error for undefined symbol for PSMCommandLineClass::New() in PSMCommandLineTool fixed by including the .cxx file in PSMCommandLineTool. 5 | 6 | XML Validation using Schema: 7 | The optimization tag has to be ended with the closing tag on the same line as the last parameter. For some reason, an error is thrown if the closing tag is on a different line. The parameters can be on different lines. 8 | 9 | Prasanna's code- 10 | 11 | itkParticleShapeMixedEffectsMatrixAttribute -> itkPSMMixedEffectsShapeMatrixAttribute 12 | 13 | itkMaximumEntropyCorrespondenceSampler -> no need to move over. 14 | 15 | ShapeWorksRun -> 16 | 17 | Input data: 18 | For the months example, the output of Intercept, intercept +0.5*slope, and so on wont make sense, you would need to look at intercept + number of months * slope. 19 | 20 | For years as timepoints, it'll be intercept + number of years * slope. We can use the ComputeMean function in the PSMMixedEffectsShapeMatrixAttribute.h class. 21 | 22 | m_InterceptRand and m_SlopeRand: 23 | so those are perturbations needed to get to each of the individuals 24 | so if there are 10 individuals 25 | there will be 10 m_interceptRand and m_Sloperand 26 | so the group parameters plus the first of the rand parameters give us the estimated intercept and slope parameters for the 1st individual 27 | when i say plus I mean 28 | m_intercept + m_interceptRand1 + k * (m_slope + m_slopeRand) -------------------------------------------------------------------------------- /src/ParticleShapeworks/README.md: -------------------------------------------------------------------------------- 1 | ITKParticleShapeModeling 2 | ======================== 3 | 4 | An external module for ITKv4+ that implements filters for computing particle-based statistical models of shapes. Please see the official project html pages, which include full Doxygen documentation, here: 5 | 6 | http://joshcates.github.com/ITKParticleShapeModeling/ 7 | 8 | -------------------------------------------------------------------------------- /src/ParticleShapeworks/include/.DS_Store: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SCIInstitute/ShapeWorksStudio/795388bdd6b167a61114b839208af185421c46df/src/ParticleShapeworks/include/.DS_Store -------------------------------------------------------------------------------- /src/ParticleShapeworks/include/itkPSMDomain.hxx: -------------------------------------------------------------------------------- 1 | /*========================================================================= 2 | * 3 | * Copyright Insight Software Consortium 4 | * 5 | * Licensed under the Apache License, Version 2.0 (the "License"); 6 | * you may not use this file except in compliance with the License. 7 | * You may obtain a copy of the License at 8 | * 9 | * http://www.apache.org/licenses/LICENSE-2.0.txt 10 | * 11 | * Unless required by applicable law or agreed to in writing, software 12 | * distributed under the License is distributed on an "AS IS" BASIS, 13 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 | * See the License for the specific language governing permissions and 15 | * limitations under the License. 16 | * 17 | *=========================================================================*/ 18 | #ifndef __itkPSMDomain_hxx 19 | #define __itkPSMDomain_hxx 20 | #include "itkPSMDomain.h" 21 | 22 | namespace itk 23 | { 24 | 25 | template 26 | PSMDomain::PSMDomain() : m_ConstraintsEnabled(true) 27 | { 28 | } 29 | 30 | template 31 | void PSMDomain::PrintSelf(std::ostream& os, Indent indent) const 32 | { 33 | Superclass::PrintSelf(os, indent); 34 | } 35 | 36 | 37 | } // end namespace 38 | 39 | #endif //__itkPSMDomain_hxx 40 | -------------------------------------------------------------------------------- /src/ParticleShapeworks/include/itkPSMParticleEntropyFunction.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SCIInstitute/ShapeWorksStudio/795388bdd6b167a61114b839208af185421c46df/src/ParticleShapeworks/include/itkPSMParticleEntropyFunction.h -------------------------------------------------------------------------------- /src/ParticleShapeworks/include/itkPSMPointIndexPair.h: -------------------------------------------------------------------------------- 1 | /*========================================================================= 2 | * 3 | * Copyright Insight Software Consortium 4 | * 5 | * Licensed under the Apache License, Version 2.0 (the "License"); 6 | * you may not use this file except in compliance with the License. 7 | * You may obtain a copy of the License at 8 | * 9 | * http://www.apache.org/licenses/LICENSE-2.0.txt 10 | * 11 | * Unless required by applicable law or agreed to in writing, software 12 | * distributed under the License is distributed on an "AS IS" BASIS, 13 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 | * See the License for the specific language governing permissions and 15 | * limitations under the License. 16 | * 17 | *=========================================================================*/ 18 | #ifndef __itkPSMPointIndexPair_h 19 | #define __itkPSMPointIndexPair_h 20 | 21 | #include "itkPoint.h" 22 | namespace itk { 23 | /** 24 | * \class PSMPointIndexPair 25 | * \brief 26 | * Struct containing a Point and an index value associated with a 27 | * point. This object is used mainly by PSMNeighborhood classes and 28 | * the PowerOfTwoPointTree. 29 | * 30 | * \ingroup PSM 31 | * 32 | */ 33 | template 34 | struct PSMPointIndexPair 35 | { 36 | typedef itk::Point PointType; 37 | PSMPointIndexPair() {} 38 | PSMPointIndexPair(const PointType &p, unsigned int i=0) 39 | { 40 | Point = p; 41 | Index = i; 42 | } 43 | PSMPointIndexPair(const PSMPointIndexPair &o) 44 | { this->operator=(o); } 45 | const PSMPointIndexPair &operator=(const PSMPointIndexPair &o) 46 | { 47 | Point = o.Point; 48 | Index = o.Index; 49 | return *this; 50 | } 51 | PointType Point; 52 | unsigned int Index; 53 | }; 54 | 55 | } 56 | #endif 57 | 58 | -------------------------------------------------------------------------------- /src/ParticleShapeworks/include/itkPSMProjectWriter.h: -------------------------------------------------------------------------------- 1 | /*========================================================================= 2 | * 3 | * Copyright Insight Software Consortium 4 | * 5 | * Licensed under the Apache License, Version 2.0 (the "License"); 6 | * you may not use this file except in compliance with the License. 7 | * You may obtain a copy of the License at 8 | * 9 | * http://www.apache.org/licenses/LICENSE-2.0.txt 10 | * 11 | * Unless required by applicable law or agreed to in writing, software 12 | * distributed under the License is distributed on an "AS IS" BASIS, 13 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 | * See the License for the specific language governing permissions and 15 | * limitations under the License. 16 | * 17 | *=========================================================================*/ 18 | 19 | #ifndef __itkPSMProjectWriter_h 20 | #define __itkPSMProjectWriter_h 21 | 22 | #include "itkPSMProject.h" 23 | 24 | namespace itk 25 | { 26 | 27 | /** 28 | * \class PSMProjectWriter 29 | * 30 | * \brief This class is a writer for PSMProjects. 31 | * 32 | * The following code illustrates how to use this class to write a PSMProject to a file. 33 | * 34 | */ 35 | class ITK_EXPORT PSMProjectWriter : public Object 36 | { 37 | public: 38 | /** Standard class typedefs. */ 39 | typedef PSMProjectWriter Self; 40 | typedef Object Superclass; 41 | typedef SmartPointer< Self > Pointer; 42 | typedef SmartPointer< const Self > ConstPointer; 43 | 44 | /** Method for creation through the object factory. */ 45 | itkNewMacro(Self); 46 | 47 | /** Run-time type information (and related methods). */ 48 | itkTypeMacro(PSMProjectWriter, Object); 49 | 50 | /** Set the input XML filename. */ 51 | itkSetStringMacro(FileName); 52 | 53 | /** Get the input XML filename. */ 54 | itkGetStringMacro(FileName); 55 | 56 | /** Get the project data structure generated after calling 57 | Update(). */ 58 | itkGetObjectMacro( Input, PSMProject); 59 | itkSetObjectMacro( Input, PSMProject); 60 | itkGetConstObjectMacro( Input, PSMProject); 61 | 62 | /** Execute the reader. */ 63 | virtual void Update(); 64 | 65 | protected: 66 | PSMProjectWriter(); 67 | 68 | private: 69 | PSMProjectWriter(const Self &); //purposely not implemented 70 | void operator=(const Self &); //purposely not implemented 71 | 72 | /** The PSMProject object that will be created by the reader. */ 73 | PSMProject::Pointer m_Input; 74 | 75 | /** The filename of the project to be written. */ 76 | std::string m_FileName; 77 | }; 78 | 79 | } // namespace itk 80 | 81 | #endif 82 | -------------------------------------------------------------------------------- /src/ParticleShapeworks/src/.DS_Store: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SCIInstitute/ShapeWorksStudio/795388bdd6b167a61114b839208af185421c46df/src/ParticleShapeworks/src/.DS_Store -------------------------------------------------------------------------------- /src/ParticleShapeworks/src/itkIncludeRequiredIOFactories.h: -------------------------------------------------------------------------------- 1 | /*========================================================================= 2 | 3 | Program: Insight Segmentation & Registration Toolkit 4 | Module: itkIncludeRequiredIOFactories.h 5 | Language: C++ 6 | Date: $Date$ 7 | Version: $Revision$ 8 | 9 | Copyright (c) Insight Software Consortium. All rights reserved. 10 | See ITKCopyright.txt or http://www.itk.org/HTML/Copyright.htm for details. 11 | 12 | This software is distributed WITHOUT ANY WARRANTY; without even 13 | the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR 14 | PURPOSE. See the above copyright notices for more information. 15 | 16 | =========================================================================*/ 17 | 18 | #ifndef __itkTestDriverIncludeRequiredIOFactories_h 19 | #define __itkTestDriverIncludeRequiredIOFactories_h 20 | #include "itkGDCMImageIOFactory.h" 21 | #include "itkMetaImageIOFactory.h" 22 | #include "itkObjectFactoryBase.h" 23 | #include "itkNrrdImageIOFactory.h" 24 | 25 | /** Fixed ITK runtime error where image format is not recognized. */ 26 | void RegisterRequiredFactories(){ 27 | itk::ObjectFactoryBase::RegisterFactory( itk::MetaImageIOFactory::New() ); 28 | itk::ObjectFactoryBase::RegisterFactory( itk::GDCMImageIOFactory::New() ); 29 | itk::ObjectFactoryBase::RegisterFactory( itk::NrrdImageIOFactory::New() ); 30 | } 31 | 32 | #endif 33 | -------------------------------------------------------------------------------- /src/ParticleShapeworks/src/itkPSMParticleSystem.cxx: -------------------------------------------------------------------------------- 1 | /*========================================================================= 2 | * 3 | * Copyright Insight Software Consortium 4 | * 5 | * Licensed under the Apache License, Version 2.0 (the "License"); 6 | * you may not use this file except in compliance with the License. 7 | * You may obtain a copy of the License at 8 | * 9 | * http://www.apache.org/licenses/LICENSE-2.0.txt 10 | * 11 | * Unless required by applicable law or agreed to in writing, software 12 | * distributed under the License is distributed on an "AS IS" BASIS, 13 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 | * See the License for the specific language governing permissions and 15 | * limitations under the License. 16 | * 17 | *=========================================================================*/ 18 | #include "itkPSMParticleSystem.h" 19 | 20 | namespace itk { 21 | 22 | /** For efficiency, we specialize for 3D and 2D */ 23 | template<> 24 | PSMParticleSystem<3>::PointType 25 | PSMParticleSystem<3> 26 | ::TransformPoint(const PointType &p, const TransformType &T) const 27 | { 28 | PointType ans; 29 | 30 | ans[0] = T[0][0] * p[0] + T[0][1] * p[1] + T[0][2] * p[2] + T[0][3]; 31 | ans[1] = T[1][0] * p[0] + T[1][1] * p[1] + T[1][2] * p[2] + T[1][3]; 32 | ans[2] = T[2][0] * p[0] + T[2][1] * p[1] + T[2][2] * p[2] + T[2][3]; 33 | 34 | return ans; 35 | } 36 | 37 | /** For efficiency, we specialize for 3D and 2D */ 38 | template<> 39 | PSMParticleSystem<2>::PointType 40 | PSMParticleSystem<2> 41 | ::TransformPoint(const PointType &p, const TransformType &T) const 42 | { 43 | PointType ans; 44 | 45 | ans[0] = T[0][0] * p[0] + T[0][1] * p[1] + T[0][2]; 46 | ans[1] = T[1][0] * p[0] + T[1][1] * p[1] + T[1][2]; 47 | 48 | return ans; 49 | } 50 | 51 | 52 | /** For efficiency, we specialize for 3D and 2D */ 53 | template<> 54 | PSMParticleSystem<3>::VectorType 55 | PSMParticleSystem<3> 56 | ::TransformVector(const VectorType &p, const TransformType &T) const 57 | { 58 | VectorType ans; 59 | 60 | ans[0] = T[0][0] * p[0] + T[0][1] * p[1] + T[0][2] * p[2]; 61 | ans[1] = T[1][0] * p[0] + T[1][1] * p[1] + T[1][2] * p[2]; 62 | ans[2] = T[2][0] * p[0] + T[2][1] * p[1] + T[2][2] * p[2]; 63 | 64 | return ans; 65 | } 66 | 67 | /** For efficiency, we specialize for 3D and 2D */ 68 | template<> 69 | PSMParticleSystem<2>::VectorType 70 | PSMParticleSystem<2> 71 | ::TransformVector(const VectorType &p, const TransformType &T) const 72 | { 73 | VectorType ans; 74 | 75 | ans[0] = T[0][0] * p[0] + T[0][1] * p[1]; 76 | ans[1] = T[1][0] * p[0] + T[1][1] * p[1]; 77 | 78 | return ans; 79 | } 80 | 81 | } // end namespace 82 | -------------------------------------------------------------------------------- /src/ParticleShapeworks/src/itkPSMProjectReader.cxx: -------------------------------------------------------------------------------- 1 | /*========================================================================= 2 | * 3 | * Copyright Insight Software Consortium 4 | * 5 | * Licensed under the Apache License, Version 2.0 (the "License"); 6 | * you may not use this file except in compliance with the License. 7 | * You may obtain a copy of the License at 8 | * 9 | * http://www.apache.org/licenses/LICENSE-2.0.txt 10 | * 11 | * Unless required by applicable law or agreed to in writing, software 12 | * distributed under the License is distributed on an "AS IS" BASIS, 13 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 | * See the License for the specific language governing permissions and 15 | * limitations under the License. 16 | * 17 | *=========================================================================*/ 18 | 19 | #include "itkPSMProjectReader.h" 20 | 21 | namespace itk 22 | { 23 | 24 | PSMProjectReader::PSMProjectReader() 25 | { 26 | } 27 | 28 | void PSMProjectReader::Update() 29 | { 30 | // Have the parent class parse the XML file 31 | Superclass::Update(); 32 | 33 | DOMNodeType* dom = this->GetDOMNode(); 34 | 35 | if (dom == 0) 36 | { 37 | itkExceptionMacro( "Failed to parse the XML file." ); 38 | } 39 | else 40 | { 41 | // Allocate a new PSM Project. 42 | m_Output = PSMProject::New(); 43 | m_Output->SetDOMNode(dom); 44 | } 45 | } 46 | 47 | } // end namespace itk 48 | -------------------------------------------------------------------------------- /src/ParticleShapeworks/src/itkPSMProjectWriter.cxx: -------------------------------------------------------------------------------- 1 | /*========================================================================= 2 | * 3 | * Copyright Insight Software Consortium 4 | * 5 | * Licensed under the Apache License, Version 2.0 (the "License"); 6 | * you may not use this file except in compliance with the License. 7 | * You may obtain a copy of the License at 8 | * 9 | * http://www.apache.org/licenses/LICENSE-2.0.txt 10 | * 11 | * Unless required by applicable law or agreed to in writing, software 12 | * distributed under the License is distributed on an "AS IS" BASIS, 13 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 | * See the License for the specific language governing permissions and 15 | * limitations under the License. 16 | * 17 | *=========================================================================*/ 18 | 19 | #include "itkPSMProjectWriter.h" 20 | #include 21 | 22 | namespace itk 23 | { 24 | 25 | PSMProjectWriter::PSMProjectWriter() 26 | { 27 | 28 | } 29 | 30 | void PSMProjectWriter::Update() 31 | { 32 | std::ofstream out; 33 | out.open(this->GetFileName()); 34 | if (!out) 35 | { 36 | itkExceptionMacro( "Could not open the file " + m_FileName + " for output."); 37 | } 38 | else 39 | { 40 | m_Input->Stream(out); 41 | out.close(); 42 | } 43 | } 44 | 45 | } // end namespace itk 46 | -------------------------------------------------------------------------------- /src/ParticleShapeworks/test/.DS_Store: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SCIInstitute/ShapeWorksStudio/795388bdd6b167a61114b839208af185421c46df/src/ParticleShapeworks/test/.DS_Store -------------------------------------------------------------------------------- /src/Surfworks/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | if(POLICY CMP0020) 2 | cmake_policy(SET CMP0020 NEW) 3 | endif() 4 | 5 | include_directories(${CMAKE_CURRENT_SOURCE_DIR}) 6 | include_directories(${CMAKE_SOURCE_DIR}/Groom) 7 | 8 | FILE(GLOB SRCS "*.h" "*.cc" ".hxx" ITKVTK/*.hxx PreViewMeshQC/*.cpp) 9 | 10 | FILE(GLOB HDRS */*.h) 11 | 12 | ADD_LIBRARY(Surfworks ${SRCS} ${HDRS}) 13 | TARGET_LINK_LIBRARIES(Surfworks ShapeWorksGroom ${ITK_LIBRARIES} ${VTK_LIBRARIES}) 14 | -------------------------------------------------------------------------------- /src/Surfworks/Eigen/Array: -------------------------------------------------------------------------------- 1 | #ifndef EIGEN_ARRAY_MODULE_H 2 | #define EIGEN_ARRAY_MODULE_H 3 | 4 | // include Core first to handle Eigen2 support macros 5 | #include "Core" 6 | 7 | #ifndef EIGEN2_SUPPORT 8 | #error The Eigen/Array header does no longer exist in Eigen3. All that functionality has moved to Eigen/Core. 9 | #endif 10 | 11 | #endif // EIGEN_ARRAY_MODULE_H 12 | -------------------------------------------------------------------------------- /src/Surfworks/Eigen/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | include(RegexUtils) 2 | test_escape_string_as_regex() 3 | 4 | file(GLOB Eigen_directory_files "*") 5 | 6 | escape_string_as_regex(ESCAPED_CMAKE_CURRENT_SOURCE_DIR "${CMAKE_CURRENT_SOURCE_DIR}") 7 | 8 | foreach(f ${Eigen_directory_files}) 9 | if(NOT f MATCHES "\\.txt" AND NOT f MATCHES "${ESCAPED_CMAKE_CURRENT_SOURCE_DIR}/[.].+" AND NOT f MATCHES "${ESCAPED_CMAKE_CURRENT_SOURCE_DIR}/src") 10 | list(APPEND Eigen_directory_files_to_install ${f}) 11 | endif() 12 | endforeach(f ${Eigen_directory_files}) 13 | 14 | install(FILES 15 | ${Eigen_directory_files_to_install} 16 | DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen COMPONENT Devel 17 | ) 18 | 19 | add_subdirectory(src) 20 | -------------------------------------------------------------------------------- /src/Surfworks/Eigen/Cholesky: -------------------------------------------------------------------------------- 1 | #ifndef EIGEN_CHOLESKY_MODULE_H 2 | #define EIGEN_CHOLESKY_MODULE_H 3 | 4 | #include "Core" 5 | 6 | #include "src/Core/util/DisableStupidWarnings.h" 7 | 8 | /** \defgroup Cholesky_Module Cholesky module 9 | * 10 | * 11 | * 12 | * This module provides two variants of the Cholesky decomposition for selfadjoint (hermitian) matrices. 13 | * Those decompositions are accessible via the following MatrixBase methods: 14 | * - MatrixBase::llt(), 15 | * - MatrixBase::ldlt() 16 | * 17 | * \code 18 | * #include 19 | * \endcode 20 | */ 21 | 22 | #include "src/misc/Solve.h" 23 | #include "src/Cholesky/LLT.h" 24 | #include "src/Cholesky/LDLT.h" 25 | #ifdef EIGEN_USE_LAPACKE 26 | #include "src/Cholesky/LLT_MKL.h" 27 | #endif 28 | 29 | #include "src/Core/util/ReenableStupidWarnings.h" 30 | 31 | #endif // EIGEN_CHOLESKY_MODULE_H 32 | /* vim: set filetype=cpp et sw=2 ts=2 ai: */ 33 | -------------------------------------------------------------------------------- /src/Surfworks/Eigen/CholmodSupport: -------------------------------------------------------------------------------- 1 | #ifndef EIGEN_CHOLMODSUPPORT_MODULE_H 2 | #define EIGEN_CHOLMODSUPPORT_MODULE_H 3 | 4 | #include "SparseCore" 5 | 6 | #include "src/Core/util/DisableStupidWarnings.h" 7 | 8 | extern "C" { 9 | #include 10 | } 11 | 12 | /** \ingroup Support_modules 13 | * \defgroup CholmodSupport_Module CholmodSupport module 14 | * 15 | * This module provides an interface to the Cholmod library which is part of the suitesparse package. 16 | * It provides the two following main factorization classes: 17 | * - class CholmodSupernodalLLT: a supernodal LLT Cholesky factorization. 18 | * - class CholmodDecomposiiton: a general L(D)LT Cholesky factorization with automatic or explicit runtime selection of the underlying factorization method (supernodal or simplicial). 19 | * 20 | * For the sake of completeness, this module also propose the two following classes: 21 | * - class CholmodSimplicialLLT 22 | * - class CholmodSimplicialLDLT 23 | * Note that these classes does not bring any particular advantage compared to the built-in 24 | * SimplicialLLT and SimplicialLDLT factorization classes. 25 | * 26 | * \code 27 | * #include 28 | * \endcode 29 | * 30 | * In order to use this module, the cholmod headers must be accessible from the include paths, and your binary must be linked to the cholmod library and its dependencies. 31 | * The dependencies depend on how cholmod has been compiled. 32 | * For a cmake based project, you can use our FindCholmod.cmake module to help you in this task. 33 | * 34 | */ 35 | 36 | #include "src/misc/Solve.h" 37 | #include "src/misc/SparseSolve.h" 38 | 39 | #include "src/CholmodSupport/CholmodSupport.h" 40 | 41 | 42 | #include "src/Core/util/ReenableStupidWarnings.h" 43 | 44 | #endif // EIGEN_CHOLMODSUPPORT_MODULE_H 45 | 46 | -------------------------------------------------------------------------------- /src/Surfworks/Eigen/Dense: -------------------------------------------------------------------------------- 1 | #include "Core" 2 | #include "LU" 3 | #include "Cholesky" 4 | #include "QR" 5 | #include "SVD" 6 | #include "Geometry" 7 | #include "Eigenvalues" 8 | -------------------------------------------------------------------------------- /src/Surfworks/Eigen/Eigen: -------------------------------------------------------------------------------- 1 | #include "Dense" 2 | //#include "Sparse" 3 | -------------------------------------------------------------------------------- /src/Surfworks/Eigen/Eigenvalues: -------------------------------------------------------------------------------- 1 | #ifndef EIGEN_EIGENVALUES_MODULE_H 2 | #define EIGEN_EIGENVALUES_MODULE_H 3 | 4 | #include "Core" 5 | 6 | #include "src/Core/util/DisableStupidWarnings.h" 7 | 8 | #include "Cholesky" 9 | #include "Jacobi" 10 | #include "Householder" 11 | #include "LU" 12 | #include "Geometry" 13 | 14 | /** \defgroup Eigenvalues_Module Eigenvalues module 15 | * 16 | * 17 | * 18 | * This module mainly provides various eigenvalue solvers. 19 | * This module also provides some MatrixBase methods, including: 20 | * - MatrixBase::eigenvalues(), 21 | * - MatrixBase::operatorNorm() 22 | * 23 | * \code 24 | * #include 25 | * \endcode 26 | */ 27 | 28 | #include "src/Eigenvalues/Tridiagonalization.h" 29 | #include "src/Eigenvalues/RealSchur.h" 30 | #include "src/Eigenvalues/EigenSolver.h" 31 | #include "src/Eigenvalues/SelfAdjointEigenSolver.h" 32 | #include "src/Eigenvalues/GeneralizedSelfAdjointEigenSolver.h" 33 | #include "src/Eigenvalues/HessenbergDecomposition.h" 34 | #include "src/Eigenvalues/ComplexSchur.h" 35 | #include "src/Eigenvalues/ComplexEigenSolver.h" 36 | #include "src/Eigenvalues/RealQZ.h" 37 | #include "src/Eigenvalues/GeneralizedEigenSolver.h" 38 | #include "src/Eigenvalues/MatrixBaseEigenvalues.h" 39 | #ifdef EIGEN_USE_LAPACKE 40 | #include "src/Eigenvalues/RealSchur_MKL.h" 41 | #include "src/Eigenvalues/ComplexSchur_MKL.h" 42 | #include "src/Eigenvalues/SelfAdjointEigenSolver_MKL.h" 43 | #endif 44 | 45 | #include "src/Core/util/ReenableStupidWarnings.h" 46 | 47 | #endif // EIGEN_EIGENVALUES_MODULE_H 48 | /* vim: set filetype=cpp et sw=2 ts=2 ai: */ 49 | -------------------------------------------------------------------------------- /src/Surfworks/Eigen/Geometry: -------------------------------------------------------------------------------- 1 | #ifndef EIGEN_GEOMETRY_MODULE_H 2 | #define EIGEN_GEOMETRY_MODULE_H 3 | 4 | #include "Core" 5 | 6 | #include "src/Core/util/DisableStupidWarnings.h" 7 | 8 | #include "SVD" 9 | #include "LU" 10 | #include 11 | 12 | #ifndef M_PI 13 | #define M_PI 3.14159265358979323846 14 | #endif 15 | 16 | /** \defgroup Geometry_Module Geometry module 17 | * 18 | * 19 | * 20 | * This module provides support for: 21 | * - fixed-size homogeneous transformations 22 | * - translation, scaling, 2D and 3D rotations 23 | * - quaternions 24 | * - \ref MatrixBase::cross() "cross product" 25 | * - \ref MatrixBase::unitOrthogonal() "orthognal vector generation" 26 | * - some linear components: parametrized-lines and hyperplanes 27 | * 28 | * \code 29 | * #include 30 | * \endcode 31 | */ 32 | 33 | #include "src/Geometry/OrthoMethods.h" 34 | #include "src/Geometry/EulerAngles.h" 35 | 36 | #if EIGEN2_SUPPORT_STAGE > STAGE20_RESOLVE_API_CONFLICTS 37 | #include "src/Geometry/Homogeneous.h" 38 | #include "src/Geometry/RotationBase.h" 39 | #include "src/Geometry/Rotation2D.h" 40 | #include "src/Geometry/Quaternion.h" 41 | #include "src/Geometry/AngleAxis.h" 42 | #include "src/Geometry/Transform.h" 43 | #include "src/Geometry/Translation.h" 44 | #include "src/Geometry/Scaling.h" 45 | #include "src/Geometry/Hyperplane.h" 46 | #include "src/Geometry/ParametrizedLine.h" 47 | #include "src/Geometry/AlignedBox.h" 48 | #include "src/Geometry/Umeyama.h" 49 | 50 | #if defined EIGEN_VECTORIZE_SSE 51 | #include "src/Geometry/arch/Geometry_SSE.h" 52 | #endif 53 | #endif 54 | 55 | #ifdef EIGEN2_SUPPORT 56 | #include "src/Eigen2Support/Geometry/All.h" 57 | #endif 58 | 59 | #include "src/Core/util/ReenableStupidWarnings.h" 60 | 61 | #endif // EIGEN_GEOMETRY_MODULE_H 62 | /* vim: set filetype=cpp et sw=2 ts=2 ai: */ 63 | 64 | -------------------------------------------------------------------------------- /src/Surfworks/Eigen/Householder: -------------------------------------------------------------------------------- 1 | #ifndef EIGEN_HOUSEHOLDER_MODULE_H 2 | #define EIGEN_HOUSEHOLDER_MODULE_H 3 | 4 | #include "Core" 5 | 6 | #include "src/Core/util/DisableStupidWarnings.h" 7 | 8 | /** \defgroup Householder_Module Householder module 9 | * This module provides Householder transformations. 10 | * 11 | * \code 12 | * #include 13 | * \endcode 14 | */ 15 | 16 | #include "src/Householder/Householder.h" 17 | #include "src/Householder/HouseholderSequence.h" 18 | #include "src/Householder/BlockHouseholder.h" 19 | 20 | #include "src/Core/util/ReenableStupidWarnings.h" 21 | 22 | #endif // EIGEN_HOUSEHOLDER_MODULE_H 23 | /* vim: set filetype=cpp et sw=2 ts=2 ai: */ 24 | -------------------------------------------------------------------------------- /src/Surfworks/Eigen/IterativeLinearSolvers: -------------------------------------------------------------------------------- 1 | #ifndef EIGEN_ITERATIVELINEARSOLVERS_MODULE_H 2 | #define EIGEN_ITERATIVELINEARSOLVERS_MODULE_H 3 | 4 | #include "SparseCore" 5 | #include "OrderingMethods" 6 | 7 | #include "src/Core/util/DisableStupidWarnings.h" 8 | 9 | /** 10 | * \defgroup IterativeLinearSolvers_Module IterativeLinearSolvers module 11 | * 12 | * This module currently provides iterative methods to solve problems of the form \c A \c x = \c b, where \c A is a squared matrix, usually very large and sparse. 13 | * Those solvers are accessible via the following classes: 14 | * - ConjugateGradient for selfadjoint (hermitian) matrices, 15 | * - BiCGSTAB for general square matrices. 16 | * 17 | * These iterative solvers are associated with some preconditioners: 18 | * - IdentityPreconditioner - not really useful 19 | * - DiagonalPreconditioner - also called JAcobi preconditioner, work very well on diagonal dominant matrices. 20 | * - IncompleteILUT - incomplete LU factorization with dual thresholding 21 | * 22 | * Such problems can also be solved using the direct sparse decomposition modules: SparseCholesky, CholmodSupport, UmfPackSupport, SuperLUSupport. 23 | * 24 | * \code 25 | * #include 26 | * \endcode 27 | */ 28 | 29 | #include "src/misc/Solve.h" 30 | #include "src/misc/SparseSolve.h" 31 | 32 | #include "src/IterativeLinearSolvers/IterativeSolverBase.h" 33 | #include "src/IterativeLinearSolvers/BasicPreconditioners.h" 34 | #include "src/IterativeLinearSolvers/ConjugateGradient.h" 35 | #include "src/IterativeLinearSolvers/BiCGSTAB.h" 36 | #include "src/IterativeLinearSolvers/IncompleteLUT.h" 37 | 38 | #include "src/Core/util/ReenableStupidWarnings.h" 39 | 40 | #endif // EIGEN_ITERATIVELINEARSOLVERS_MODULE_H 41 | -------------------------------------------------------------------------------- /src/Surfworks/Eigen/Jacobi: -------------------------------------------------------------------------------- 1 | #ifndef EIGEN_JACOBI_MODULE_H 2 | #define EIGEN_JACOBI_MODULE_H 3 | 4 | #include "Core" 5 | 6 | #include "src/Core/util/DisableStupidWarnings.h" 7 | 8 | /** \defgroup Jacobi_Module Jacobi module 9 | * This module provides Jacobi and Givens rotations. 10 | * 11 | * \code 12 | * #include 13 | * \endcode 14 | * 15 | * In addition to listed classes, it defines the two following MatrixBase methods to apply a Jacobi or Givens rotation: 16 | * - MatrixBase::applyOnTheLeft() 17 | * - MatrixBase::applyOnTheRight(). 18 | */ 19 | 20 | #include "src/Jacobi/Jacobi.h" 21 | 22 | #include "src/Core/util/ReenableStupidWarnings.h" 23 | 24 | #endif // EIGEN_JACOBI_MODULE_H 25 | /* vim: set filetype=cpp et sw=2 ts=2 ai: */ 26 | 27 | -------------------------------------------------------------------------------- /src/Surfworks/Eigen/LU: -------------------------------------------------------------------------------- 1 | #ifndef EIGEN_LU_MODULE_H 2 | #define EIGEN_LU_MODULE_H 3 | 4 | #include "Core" 5 | 6 | #include "src/Core/util/DisableStupidWarnings.h" 7 | 8 | /** \defgroup LU_Module LU module 9 | * This module includes %LU decomposition and related notions such as matrix inversion and determinant. 10 | * This module defines the following MatrixBase methods: 11 | * - MatrixBase::inverse() 12 | * - MatrixBase::determinant() 13 | * 14 | * \code 15 | * #include 16 | * \endcode 17 | */ 18 | 19 | #include "src/misc/Solve.h" 20 | #include "src/misc/Kernel.h" 21 | #include "src/misc/Image.h" 22 | #include "src/LU/FullPivLU.h" 23 | #include "src/LU/PartialPivLU.h" 24 | #ifdef EIGEN_USE_LAPACKE 25 | #include "src/LU/PartialPivLU_MKL.h" 26 | #endif 27 | #include "src/LU/Determinant.h" 28 | #include "src/LU/Inverse.h" 29 | 30 | #if defined EIGEN_VECTORIZE_SSE 31 | #include "src/LU/arch/Inverse_SSE.h" 32 | #endif 33 | 34 | #ifdef EIGEN2_SUPPORT 35 | #include "src/Eigen2Support/LU.h" 36 | #endif 37 | 38 | #include "src/Core/util/ReenableStupidWarnings.h" 39 | 40 | #endif // EIGEN_LU_MODULE_H 41 | /* vim: set filetype=cpp et sw=2 ts=2 ai: */ 42 | -------------------------------------------------------------------------------- /src/Surfworks/Eigen/LeastSquares: -------------------------------------------------------------------------------- 1 | #ifndef EIGEN_REGRESSION_MODULE_H 2 | #define EIGEN_REGRESSION_MODULE_H 3 | 4 | #ifndef EIGEN2_SUPPORT 5 | #error LeastSquares is only available in Eigen2 support mode (define EIGEN2_SUPPORT) 6 | #endif 7 | 8 | // exclude from normal eigen3-only documentation 9 | #ifdef EIGEN2_SUPPORT 10 | 11 | #include "Core" 12 | 13 | #include "src/Core/util/DisableStupidWarnings.h" 14 | 15 | #include "Eigenvalues" 16 | #include "Geometry" 17 | 18 | /** \defgroup LeastSquares_Module LeastSquares module 19 | * This module provides linear regression and related features. 20 | * 21 | * \code 22 | * #include 23 | * \endcode 24 | */ 25 | 26 | #include "src/Eigen2Support/LeastSquares.h" 27 | 28 | #include "src/Core/util/ReenableStupidWarnings.h" 29 | 30 | #endif // EIGEN2_SUPPORT 31 | 32 | #endif // EIGEN_REGRESSION_MODULE_H 33 | -------------------------------------------------------------------------------- /src/Surfworks/Eigen/MetisSupport: -------------------------------------------------------------------------------- 1 | #ifndef EIGEN_METISSUPPORT_MODULE_H 2 | #define EIGEN_METISSUPPORT_MODULE_H 3 | 4 | #include "SparseCore" 5 | 6 | #include "src/Core/util/DisableStupidWarnings.h" 7 | 8 | extern "C" { 9 | #include 10 | } 11 | 12 | 13 | /** \ingroup Support_modules 14 | * \defgroup MetisSupport_Module MetisSupport module 15 | * 16 | * \code 17 | * #include 18 | * \endcode 19 | * This module defines an interface to the METIS reordering package (http://glaros.dtc.umn.edu/gkhome/views/metis). 20 | * It can be used just as any other built-in method as explained in \link OrderingMethods_Module here. \endlink 21 | */ 22 | 23 | 24 | #include "src/MetisSupport/MetisSupport.h" 25 | 26 | #include "src/Core/util/ReenableStupidWarnings.h" 27 | 28 | #endif // EIGEN_METISSUPPORT_MODULE_H 29 | -------------------------------------------------------------------------------- /src/Surfworks/Eigen/OrderingMethods: -------------------------------------------------------------------------------- 1 | #ifndef EIGEN_ORDERINGMETHODS_MODULE_H 2 | #define EIGEN_ORDERINGMETHODS_MODULE_H 3 | 4 | #include "SparseCore" 5 | 6 | #include "src/Core/util/DisableStupidWarnings.h" 7 | 8 | /** 9 | * \defgroup OrderingMethods_Module OrderingMethods module 10 | * 11 | * This module is currently for internal use only 12 | * 13 | * It defines various built-in and external ordering methods for sparse matrices. 14 | * They are typically used to reduce the number of elements during 15 | * the sparse matrix decomposition (LLT, LU, QR). 16 | * Precisely, in a preprocessing step, a permutation matrix P is computed using 17 | * those ordering methods and applied to the columns of the matrix. 18 | * Using for instance the sparse Cholesky decomposition, it is expected that 19 | * the nonzeros elements in LLT(A*P) will be much smaller than that in LLT(A). 20 | * 21 | * 22 | * Usage : 23 | * \code 24 | * #include 25 | * \endcode 26 | * 27 | * A simple usage is as a template parameter in the sparse decomposition classes : 28 | * 29 | * \code 30 | * SparseLU > solver; 31 | * \endcode 32 | * 33 | * \code 34 | * SparseQR > solver; 35 | * \endcode 36 | * 37 | * It is possible as well to call directly a particular ordering method for your own purpose, 38 | * \code 39 | * AMDOrdering ordering; 40 | * PermutationMatrix perm; 41 | * SparseMatrix A; 42 | * //Fill the matrix ... 43 | * 44 | * ordering(A, perm); // Call AMD 45 | * \endcode 46 | * 47 | * \note Some of these methods (like AMD or METIS), need the sparsity pattern 48 | * of the input matrix to be symmetric. When the matrix is structurally unsymmetric, 49 | * Eigen computes internally the pattern of \f$A^T*A\f$ before calling the method. 50 | * If your matrix is already symmetric (at leat in structure), you can avoid that 51 | * by calling the method with a SelfAdjointView type. 52 | * 53 | * \code 54 | * // Call the ordering on the pattern of the lower triangular matrix A 55 | * ordering(A.selfadjointView(), perm); 56 | * \endcode 57 | */ 58 | 59 | #ifndef EIGEN_MPL2_ONLY 60 | #include "src/OrderingMethods/Amd.h" 61 | #endif 62 | 63 | #include "src/OrderingMethods/Ordering.h" 64 | #include "src/Core/util/ReenableStupidWarnings.h" 65 | 66 | #endif // EIGEN_ORDERINGMETHODS_MODULE_H 67 | -------------------------------------------------------------------------------- /src/Surfworks/Eigen/PaStiXSupport: -------------------------------------------------------------------------------- 1 | #ifndef EIGEN_PASTIXSUPPORT_MODULE_H 2 | #define EIGEN_PASTIXSUPPORT_MODULE_H 3 | 4 | #include "SparseCore" 5 | 6 | #include "src/Core/util/DisableStupidWarnings.h" 7 | 8 | #include 9 | extern "C" { 10 | #include 11 | #include 12 | } 13 | 14 | #ifdef complex 15 | #undef complex 16 | #endif 17 | 18 | /** \ingroup Support_modules 19 | * \defgroup PaStiXSupport_Module PaStiXSupport module 20 | * 21 | * This module provides an interface to the PaSTiX library. 22 | * PaSTiX is a general \b supernodal, \b parallel and \b opensource sparse solver. 23 | * It provides the two following main factorization classes: 24 | * - class PastixLLT : a supernodal, parallel LLt Cholesky factorization. 25 | * - class PastixLDLT: a supernodal, parallel LDLt Cholesky factorization. 26 | * - class PastixLU : a supernodal, parallel LU factorization (optimized for a symmetric pattern). 27 | * 28 | * \code 29 | * #include 30 | * \endcode 31 | * 32 | * In order to use this module, the PaSTiX headers must be accessible from the include paths, and your binary must be linked to the PaSTiX library and its dependencies. 33 | * The dependencies depend on how PaSTiX has been compiled. 34 | * For a cmake based project, you can use our FindPaSTiX.cmake module to help you in this task. 35 | * 36 | */ 37 | 38 | #include "src/misc/Solve.h" 39 | #include "src/misc/SparseSolve.h" 40 | 41 | #include "src/PaStiXSupport/PaStiXSupport.h" 42 | 43 | 44 | #include "src/Core/util/ReenableStupidWarnings.h" 45 | 46 | #endif // EIGEN_PASTIXSUPPORT_MODULE_H 47 | -------------------------------------------------------------------------------- /src/Surfworks/Eigen/PardisoSupport: -------------------------------------------------------------------------------- 1 | #ifndef EIGEN_PARDISOSUPPORT_MODULE_H 2 | #define EIGEN_PARDISOSUPPORT_MODULE_H 3 | 4 | #include "SparseCore" 5 | 6 | #include "src/Core/util/DisableStupidWarnings.h" 7 | 8 | #include 9 | 10 | #include 11 | 12 | /** \ingroup Support_modules 13 | * \defgroup PardisoSupport_Module PardisoSupport module 14 | * 15 | * This module brings support for the Intel(R) MKL PARDISO direct sparse solvers. 16 | * 17 | * \code 18 | * #include 19 | * \endcode 20 | * 21 | * In order to use this module, the MKL headers must be accessible from the include paths, and your binary must be linked to the MKL library and its dependencies. 22 | * See this \ref TopicUsingIntelMKL "page" for more information on MKL-Eigen integration. 23 | * 24 | */ 25 | 26 | #include "src/PardisoSupport/PardisoSupport.h" 27 | 28 | #include "src/Core/util/ReenableStupidWarnings.h" 29 | 30 | #endif // EIGEN_PARDISOSUPPORT_MODULE_H 31 | -------------------------------------------------------------------------------- /src/Surfworks/Eigen/QR: -------------------------------------------------------------------------------- 1 | #ifndef EIGEN_QR_MODULE_H 2 | #define EIGEN_QR_MODULE_H 3 | 4 | #include "Core" 5 | 6 | #include "src/Core/util/DisableStupidWarnings.h" 7 | 8 | #include "Cholesky" 9 | #include "Jacobi" 10 | #include "Householder" 11 | 12 | /** \defgroup QR_Module QR module 13 | * 14 | * 15 | * 16 | * This module provides various QR decompositions 17 | * This module also provides some MatrixBase methods, including: 18 | * - MatrixBase::qr(), 19 | * 20 | * \code 21 | * #include 22 | * \endcode 23 | */ 24 | 25 | #include "src/misc/Solve.h" 26 | #include "src/QR/HouseholderQR.h" 27 | #include "src/QR/FullPivHouseholderQR.h" 28 | #include "src/QR/ColPivHouseholderQR.h" 29 | #ifdef EIGEN_USE_LAPACKE 30 | #include "src/QR/HouseholderQR_MKL.h" 31 | #include "src/QR/ColPivHouseholderQR_MKL.h" 32 | #endif 33 | 34 | #ifdef EIGEN2_SUPPORT 35 | #include "src/Eigen2Support/QR.h" 36 | #endif 37 | 38 | #include "src/Core/util/ReenableStupidWarnings.h" 39 | 40 | #ifdef EIGEN2_SUPPORT 41 | #include "Eigenvalues" 42 | #endif 43 | 44 | #endif // EIGEN_QR_MODULE_H 45 | /* vim: set filetype=cpp et sw=2 ts=2 ai: */ 46 | -------------------------------------------------------------------------------- /src/Surfworks/Eigen/QtAlignedMalloc: -------------------------------------------------------------------------------- 1 | 2 | #ifndef EIGEN_QTMALLOC_MODULE_H 3 | #define EIGEN_QTMALLOC_MODULE_H 4 | 5 | #include "Core" 6 | 7 | #if (!EIGEN_MALLOC_ALREADY_ALIGNED) 8 | 9 | #include "src/Core/util/DisableStupidWarnings.h" 10 | 11 | void *qMalloc(size_t size) 12 | { 13 | return Eigen::internal::aligned_malloc(size); 14 | } 15 | 16 | void qFree(void *ptr) 17 | { 18 | Eigen::internal::aligned_free(ptr); 19 | } 20 | 21 | void *qRealloc(void *ptr, size_t size) 22 | { 23 | void* newPtr = Eigen::internal::aligned_malloc(size); 24 | memcpy(newPtr, ptr, size); 25 | Eigen::internal::aligned_free(ptr); 26 | return newPtr; 27 | } 28 | 29 | #include "src/Core/util/ReenableStupidWarnings.h" 30 | 31 | #endif 32 | 33 | #endif // EIGEN_QTMALLOC_MODULE_H 34 | /* vim: set filetype=cpp et sw=2 ts=2 ai: */ 35 | -------------------------------------------------------------------------------- /src/Surfworks/Eigen/SPQRSupport: -------------------------------------------------------------------------------- 1 | #ifndef EIGEN_SPQRSUPPORT_MODULE_H 2 | #define EIGEN_SPQRSUPPORT_MODULE_H 3 | 4 | #include "SparseCore" 5 | 6 | #include "src/Core/util/DisableStupidWarnings.h" 7 | 8 | #include "SuiteSparseQR.hpp" 9 | 10 | /** \ingroup Support_modules 11 | * \defgroup SPQRSupport_Module SuiteSparseQR module 12 | * 13 | * This module provides an interface to the SPQR library, which is part of the suitesparse package. 14 | * 15 | * \code 16 | * #include 17 | * \endcode 18 | * 19 | * In order to use this module, the SPQR headers must be accessible from the include paths, and your binary must be linked to the SPQR library and its dependencies (Cholmod, AMD, COLAMD,...). 20 | * For a cmake based project, you can use our FindSPQR.cmake and FindCholmod.Cmake modules 21 | * 22 | */ 23 | 24 | #include "src/misc/Solve.h" 25 | #include "src/misc/SparseSolve.h" 26 | #include "src/CholmodSupport/CholmodSupport.h" 27 | #include "src/SPQRSupport/SuiteSparseQRSupport.h" 28 | 29 | #endif 30 | -------------------------------------------------------------------------------- /src/Surfworks/Eigen/SVD: -------------------------------------------------------------------------------- 1 | #ifndef EIGEN_SVD_MODULE_H 2 | #define EIGEN_SVD_MODULE_H 3 | 4 | #include "QR" 5 | #include "Householder" 6 | #include "Jacobi" 7 | 8 | #include "src/Core/util/DisableStupidWarnings.h" 9 | 10 | /** \defgroup SVD_Module SVD module 11 | * 12 | * 13 | * 14 | * This module provides SVD decomposition for matrices (both real and complex). 15 | * This decomposition is accessible via the following MatrixBase method: 16 | * - MatrixBase::jacobiSvd() 17 | * 18 | * \code 19 | * #include 20 | * \endcode 21 | */ 22 | 23 | #include "src/misc/Solve.h" 24 | #include "src/SVD/JacobiSVD.h" 25 | #if defined(EIGEN_USE_LAPACKE) && !defined(EIGEN_USE_LAPACKE_STRICT) 26 | #include "src/SVD/JacobiSVD_MKL.h" 27 | #endif 28 | #include "src/SVD/UpperBidiagonalization.h" 29 | 30 | #ifdef EIGEN2_SUPPORT 31 | #include "src/Eigen2Support/SVD.h" 32 | #endif 33 | 34 | #include "src/Core/util/ReenableStupidWarnings.h" 35 | 36 | #endif // EIGEN_SVD_MODULE_H 37 | /* vim: set filetype=cpp et sw=2 ts=2 ai: */ 38 | -------------------------------------------------------------------------------- /src/Surfworks/Eigen/Sparse: -------------------------------------------------------------------------------- 1 | #ifndef EIGEN_SPARSE_MODULE_H 2 | #define EIGEN_SPARSE_MODULE_H 3 | 4 | /** \defgroup Sparse_Module Sparse meta-module 5 | * 6 | * Meta-module including all related modules: 7 | * - \ref SparseCore_Module 8 | * - \ref OrderingMethods_Module 9 | * - \ref SparseCholesky_Module 10 | * - \ref SparseLU_Module 11 | * - \ref SparseQR_Module 12 | * - \ref IterativeLinearSolvers_Module 13 | * 14 | * \code 15 | * #include 16 | * \endcode 17 | */ 18 | 19 | #include "SparseCore" 20 | #include "OrderingMethods" 21 | #include "SparseCholesky" 22 | #include "SparseLU" 23 | #include "SparseQR" 24 | #include "IterativeLinearSolvers" 25 | 26 | #endif // EIGEN_SPARSE_MODULE_H 27 | 28 | -------------------------------------------------------------------------------- /src/Surfworks/Eigen/SparseCholesky: -------------------------------------------------------------------------------- 1 | // This file is part of Eigen, a lightweight C++ template library 2 | // for linear algebra. 3 | // 4 | // Copyright (C) 2008-2013 Gael Guennebaud 5 | // 6 | // This Source Code Form is subject to the terms of the Mozilla 7 | // Public License v. 2.0. If a copy of the MPL was not distributed 8 | // with this file, You can obtain one at http://mozilla.org/MPL/2.0/. 9 | 10 | #ifndef EIGEN_SPARSECHOLESKY_MODULE_H 11 | #define EIGEN_SPARSECHOLESKY_MODULE_H 12 | 13 | #include "SparseCore" 14 | #include "OrderingMethods" 15 | 16 | #include "src/Core/util/DisableStupidWarnings.h" 17 | 18 | /** 19 | * \defgroup SparseCholesky_Module SparseCholesky module 20 | * 21 | * This module currently provides two variants of the direct sparse Cholesky decomposition for selfadjoint (hermitian) matrices. 22 | * Those decompositions are accessible via the following classes: 23 | * - SimplicialLLt, 24 | * - SimplicialLDLt 25 | * 26 | * Such problems can also be solved using the ConjugateGradient solver from the IterativeLinearSolvers module. 27 | * 28 | * \code 29 | * #include 30 | * \endcode 31 | */ 32 | 33 | #ifdef EIGEN_MPL2_ONLY 34 | #error The SparseCholesky module has nothing to offer in MPL2 only mode 35 | #endif 36 | 37 | #include "src/misc/Solve.h" 38 | #include "src/misc/SparseSolve.h" 39 | #include "src/SparseCholesky/SimplicialCholesky.h" 40 | 41 | #ifndef EIGEN_MPL2_ONLY 42 | #include "src/SparseCholesky/SimplicialCholesky_impl.h" 43 | #endif 44 | 45 | #include "src/Core/util/ReenableStupidWarnings.h" 46 | 47 | #endif // EIGEN_SPARSECHOLESKY_MODULE_H 48 | -------------------------------------------------------------------------------- /src/Surfworks/Eigen/SparseCore: -------------------------------------------------------------------------------- 1 | #ifndef EIGEN_SPARSECORE_MODULE_H 2 | #define EIGEN_SPARSECORE_MODULE_H 3 | 4 | #include "Core" 5 | 6 | #include "src/Core/util/DisableStupidWarnings.h" 7 | 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | 14 | /** 15 | * \defgroup SparseCore_Module SparseCore module 16 | * 17 | * This module provides a sparse matrix representation, and basic associatd matrix manipulations 18 | * and operations. 19 | * 20 | * See the \ref TutorialSparse "Sparse tutorial" 21 | * 22 | * \code 23 | * #include 24 | * \endcode 25 | * 26 | * This module depends on: Core. 27 | */ 28 | 29 | namespace Eigen { 30 | 31 | /** The type used to identify a general sparse storage. */ 32 | struct Sparse {}; 33 | 34 | } 35 | 36 | #include "src/SparseCore/SparseUtil.h" 37 | #include "src/SparseCore/SparseMatrixBase.h" 38 | #include "src/SparseCore/CompressedStorage.h" 39 | #include "src/SparseCore/AmbiVector.h" 40 | #include "src/SparseCore/SparseMatrix.h" 41 | #include "src/SparseCore/MappedSparseMatrix.h" 42 | #include "src/SparseCore/SparseVector.h" 43 | #include "src/SparseCore/SparseBlock.h" 44 | #include "src/SparseCore/SparseTranspose.h" 45 | #include "src/SparseCore/SparseCwiseUnaryOp.h" 46 | #include "src/SparseCore/SparseCwiseBinaryOp.h" 47 | #include "src/SparseCore/SparseDot.h" 48 | #include "src/SparseCore/SparsePermutation.h" 49 | #include "src/SparseCore/SparseRedux.h" 50 | #include "src/SparseCore/SparseFuzzy.h" 51 | #include "src/SparseCore/ConservativeSparseSparseProduct.h" 52 | #include "src/SparseCore/SparseSparseProductWithPruning.h" 53 | #include "src/SparseCore/SparseProduct.h" 54 | #include "src/SparseCore/SparseDenseProduct.h" 55 | #include "src/SparseCore/SparseDiagonalProduct.h" 56 | #include "src/SparseCore/SparseTriangularView.h" 57 | #include "src/SparseCore/SparseSelfAdjointView.h" 58 | #include "src/SparseCore/TriangularSolver.h" 59 | #include "src/SparseCore/SparseView.h" 60 | 61 | #include "src/Core/util/ReenableStupidWarnings.h" 62 | 63 | #endif // EIGEN_SPARSECORE_MODULE_H 64 | 65 | -------------------------------------------------------------------------------- /src/Surfworks/Eigen/SparseLU: -------------------------------------------------------------------------------- 1 | // This file is part of Eigen, a lightweight C++ template library 2 | // for linear algebra. 3 | // 4 | // Copyright (C) 2012 Désiré Nuentsa-Wakam 5 | // Copyright (C) 2012 Gael Guennebaud 6 | // 7 | // This Source Code Form is subject to the terms of the Mozilla 8 | // Public License v. 2.0. If a copy of the MPL was not distributed 9 | // with this file, You can obtain one at http://mozilla.org/MPL/2.0/. 10 | 11 | #ifndef EIGEN_SPARSELU_MODULE_H 12 | #define EIGEN_SPARSELU_MODULE_H 13 | 14 | #include "SparseCore" 15 | 16 | /** 17 | * \defgroup SparseLU_Module SparseLU module 18 | * This module defines a supernodal factorization of general sparse matrices. 19 | * The code is fully optimized for supernode-panel updates with specialized kernels. 20 | * Please, see the documentation of the SparseLU class for more details. 21 | */ 22 | 23 | #include "src/misc/Solve.h" 24 | #include "src/misc/SparseSolve.h" 25 | 26 | // Ordering interface 27 | #include "OrderingMethods" 28 | 29 | #include "src/SparseLU/SparseLU_gemm_kernel.h" 30 | 31 | #include "src/SparseLU/SparseLU_Structs.h" 32 | #include "src/SparseLU/SparseLU_SupernodalMatrix.h" 33 | #include "src/SparseLU/SparseLUImpl.h" 34 | #include "src/SparseCore/SparseColEtree.h" 35 | #include "src/SparseLU/SparseLU_Memory.h" 36 | #include "src/SparseLU/SparseLU_heap_relax_snode.h" 37 | #include "src/SparseLU/SparseLU_relax_snode.h" 38 | #include "src/SparseLU/SparseLU_pivotL.h" 39 | #include "src/SparseLU/SparseLU_panel_dfs.h" 40 | #include "src/SparseLU/SparseLU_kernel_bmod.h" 41 | #include "src/SparseLU/SparseLU_panel_bmod.h" 42 | #include "src/SparseLU/SparseLU_column_dfs.h" 43 | #include "src/SparseLU/SparseLU_column_bmod.h" 44 | #include "src/SparseLU/SparseLU_copy_to_ucol.h" 45 | #include "src/SparseLU/SparseLU_pruneL.h" 46 | #include "src/SparseLU/SparseLU_Utils.h" 47 | #include "src/SparseLU/SparseLU.h" 48 | 49 | #endif // EIGEN_SPARSELU_MODULE_H 50 | -------------------------------------------------------------------------------- /src/Surfworks/Eigen/SparseQR: -------------------------------------------------------------------------------- 1 | #ifndef EIGEN_SPARSEQR_MODULE_H 2 | #define EIGEN_SPARSEQR_MODULE_H 3 | 4 | #include "SparseCore" 5 | #include "OrderingMethods" 6 | #include "src/Core/util/DisableStupidWarnings.h" 7 | 8 | /** \defgroup SparseQR_Module SparseQR module 9 | * \brief Provides QR decomposition for sparse matrices 10 | * 11 | * This module provides a simplicial version of the left-looking Sparse QR decomposition. 12 | * The columns of the input matrix should be reordered to limit the fill-in during the 13 | * decomposition. Built-in methods (COLAMD, AMD) or external methods (METIS) can be used to this end. 14 | * See the \link OrderingMethods_Module OrderingMethods\endlink module for the list 15 | * of built-in and external ordering methods. 16 | * 17 | * \code 18 | * #include 19 | * \endcode 20 | * 21 | * 22 | */ 23 | 24 | #include "src/misc/Solve.h" 25 | #include "src/misc/SparseSolve.h" 26 | 27 | #include "OrderingMethods" 28 | #include "src/SparseCore/SparseColEtree.h" 29 | #include "src/SparseQR/SparseQR.h" 30 | 31 | #include "src/Core/util/ReenableStupidWarnings.h" 32 | 33 | #endif 34 | -------------------------------------------------------------------------------- /src/Surfworks/Eigen/StdDeque: -------------------------------------------------------------------------------- 1 | // This file is part of Eigen, a lightweight C++ template library 2 | // for linear algebra. 3 | // 4 | // Copyright (C) 2009 Gael Guennebaud 5 | // Copyright (C) 2009 Hauke Heibel 6 | // 7 | // This Source Code Form is subject to the terms of the Mozilla 8 | // Public License v. 2.0. If a copy of the MPL was not distributed 9 | // with this file, You can obtain one at http://mozilla.org/MPL/2.0/. 10 | 11 | #ifndef EIGEN_STDDEQUE_MODULE_H 12 | #define EIGEN_STDDEQUE_MODULE_H 13 | 14 | #include "Core" 15 | #include 16 | 17 | #if (defined(_MSC_VER) && defined(_WIN64)) /* MSVC auto aligns in 64 bit builds */ 18 | 19 | #define EIGEN_DEFINE_STL_DEQUE_SPECIALIZATION(...) 20 | 21 | #else 22 | 23 | #include "src/StlSupport/StdDeque.h" 24 | 25 | #endif 26 | 27 | #endif // EIGEN_STDDEQUE_MODULE_H 28 | -------------------------------------------------------------------------------- /src/Surfworks/Eigen/StdList: -------------------------------------------------------------------------------- 1 | // This file is part of Eigen, a lightweight C++ template library 2 | // for linear algebra. 3 | // 4 | // Copyright (C) 2009 Hauke Heibel 5 | // 6 | // This Source Code Form is subject to the terms of the Mozilla 7 | // Public License v. 2.0. If a copy of the MPL was not distributed 8 | // with this file, You can obtain one at http://mozilla.org/MPL/2.0/. 9 | 10 | #ifndef EIGEN_STDLIST_MODULE_H 11 | #define EIGEN_STDLIST_MODULE_H 12 | 13 | #include "Core" 14 | #include 15 | 16 | #if (defined(_MSC_VER) && defined(_WIN64)) /* MSVC auto aligns in 64 bit builds */ 17 | 18 | #define EIGEN_DEFINE_STL_LIST_SPECIALIZATION(...) 19 | 20 | #else 21 | 22 | #include "src/StlSupport/StdList.h" 23 | 24 | #endif 25 | 26 | #endif // EIGEN_STDLIST_MODULE_H 27 | -------------------------------------------------------------------------------- /src/Surfworks/Eigen/StdVector: -------------------------------------------------------------------------------- 1 | // This file is part of Eigen, a lightweight C++ template library 2 | // for linear algebra. 3 | // 4 | // Copyright (C) 2009 Gael Guennebaud 5 | // Copyright (C) 2009 Hauke Heibel 6 | // 7 | // This Source Code Form is subject to the terms of the Mozilla 8 | // Public License v. 2.0. If a copy of the MPL was not distributed 9 | // with this file, You can obtain one at http://mozilla.org/MPL/2.0/. 10 | 11 | #ifndef EIGEN_STDVECTOR_MODULE_H 12 | #define EIGEN_STDVECTOR_MODULE_H 13 | 14 | #include "Core" 15 | #include 16 | 17 | #if (defined(_MSC_VER) && defined(_WIN64)) /* MSVC auto aligns in 64 bit builds */ 18 | 19 | #define EIGEN_DEFINE_STL_VECTOR_SPECIALIZATION(...) 20 | 21 | #else 22 | 23 | #include "src/StlSupport/StdVector.h" 24 | 25 | #endif 26 | 27 | #endif // EIGEN_STDVECTOR_MODULE_H 28 | -------------------------------------------------------------------------------- /src/Surfworks/Eigen/SuperLUSupport: -------------------------------------------------------------------------------- 1 | #ifndef EIGEN_SUPERLUSUPPORT_MODULE_H 2 | #define EIGEN_SUPERLUSUPPORT_MODULE_H 3 | 4 | #include "SparseCore" 5 | 6 | #include "src/Core/util/DisableStupidWarnings.h" 7 | 8 | #ifdef EMPTY 9 | #define EIGEN_EMPTY_WAS_ALREADY_DEFINED 10 | #endif 11 | 12 | typedef int int_t; 13 | #include 14 | #include 15 | #include 16 | 17 | // slu_util.h defines a preprocessor token named EMPTY which is really polluting, 18 | // so we remove it in favor of a SUPERLU_EMPTY token. 19 | // If EMPTY was already defined then we don't undef it. 20 | 21 | #if defined(EIGEN_EMPTY_WAS_ALREADY_DEFINED) 22 | # undef EIGEN_EMPTY_WAS_ALREADY_DEFINED 23 | #elif defined(EMPTY) 24 | # undef EMPTY 25 | #endif 26 | 27 | #define SUPERLU_EMPTY (-1) 28 | 29 | namespace Eigen { struct SluMatrix; } 30 | 31 | /** \ingroup Support_modules 32 | * \defgroup SuperLUSupport_Module SuperLUSupport module 33 | * 34 | * This module provides an interface to the SuperLU library. 35 | * It provides the following factorization class: 36 | * - class SuperLU: a supernodal sequential LU factorization. 37 | * - class SuperILU: a supernodal sequential incomplete LU factorization (to be used as a preconditioner for iterative methods). 38 | * 39 | * \warning When including this module, you have to use SUPERLU_EMPTY instead of EMPTY which is no longer defined because it is too polluting. 40 | * 41 | * \code 42 | * #include 43 | * \endcode 44 | * 45 | * In order to use this module, the superlu headers must be accessible from the include paths, and your binary must be linked to the superlu library and its dependencies. 46 | * The dependencies depend on how superlu has been compiled. 47 | * For a cmake based project, you can use our FindSuperLU.cmake module to help you in this task. 48 | * 49 | */ 50 | 51 | #include "src/misc/Solve.h" 52 | #include "src/misc/SparseSolve.h" 53 | 54 | #include "src/SuperLUSupport/SuperLUSupport.h" 55 | 56 | 57 | #include "src/Core/util/ReenableStupidWarnings.h" 58 | 59 | #endif // EIGEN_SUPERLUSUPPORT_MODULE_H 60 | -------------------------------------------------------------------------------- /src/Surfworks/Eigen/UmfPackSupport: -------------------------------------------------------------------------------- 1 | #ifndef EIGEN_UMFPACKSUPPORT_MODULE_H 2 | #define EIGEN_UMFPACKSUPPORT_MODULE_H 3 | 4 | #include "SparseCore" 5 | 6 | #include "src/Core/util/DisableStupidWarnings.h" 7 | 8 | extern "C" { 9 | #include 10 | } 11 | 12 | /** \ingroup Support_modules 13 | * \defgroup UmfPackSupport_Module UmfPackSupport module 14 | * 15 | * This module provides an interface to the UmfPack library which is part of the suitesparse package. 16 | * It provides the following factorization class: 17 | * - class UmfPackLU: a multifrontal sequential LU factorization. 18 | * 19 | * \code 20 | * #include 21 | * \endcode 22 | * 23 | * In order to use this module, the umfpack headers must be accessible from the include paths, and your binary must be linked to the umfpack library and its dependencies. 24 | * The dependencies depend on how umfpack has been compiled. 25 | * For a cmake based project, you can use our FindUmfPack.cmake module to help you in this task. 26 | * 27 | */ 28 | 29 | #include "src/misc/Solve.h" 30 | #include "src/misc/SparseSolve.h" 31 | 32 | #include "src/UmfPackSupport/UmfPackSupport.h" 33 | 34 | #include "src/Core/util/ReenableStupidWarnings.h" 35 | 36 | #endif // EIGEN_UMFPACKSUPPORT_MODULE_H 37 | -------------------------------------------------------------------------------- /src/Surfworks/Eigen/src/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | file(GLOB Eigen_src_subdirectories "*") 2 | escape_string_as_regex(ESCAPED_CMAKE_CURRENT_SOURCE_DIR "${CMAKE_CURRENT_SOURCE_DIR}") 3 | foreach(f ${Eigen_src_subdirectories}) 4 | if(NOT f MATCHES "\\.txt" AND NOT f MATCHES "${ESCAPED_CMAKE_CURRENT_SOURCE_DIR}/[.].+" ) 5 | add_subdirectory(${f}) 6 | endif() 7 | endforeach() 8 | -------------------------------------------------------------------------------- /src/Surfworks/Eigen/src/Cholesky/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FILE(GLOB Eigen_Cholesky_SRCS "*.h") 2 | 3 | INSTALL(FILES 4 | ${Eigen_Cholesky_SRCS} 5 | DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/Cholesky COMPONENT Devel 6 | ) 7 | -------------------------------------------------------------------------------- /src/Surfworks/Eigen/src/CholmodSupport/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FILE(GLOB Eigen_CholmodSupport_SRCS "*.h") 2 | 3 | INSTALL(FILES 4 | ${Eigen_CholmodSupport_SRCS} 5 | DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/CholmodSupport COMPONENT Devel 6 | ) 7 | -------------------------------------------------------------------------------- /src/Surfworks/Eigen/src/Core/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FILE(GLOB Eigen_Core_SRCS "*.h") 2 | 3 | INSTALL(FILES 4 | ${Eigen_Core_SRCS} 5 | DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/Core COMPONENT Devel 6 | ) 7 | 8 | ADD_SUBDIRECTORY(products) 9 | ADD_SUBDIRECTORY(util) 10 | ADD_SUBDIRECTORY(arch) 11 | -------------------------------------------------------------------------------- /src/Surfworks/Eigen/src/Core/CoreIterators.h: -------------------------------------------------------------------------------- 1 | // This file is part of Eigen, a lightweight C++ template library 2 | // for linear algebra. 3 | // 4 | // Copyright (C) 2008-2010 Gael Guennebaud 5 | // 6 | // This Source Code Form is subject to the terms of the Mozilla 7 | // Public License v. 2.0. If a copy of the MPL was not distributed 8 | // with this file, You can obtain one at http://mozilla.org/MPL/2.0/. 9 | 10 | #ifndef EIGEN_COREITERATORS_H 11 | #define EIGEN_COREITERATORS_H 12 | 13 | namespace Eigen { 14 | 15 | /* This file contains the respective InnerIterator definition of the expressions defined in Eigen/Core 16 | */ 17 | 18 | /** \ingroup SparseCore_Module 19 | * \class InnerIterator 20 | * \brief An InnerIterator allows to loop over the element of a sparse (or dense) matrix or expression 21 | * 22 | * todo 23 | */ 24 | 25 | // generic version for dense matrix and expressions 26 | template class DenseBase::InnerIterator 27 | { 28 | protected: 29 | typedef typename Derived::Scalar Scalar; 30 | typedef typename Derived::Index Index; 31 | 32 | enum { IsRowMajor = (Derived::Flags&RowMajorBit)==RowMajorBit }; 33 | public: 34 | EIGEN_STRONG_INLINE InnerIterator(const Derived& expr, Index outer) 35 | : m_expression(expr), m_inner(0), m_outer(outer), m_end(expr.innerSize()) 36 | {} 37 | 38 | EIGEN_STRONG_INLINE Scalar value() const 39 | { 40 | return (IsRowMajor) ? m_expression.coeff(m_outer, m_inner) 41 | : m_expression.coeff(m_inner, m_outer); 42 | } 43 | 44 | EIGEN_STRONG_INLINE InnerIterator& operator++() { m_inner++; return *this; } 45 | 46 | EIGEN_STRONG_INLINE Index index() const { return m_inner; } 47 | inline Index row() const { return IsRowMajor ? m_outer : index(); } 48 | inline Index col() const { return IsRowMajor ? index() : m_outer; } 49 | 50 | EIGEN_STRONG_INLINE operator bool() const { return m_inner < m_end && m_inner>=0; } 51 | 52 | protected: 53 | const Derived& m_expression; 54 | Index m_inner; 55 | const Index m_outer; 56 | const Index m_end; 57 | }; 58 | 59 | } // end namespace Eigen 60 | 61 | #endif // EIGEN_COREITERATORS_H 62 | -------------------------------------------------------------------------------- /src/Surfworks/Eigen/src/Core/arch/AltiVec/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FILE(GLOB Eigen_Core_arch_AltiVec_SRCS "*.h") 2 | 3 | INSTALL(FILES 4 | ${Eigen_Core_arch_AltiVec_SRCS} 5 | DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/Core/arch/AltiVec COMPONENT Devel 6 | ) 7 | -------------------------------------------------------------------------------- /src/Surfworks/Eigen/src/Core/arch/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | ADD_SUBDIRECTORY(SSE) 2 | ADD_SUBDIRECTORY(AltiVec) 3 | ADD_SUBDIRECTORY(NEON) 4 | ADD_SUBDIRECTORY(Default) 5 | -------------------------------------------------------------------------------- /src/Surfworks/Eigen/src/Core/arch/Default/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FILE(GLOB Eigen_Core_arch_Default_SRCS "*.h") 2 | 3 | INSTALL(FILES 4 | ${Eigen_Core_arch_Default_SRCS} 5 | DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/Core/arch/Default COMPONENT Devel 6 | ) 7 | -------------------------------------------------------------------------------- /src/Surfworks/Eigen/src/Core/arch/Default/Settings.h: -------------------------------------------------------------------------------- 1 | // This file is part of Eigen, a lightweight C++ template library 2 | // for linear algebra. 3 | // 4 | // Copyright (C) 2008-2010 Gael Guennebaud 5 | // Copyright (C) 2006-2008 Benoit Jacob 6 | // 7 | // This Source Code Form is subject to the terms of the Mozilla 8 | // Public License v. 2.0. If a copy of the MPL was not distributed 9 | // with this file, You can obtain one at http://mozilla.org/MPL/2.0/. 10 | 11 | 12 | /* All the parameters defined in this file can be specialized in the 13 | * architecture specific files, and/or by the user. 14 | * More to come... */ 15 | 16 | #ifndef EIGEN_DEFAULT_SETTINGS_H 17 | #define EIGEN_DEFAULT_SETTINGS_H 18 | 19 | /** Defines the maximal loop size to enable meta unrolling of loops. 20 | * Note that the value here is expressed in Eigen's own notion of "number of FLOPS", 21 | * it does not correspond to the number of iterations or the number of instructions 22 | */ 23 | #ifndef EIGEN_UNROLLING_LIMIT 24 | #define EIGEN_UNROLLING_LIMIT 100 25 | #endif 26 | 27 | /** Defines the threshold between a "small" and a "large" matrix. 28 | * This threshold is mainly used to select the proper product implementation. 29 | */ 30 | #ifndef EIGEN_CACHEFRIENDLY_PRODUCT_THRESHOLD 31 | #define EIGEN_CACHEFRIENDLY_PRODUCT_THRESHOLD 8 32 | #endif 33 | 34 | /** Defines the maximal width of the blocks used in the triangular product and solver 35 | * for vectors (level 2 blas xTRMV and xTRSV). The default is 8. 36 | */ 37 | #ifndef EIGEN_TUNE_TRIANGULAR_PANEL_WIDTH 38 | #define EIGEN_TUNE_TRIANGULAR_PANEL_WIDTH 8 39 | #endif 40 | 41 | 42 | /** Defines the default number of registers available for that architecture. 43 | * Currently it must be 8 or 16. Other values will fail. 44 | */ 45 | #ifndef EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS 46 | #define EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS 8 47 | #endif 48 | 49 | #endif // EIGEN_DEFAULT_SETTINGS_H 50 | -------------------------------------------------------------------------------- /src/Surfworks/Eigen/src/Core/arch/NEON/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FILE(GLOB Eigen_Core_arch_NEON_SRCS "*.h") 2 | 3 | INSTALL(FILES 4 | ${Eigen_Core_arch_NEON_SRCS} 5 | DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/Core/arch/NEON COMPONENT Devel 6 | ) 7 | -------------------------------------------------------------------------------- /src/Surfworks/Eigen/src/Core/arch/SSE/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FILE(GLOB Eigen_Core_arch_SSE_SRCS "*.h") 2 | 3 | INSTALL(FILES 4 | ${Eigen_Core_arch_SSE_SRCS} 5 | DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/Core/arch/SSE COMPONENT Devel 6 | ) 7 | -------------------------------------------------------------------------------- /src/Surfworks/Eigen/src/Core/products/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FILE(GLOB Eigen_Core_Product_SRCS "*.h") 2 | 3 | INSTALL(FILES 4 | ${Eigen_Core_Product_SRCS} 5 | DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/Core/products COMPONENT Devel 6 | ) 7 | -------------------------------------------------------------------------------- /src/Surfworks/Eigen/src/Core/util/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FILE(GLOB Eigen_Core_util_SRCS "*.h") 2 | 3 | INSTALL(FILES 4 | ${Eigen_Core_util_SRCS} 5 | DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/Core/util COMPONENT Devel 6 | ) 7 | -------------------------------------------------------------------------------- /src/Surfworks/Eigen/src/Core/util/DisableStupidWarnings.h: -------------------------------------------------------------------------------- 1 | #ifndef EIGEN_WARNINGS_DISABLED 2 | #define EIGEN_WARNINGS_DISABLED 3 | 4 | #ifdef _MSC_VER 5 | // 4100 - unreferenced formal parameter (occurred e.g. in aligned_allocator::destroy(pointer p)) 6 | // 4101 - unreferenced local variable 7 | // 4127 - conditional expression is constant 8 | // 4181 - qualifier applied to reference type ignored 9 | // 4211 - nonstandard extension used : redefined extern to static 10 | // 4244 - 'argument' : conversion from 'type1' to 'type2', possible loss of data 11 | // 4273 - QtAlignedMalloc, inconsistent DLL linkage 12 | // 4324 - structure was padded due to declspec(align()) 13 | // 4512 - assignment operator could not be generated 14 | // 4522 - 'class' : multiple assignment operators specified 15 | // 4700 - uninitialized local variable 'xyz' used 16 | // 4717 - 'function' : recursive on all control paths, function will cause runtime stack overflow 17 | #ifndef EIGEN_PERMANENTLY_DISABLE_STUPID_WARNINGS 18 | #pragma warning( push ) 19 | #endif 20 | #pragma warning( disable : 4100 4101 4127 4181 4211 4244 4273 4324 4512 4522 4700 4717 ) 21 | #elif defined __INTEL_COMPILER 22 | // 2196 - routine is both "inline" and "noinline" ("noinline" assumed) 23 | // ICC 12 generates this warning even without any inline keyword, when defining class methods 'inline' i.e. inside of class body 24 | // typedef that may be a reference type. 25 | // 279 - controlling expression is constant 26 | // ICC 12 generates this warning on assert(constant_expression_depending_on_template_params) and frankly this is a legitimate use case. 27 | #ifndef EIGEN_PERMANENTLY_DISABLE_STUPID_WARNINGS 28 | #pragma warning push 29 | #endif 30 | #pragma warning disable 2196 279 31 | #elif defined __clang__ 32 | // -Wconstant-logical-operand - warning: use of logical && with constant operand; switch to bitwise & or remove constant 33 | // this is really a stupid warning as it warns on compile-time expressions involving enums 34 | #ifndef EIGEN_PERMANENTLY_DISABLE_STUPID_WARNINGS 35 | #pragma clang diagnostic push 36 | #endif 37 | #pragma clang diagnostic ignored "-Wconstant-logical-operand" 38 | #endif 39 | 40 | #endif // not EIGEN_WARNINGS_DISABLED 41 | -------------------------------------------------------------------------------- /src/Surfworks/Eigen/src/Core/util/NonMPL2.h: -------------------------------------------------------------------------------- 1 | #ifdef EIGEN_MPL2_ONLY 2 | #error Including non-MPL2 code in EIGEN_MPL2_ONLY mode 3 | #endif 4 | -------------------------------------------------------------------------------- /src/Surfworks/Eigen/src/Core/util/ReenableStupidWarnings.h: -------------------------------------------------------------------------------- 1 | #ifdef EIGEN_WARNINGS_DISABLED 2 | #undef EIGEN_WARNINGS_DISABLED 3 | 4 | #ifndef EIGEN_PERMANENTLY_DISABLE_STUPID_WARNINGS 5 | #ifdef _MSC_VER 6 | #pragma warning( pop ) 7 | #elif defined __INTEL_COMPILER 8 | #pragma warning pop 9 | #elif defined __clang__ 10 | #pragma clang diagnostic pop 11 | #endif 12 | #endif 13 | 14 | #endif // EIGEN_WARNINGS_DISABLED 15 | -------------------------------------------------------------------------------- /src/Surfworks/Eigen/src/Eigen2Support/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FILE(GLOB Eigen_Eigen2Support_SRCS "*.h") 2 | 3 | INSTALL(FILES 4 | ${Eigen_Eigen2Support_SRCS} 5 | DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/Eigen2Support COMPONENT Devel 6 | ) 7 | 8 | ADD_SUBDIRECTORY(Geometry) -------------------------------------------------------------------------------- /src/Surfworks/Eigen/src/Eigen2Support/Geometry/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FILE(GLOB Eigen_Eigen2Support_Geometry_SRCS "*.h") 2 | 3 | INSTALL(FILES 4 | ${Eigen_Eigen2Support_Geometry_SRCS} 5 | DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/Eigen2Support/Geometry 6 | ) 7 | -------------------------------------------------------------------------------- /src/Surfworks/Eigen/src/Eigen2Support/Lazy.h: -------------------------------------------------------------------------------- 1 | // This file is part of Eigen, a lightweight C++ template library 2 | // for linear algebra. 3 | // 4 | // Copyright (C) 2008 Benoit Jacob 5 | // 6 | // This Source Code Form is subject to the terms of the Mozilla 7 | // Public License v. 2.0. If a copy of the MPL was not distributed 8 | // with this file, You can obtain one at http://mozilla.org/MPL/2.0/. 9 | 10 | #ifndef EIGEN_LAZY_H 11 | #define EIGEN_LAZY_H 12 | 13 | namespace Eigen { 14 | 15 | /** \deprecated it is only used by lazy() which is deprecated 16 | * 17 | * \returns an expression of *this with added flags 18 | * 19 | * Example: \include MatrixBase_marked.cpp 20 | * Output: \verbinclude MatrixBase_marked.out 21 | * 22 | * \sa class Flagged, extract(), part() 23 | */ 24 | template 25 | template 26 | inline const Flagged 27 | MatrixBase::marked() const 28 | { 29 | return derived(); 30 | } 31 | 32 | /** \deprecated use MatrixBase::noalias() 33 | * 34 | * \returns an expression of *this with the EvalBeforeAssigningBit flag removed. 35 | * 36 | * Example: \include MatrixBase_lazy.cpp 37 | * Output: \verbinclude MatrixBase_lazy.out 38 | * 39 | * \sa class Flagged, marked() 40 | */ 41 | template 42 | inline const Flagged 43 | MatrixBase::lazy() const 44 | { 45 | return derived(); 46 | } 47 | 48 | 49 | /** \internal 50 | * Overloaded to perform an efficient C += (A*B).lazy() */ 51 | template 52 | template 53 | Derived& MatrixBase::operator+=(const Flagged, 0, 54 | EvalBeforeAssigningBit>& other) 55 | { 56 | other._expression().derived().addTo(derived()); return derived(); 57 | } 58 | 59 | /** \internal 60 | * Overloaded to perform an efficient C -= (A*B).lazy() */ 61 | template 62 | template 63 | Derived& MatrixBase::operator-=(const Flagged, 0, 64 | EvalBeforeAssigningBit>& other) 65 | { 66 | other._expression().derived().subTo(derived()); return derived(); 67 | } 68 | 69 | } // end namespace Eigen 70 | 71 | #endif // EIGEN_LAZY_H 72 | -------------------------------------------------------------------------------- /src/Surfworks/Eigen/src/Eigen2Support/Macros.h: -------------------------------------------------------------------------------- 1 | // This file is part of Eigen, a lightweight C++ template library 2 | // for linear algebra. 3 | // 4 | // Copyright (C) 2011 Benoit Jacob 5 | // 6 | // This Source Code Form is subject to the terms of the Mozilla 7 | // Public License v. 2.0. If a copy of the MPL was not distributed 8 | // with this file, You can obtain one at http://mozilla.org/MPL/2.0/. 9 | 10 | #ifndef EIGEN2_MACROS_H 11 | #define EIGEN2_MACROS_H 12 | 13 | #define ei_assert eigen_assert 14 | #define ei_internal_assert eigen_internal_assert 15 | 16 | #define EIGEN_ALIGN_128 EIGEN_ALIGN16 17 | 18 | #define EIGEN_ARCH_WANTS_ALIGNMENT EIGEN_ALIGN_STATICALLY 19 | 20 | #endif // EIGEN2_MACROS_H 21 | -------------------------------------------------------------------------------- /src/Surfworks/Eigen/src/Eigen2Support/Memory.h: -------------------------------------------------------------------------------- 1 | // This file is part of Eigen, a lightweight C++ template library 2 | // for linear algebra. 3 | // 4 | // Copyright (C) 2011 Benoit Jacob 5 | // 6 | // This Source Code Form is subject to the terms of the Mozilla 7 | // Public License v. 2.0. If a copy of the MPL was not distributed 8 | // with this file, You can obtain one at http://mozilla.org/MPL/2.0/. 9 | 10 | #ifndef EIGEN2_MEMORY_H 11 | #define EIGEN2_MEMORY_H 12 | 13 | namespace Eigen { 14 | 15 | inline void* ei_aligned_malloc(size_t size) { return internal::aligned_malloc(size); } 16 | inline void ei_aligned_free(void *ptr) { internal::aligned_free(ptr); } 17 | inline void* ei_aligned_realloc(void *ptr, size_t new_size, size_t old_size) { return internal::aligned_realloc(ptr, new_size, old_size); } 18 | inline void* ei_handmade_aligned_malloc(size_t size) { return internal::handmade_aligned_malloc(size); } 19 | inline void ei_handmade_aligned_free(void *ptr) { internal::handmade_aligned_free(ptr); } 20 | 21 | template inline void* ei_conditional_aligned_malloc(size_t size) 22 | { 23 | return internal::conditional_aligned_malloc(size); 24 | } 25 | template inline void ei_conditional_aligned_free(void *ptr) 26 | { 27 | internal::conditional_aligned_free(ptr); 28 | } 29 | template inline void* ei_conditional_aligned_realloc(void* ptr, size_t new_size, size_t old_size) 30 | { 31 | return internal::conditional_aligned_realloc(ptr, new_size, old_size); 32 | } 33 | 34 | template inline T* ei_aligned_new(size_t size) 35 | { 36 | return internal::aligned_new(size); 37 | } 38 | template inline void ei_aligned_delete(T *ptr, size_t size) 39 | { 40 | return internal::aligned_delete(ptr, size); 41 | } 42 | 43 | } // end namespace Eigen 44 | 45 | #endif // EIGEN2_MACROS_H 46 | -------------------------------------------------------------------------------- /src/Surfworks/Eigen/src/Eigen2Support/QR.h: -------------------------------------------------------------------------------- 1 | // This file is part of Eigen, a lightweight C++ template library 2 | // for linear algebra. 3 | // 4 | // Copyright (C) 2008 Gael Guennebaud 5 | // Copyright (C) 2011 Benoit Jacob 6 | // 7 | // This Source Code Form is subject to the terms of the Mozilla 8 | // Public License v. 2.0. If a copy of the MPL was not distributed 9 | // with this file, You can obtain one at http://mozilla.org/MPL/2.0/. 10 | 11 | #ifndef EIGEN2_QR_H 12 | #define EIGEN2_QR_H 13 | 14 | namespace Eigen { 15 | 16 | template 17 | class QR : public HouseholderQR 18 | { 19 | public: 20 | 21 | typedef HouseholderQR Base; 22 | typedef Block MatrixRBlockType; 23 | 24 | QR() : Base() {} 25 | 26 | template 27 | explicit QR(const T& t) : Base(t) {} 28 | 29 | template 30 | bool solve(const MatrixBase& b, ResultType *result) const 31 | { 32 | *result = static_cast(this)->solve(b); 33 | return true; 34 | } 35 | 36 | MatrixType matrixQ(void) const { 37 | MatrixType ret = MatrixType::Identity(this->rows(), this->cols()); 38 | ret = this->householderQ() * ret; 39 | return ret; 40 | } 41 | 42 | bool isFullRank() const { 43 | return true; 44 | } 45 | 46 | const TriangularView 47 | matrixR(void) const 48 | { 49 | int cols = this->cols(); 50 | return MatrixRBlockType(this->matrixQR(), 0, 0, cols, cols).template triangularView(); 51 | } 52 | }; 53 | 54 | /** \return the QR decomposition of \c *this. 55 | * 56 | * \sa class QR 57 | */ 58 | template 59 | const QR::PlainObject> 60 | MatrixBase::qr() const 61 | { 62 | return QR(eval()); 63 | } 64 | 65 | } // end namespace Eigen 66 | 67 | #endif // EIGEN2_QR_H 68 | -------------------------------------------------------------------------------- /src/Surfworks/Eigen/src/Eigen2Support/TriangularSolver.h: -------------------------------------------------------------------------------- 1 | // This file is part of Eigen, a lightweight C++ template library 2 | // for linear algebra. 3 | // 4 | // Copyright (C) 2010 Gael Guennebaud 5 | // 6 | // This Source Code Form is subject to the terms of the Mozilla 7 | // Public License v. 2.0. If a copy of the MPL was not distributed 8 | // with this file, You can obtain one at http://mozilla.org/MPL/2.0/. 9 | 10 | #ifndef EIGEN_TRIANGULAR_SOLVER2_H 11 | #define EIGEN_TRIANGULAR_SOLVER2_H 12 | 13 | namespace Eigen { 14 | 15 | const unsigned int UnitDiagBit = UnitDiag; 16 | const unsigned int SelfAdjointBit = SelfAdjoint; 17 | const unsigned int UpperTriangularBit = Upper; 18 | const unsigned int LowerTriangularBit = Lower; 19 | 20 | const unsigned int UpperTriangular = Upper; 21 | const unsigned int LowerTriangular = Lower; 22 | const unsigned int UnitUpperTriangular = UnitUpper; 23 | const unsigned int UnitLowerTriangular = UnitLower; 24 | 25 | template 26 | template 27 | typename ExpressionType::PlainObject 28 | Flagged::solveTriangular(const MatrixBase& other) const 29 | { 30 | return m_matrix.template triangularView().solve(other.derived()); 31 | } 32 | 33 | template 34 | template 35 | void Flagged::solveTriangularInPlace(const MatrixBase& other) const 36 | { 37 | m_matrix.template triangularView().solveInPlace(other.derived()); 38 | } 39 | 40 | } // end namespace Eigen 41 | 42 | #endif // EIGEN_TRIANGULAR_SOLVER2_H 43 | -------------------------------------------------------------------------------- /src/Surfworks/Eigen/src/Eigenvalues/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FILE(GLOB Eigen_EIGENVALUES_SRCS "*.h") 2 | 3 | INSTALL(FILES 4 | ${Eigen_EIGENVALUES_SRCS} 5 | DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/Eigenvalues COMPONENT Devel 6 | ) 7 | -------------------------------------------------------------------------------- /src/Surfworks/Eigen/src/Geometry/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FILE(GLOB Eigen_Geometry_SRCS "*.h") 2 | 3 | INSTALL(FILES 4 | ${Eigen_Geometry_SRCS} 5 | DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/Geometry COMPONENT Devel 6 | ) 7 | 8 | ADD_SUBDIRECTORY(arch) 9 | -------------------------------------------------------------------------------- /src/Surfworks/Eigen/src/Geometry/arch/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FILE(GLOB Eigen_Geometry_arch_SRCS "*.h") 2 | 3 | INSTALL(FILES 4 | ${Eigen_Geometry_arch_SRCS} 5 | DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/Geometry/arch COMPONENT Devel 6 | ) 7 | -------------------------------------------------------------------------------- /src/Surfworks/Eigen/src/Householder/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FILE(GLOB Eigen_Householder_SRCS "*.h") 2 | 3 | INSTALL(FILES 4 | ${Eigen_Householder_SRCS} 5 | DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/Householder COMPONENT Devel 6 | ) 7 | -------------------------------------------------------------------------------- /src/Surfworks/Eigen/src/IterativeLinearSolvers/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FILE(GLOB Eigen_IterativeLinearSolvers_SRCS "*.h") 2 | 3 | INSTALL(FILES 4 | ${Eigen_IterativeLinearSolvers_SRCS} 5 | DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/IterativeLinearSolvers COMPONENT Devel 6 | ) 7 | -------------------------------------------------------------------------------- /src/Surfworks/Eigen/src/Jacobi/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FILE(GLOB Eigen_Jacobi_SRCS "*.h") 2 | 3 | INSTALL(FILES 4 | ${Eigen_Jacobi_SRCS} 5 | DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/Jacobi COMPONENT Devel 6 | ) 7 | -------------------------------------------------------------------------------- /src/Surfworks/Eigen/src/LU/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FILE(GLOB Eigen_LU_SRCS "*.h") 2 | 3 | INSTALL(FILES 4 | ${Eigen_LU_SRCS} 5 | DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/LU COMPONENT Devel 6 | ) 7 | 8 | ADD_SUBDIRECTORY(arch) 9 | -------------------------------------------------------------------------------- /src/Surfworks/Eigen/src/LU/arch/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FILE(GLOB Eigen_LU_arch_SRCS "*.h") 2 | 3 | INSTALL(FILES 4 | ${Eigen_LU_arch_SRCS} 5 | DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/LU/arch COMPONENT Devel 6 | ) 7 | -------------------------------------------------------------------------------- /src/Surfworks/Eigen/src/MetisSupport/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FILE(GLOB Eigen_MetisSupport_SRCS "*.h") 2 | 3 | INSTALL(FILES 4 | ${Eigen_MetisSupport_SRCS} 5 | DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/MetisSupport COMPONENT Devel 6 | ) 7 | -------------------------------------------------------------------------------- /src/Surfworks/Eigen/src/OrderingMethods/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FILE(GLOB Eigen_OrderingMethods_SRCS "*.h") 2 | 3 | INSTALL(FILES 4 | ${Eigen_OrderingMethods_SRCS} 5 | DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/OrderingMethods COMPONENT Devel 6 | ) 7 | -------------------------------------------------------------------------------- /src/Surfworks/Eigen/src/PaStiXSupport/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FILE(GLOB Eigen_PastixSupport_SRCS "*.h") 2 | 3 | INSTALL(FILES 4 | ${Eigen_PastixSupport_SRCS} 5 | DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/PaStiXSupport COMPONENT Devel 6 | ) 7 | -------------------------------------------------------------------------------- /src/Surfworks/Eigen/src/PardisoSupport/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FILE(GLOB Eigen_PardisoSupport_SRCS "*.h") 2 | 3 | INSTALL(FILES 4 | ${Eigen_PardisoSupport_SRCS} 5 | DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/PardisoSupport COMPONENT Devel 6 | ) 7 | -------------------------------------------------------------------------------- /src/Surfworks/Eigen/src/QR/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FILE(GLOB Eigen_QR_SRCS "*.h") 2 | 3 | INSTALL(FILES 4 | ${Eigen_QR_SRCS} 5 | DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/QR COMPONENT Devel 6 | ) 7 | -------------------------------------------------------------------------------- /src/Surfworks/Eigen/src/SPQRSupport/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FILE(GLOB Eigen_SPQRSupport_SRCS "*.h") 2 | 3 | INSTALL(FILES 4 | ${Eigen_SPQRSupport_SRCS} 5 | DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/SPQRSupport/ COMPONENT Devel 6 | ) 7 | -------------------------------------------------------------------------------- /src/Surfworks/Eigen/src/SVD/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FILE(GLOB Eigen_SVD_SRCS "*.h") 2 | 3 | INSTALL(FILES 4 | ${Eigen_SVD_SRCS} 5 | DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/SVD COMPONENT Devel 6 | ) 7 | -------------------------------------------------------------------------------- /src/Surfworks/Eigen/src/SparseCholesky/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FILE(GLOB Eigen_SparseCholesky_SRCS "*.h") 2 | 3 | INSTALL(FILES 4 | ${Eigen_SparseCholesky_SRCS} 5 | DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/SparseCholesky COMPONENT Devel 6 | ) 7 | -------------------------------------------------------------------------------- /src/Surfworks/Eigen/src/SparseCore/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FILE(GLOB Eigen_SparseCore_SRCS "*.h") 2 | 3 | INSTALL(FILES 4 | ${Eigen_SparseCore_SRCS} 5 | DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/SparseCore COMPONENT Devel 6 | ) 7 | -------------------------------------------------------------------------------- /src/Surfworks/Eigen/src/SparseCore/SparseFuzzy.h: -------------------------------------------------------------------------------- 1 | // This file is part of Eigen, a lightweight C++ template library 2 | // for linear algebra. 3 | // 4 | // Copyright (C) 2008 Gael Guennebaud 5 | // 6 | // This Source Code Form is subject to the terms of the Mozilla 7 | // Public License v. 2.0. If a copy of the MPL was not distributed 8 | // with this file, You can obtain one at http://mozilla.org/MPL/2.0/. 9 | 10 | #ifndef EIGEN_SPARSE_FUZZY_H 11 | #define EIGEN_SPARSE_FUZZY_H 12 | 13 | // template 14 | // template 15 | // bool SparseMatrixBase::isApprox( 16 | // const OtherDerived& other, 17 | // typename NumTraits::Real prec 18 | // ) const 19 | // { 20 | // const typename internal::nested::type nested(derived()); 21 | // const typename internal::nested::type otherNested(other.derived()); 22 | // return (nested - otherNested).cwise().abs2().sum() 23 | // <= prec * prec * (std::min)(nested.cwise().abs2().sum(), otherNested.cwise().abs2().sum()); 24 | // } 25 | 26 | #endif // EIGEN_SPARSE_FUZZY_H 27 | -------------------------------------------------------------------------------- /src/Surfworks/Eigen/src/SparseCore/SparseRedux.h: -------------------------------------------------------------------------------- 1 | // This file is part of Eigen, a lightweight C++ template library 2 | // for linear algebra. 3 | // 4 | // Copyright (C) 2008 Gael Guennebaud 5 | // 6 | // This Source Code Form is subject to the terms of the Mozilla 7 | // Public License v. 2.0. If a copy of the MPL was not distributed 8 | // with this file, You can obtain one at http://mozilla.org/MPL/2.0/. 9 | 10 | #ifndef EIGEN_SPARSEREDUX_H 11 | #define EIGEN_SPARSEREDUX_H 12 | 13 | namespace Eigen { 14 | 15 | template 16 | typename internal::traits::Scalar 17 | SparseMatrixBase::sum() const 18 | { 19 | eigen_assert(rows()>0 && cols()>0 && "you are using a non initialized matrix"); 20 | Scalar res(0); 21 | for (Index j=0; j 28 | typename internal::traits >::Scalar 29 | SparseMatrix<_Scalar,_Options,_Index>::sum() const 30 | { 31 | eigen_assert(rows()>0 && cols()>0 && "you are using a non initialized matrix"); 32 | return Matrix::Map(&m_data.value(0), m_data.size()).sum(); 33 | } 34 | 35 | template 36 | typename internal::traits >::Scalar 37 | SparseVector<_Scalar,_Options,_Index>::sum() const 38 | { 39 | eigen_assert(rows()>0 && cols()>0 && "you are using a non initialized matrix"); 40 | return Matrix::Map(&m_data.value(0), m_data.size()).sum(); 41 | } 42 | 43 | } // end namespace Eigen 44 | 45 | #endif // EIGEN_SPARSEREDUX_H 46 | -------------------------------------------------------------------------------- /src/Surfworks/Eigen/src/SparseCore/SparseTranspose.h: -------------------------------------------------------------------------------- 1 | // This file is part of Eigen, a lightweight C++ template library 2 | // for linear algebra. 3 | // 4 | // Copyright (C) 2008-2009 Gael Guennebaud 5 | // 6 | // This Source Code Form is subject to the terms of the Mozilla 7 | // Public License v. 2.0. If a copy of the MPL was not distributed 8 | // with this file, You can obtain one at http://mozilla.org/MPL/2.0/. 9 | 10 | #ifndef EIGEN_SPARSETRANSPOSE_H 11 | #define EIGEN_SPARSETRANSPOSE_H 12 | 13 | namespace Eigen { 14 | 15 | template class TransposeImpl 16 | : public SparseMatrixBase > 17 | { 18 | typedef typename internal::remove_all::type _MatrixTypeNested; 19 | public: 20 | 21 | EIGEN_SPARSE_PUBLIC_INTERFACE(Transpose ) 22 | 23 | class InnerIterator; 24 | class ReverseInnerIterator; 25 | 26 | inline Index nonZeros() const { return derived().nestedExpression().nonZeros(); } 27 | }; 28 | 29 | // NOTE: VC10 trigger an ICE if don't put typename TransposeImpl:: in front of Index, 30 | // a typedef typename TransposeImpl::Index Index; 31 | // does not fix the issue. 32 | // An alternative is to define the nested class in the parent class itself. 33 | template class TransposeImpl::InnerIterator 34 | : public _MatrixTypeNested::InnerIterator 35 | { 36 | typedef typename _MatrixTypeNested::InnerIterator Base; 37 | typedef typename TransposeImpl::Index Index; 38 | public: 39 | 40 | EIGEN_STRONG_INLINE InnerIterator(const TransposeImpl& trans, typename TransposeImpl::Index outer) 41 | : Base(trans.derived().nestedExpression(), outer) 42 | {} 43 | Index row() const { return Base::col(); } 44 | Index col() const { return Base::row(); } 45 | }; 46 | 47 | template class TransposeImpl::ReverseInnerIterator 48 | : public _MatrixTypeNested::ReverseInnerIterator 49 | { 50 | typedef typename _MatrixTypeNested::ReverseInnerIterator Base; 51 | typedef typename TransposeImpl::Index Index; 52 | public: 53 | 54 | EIGEN_STRONG_INLINE ReverseInnerIterator(const TransposeImpl& xpr, typename TransposeImpl::Index outer) 55 | : Base(xpr.derived().nestedExpression(), outer) 56 | {} 57 | Index row() const { return Base::col(); } 58 | Index col() const { return Base::row(); } 59 | }; 60 | 61 | } // end namespace Eigen 62 | 63 | #endif // EIGEN_SPARSETRANSPOSE_H 64 | -------------------------------------------------------------------------------- /src/Surfworks/Eigen/src/SparseLU/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FILE(GLOB Eigen_SparseLU_SRCS "*.h") 2 | 3 | INSTALL(FILES 4 | ${Eigen_SparseLU_SRCS} 5 | DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/SparseLU COMPONENT Devel 6 | ) 7 | -------------------------------------------------------------------------------- /src/Surfworks/Eigen/src/SparseLU/SparseLU_Utils.h: -------------------------------------------------------------------------------- 1 | // This file is part of Eigen, a lightweight C++ template library 2 | // for linear algebra. 3 | // 4 | // Copyright (C) 2012 Désiré Nuentsa-Wakam 5 | // 6 | // This Source Code Form is subject to the terms of the Mozilla 7 | // Public License v. 2.0. If a copy of the MPL was not distributed 8 | // with this file, You can obtain one at http://mozilla.org/MPL/2.0/. 9 | 10 | 11 | #ifndef EIGEN_SPARSELU_UTILS_H 12 | #define EIGEN_SPARSELU_UTILS_H 13 | 14 | namespace Eigen { 15 | namespace internal { 16 | 17 | /** 18 | * \brief Count Nonzero elements in the factors 19 | */ 20 | template 21 | void SparseLUImpl::countnz(const Index n, Index& nnzL, Index& nnzU, GlobalLU_t& glu) 22 | { 23 | nnzL = 0; 24 | nnzU = (glu.xusub)(n); 25 | Index nsuper = (glu.supno)(n); 26 | Index jlen; 27 | Index i, j, fsupc; 28 | if (n <= 0 ) return; 29 | // For each supernode 30 | for (i = 0; i <= nsuper; i++) 31 | { 32 | fsupc = glu.xsup(i); 33 | jlen = glu.xlsub(fsupc+1) - glu.xlsub(fsupc); 34 | 35 | for (j = fsupc; j < glu.xsup(i+1); j++) 36 | { 37 | nnzL += jlen; 38 | nnzU += j - fsupc + 1; 39 | jlen--; 40 | } 41 | } 42 | } 43 | 44 | /** 45 | * \brief Fix up the data storage lsub for L-subscripts. 46 | * 47 | * It removes the subscripts sets for structural pruning, 48 | * and applies permutation to the remaining subscripts 49 | * 50 | */ 51 | template 52 | void SparseLUImpl::fixupL(const Index n, const IndexVector& perm_r, GlobalLU_t& glu) 53 | { 54 | Index fsupc, i, j, k, jstart; 55 | 56 | Index nextl = 0; 57 | Index nsuper = (glu.supno)(n); 58 | 59 | // For each supernode 60 | for (i = 0; i <= nsuper; i++) 61 | { 62 | fsupc = glu.xsup(i); 63 | jstart = glu.xlsub(fsupc); 64 | glu.xlsub(fsupc) = nextl; 65 | for (j = jstart; j < glu.xlsub(fsupc + 1); j++) 66 | { 67 | glu.lsub(nextl) = perm_r(glu.lsub(j)); // Now indexed into P*A 68 | nextl++; 69 | } 70 | for (k = fsupc+1; k < glu.xsup(i+1); k++) 71 | glu.xlsub(k) = nextl; // other columns in supernode i 72 | } 73 | 74 | glu.xlsub(n) = nextl; 75 | } 76 | 77 | } // end namespace internal 78 | 79 | } // end namespace Eigen 80 | #endif // EIGEN_SPARSELU_UTILS_H 81 | -------------------------------------------------------------------------------- /src/Surfworks/Eigen/src/SparseQR/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FILE(GLOB Eigen_SparseQR_SRCS "*.h") 2 | 3 | INSTALL(FILES 4 | ${Eigen_SparseQR_SRCS} 5 | DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/SparseQR/ COMPONENT Devel 6 | ) 7 | -------------------------------------------------------------------------------- /src/Surfworks/Eigen/src/StlSupport/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FILE(GLOB Eigen_StlSupport_SRCS "*.h") 2 | 3 | INSTALL(FILES 4 | ${Eigen_StlSupport_SRCS} 5 | DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/StlSupport COMPONENT Devel 6 | ) 7 | -------------------------------------------------------------------------------- /src/Surfworks/Eigen/src/SuperLUSupport/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FILE(GLOB Eigen_SuperLUSupport_SRCS "*.h") 2 | 3 | INSTALL(FILES 4 | ${Eigen_SuperLUSupport_SRCS} 5 | DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/SuperLUSupport COMPONENT Devel 6 | ) 7 | -------------------------------------------------------------------------------- /src/Surfworks/Eigen/src/UmfPackSupport/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FILE(GLOB Eigen_UmfPackSupport_SRCS "*.h") 2 | 3 | INSTALL(FILES 4 | ${Eigen_UmfPackSupport_SRCS} 5 | DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/UmfPackSupport COMPONENT Devel 6 | ) 7 | -------------------------------------------------------------------------------- /src/Surfworks/Eigen/src/misc/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FILE(GLOB Eigen_misc_SRCS "*.h") 2 | 3 | INSTALL(FILES 4 | ${Eigen_misc_SRCS} 5 | DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/misc COMPONENT Devel 6 | ) 7 | -------------------------------------------------------------------------------- /src/Surfworks/Eigen/src/plugins/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FILE(GLOB Eigen_plugins_SRCS "*.h") 2 | 3 | INSTALL(FILES 4 | ${Eigen_plugins_SRCS} 5 | DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/plugins COMPONENT Devel 6 | ) 7 | -------------------------------------------------------------------------------- /src/Surfworks/Eigen/src/plugins/CommonCwiseBinaryOps.h: -------------------------------------------------------------------------------- 1 | // This file is part of Eigen, a lightweight C++ template library 2 | // for linear algebra. 3 | // 4 | // Copyright (C) 2008-2009 Gael Guennebaud 5 | // Copyright (C) 2006-2008 Benoit Jacob 6 | // 7 | // This Source Code Form is subject to the terms of the Mozilla 8 | // Public License v. 2.0. If a copy of the MPL was not distributed 9 | // with this file, You can obtain one at http://mozilla.org/MPL/2.0/. 10 | 11 | // This file is a base class plugin containing common coefficient wise functions. 12 | 13 | /** \returns an expression of the difference of \c *this and \a other 14 | * 15 | * \note If you want to substract a given scalar from all coefficients, see Cwise::operator-(). 16 | * 17 | * \sa class CwiseBinaryOp, operator-=() 18 | */ 19 | EIGEN_MAKE_CWISE_BINARY_OP(operator-,internal::scalar_difference_op) 20 | 21 | /** \returns an expression of the sum of \c *this and \a other 22 | * 23 | * \note If you want to add a given scalar to all coefficients, see Cwise::operator+(). 24 | * 25 | * \sa class CwiseBinaryOp, operator+=() 26 | */ 27 | EIGEN_MAKE_CWISE_BINARY_OP(operator+,internal::scalar_sum_op) 28 | 29 | /** \returns an expression of a custom coefficient-wise operator \a func of *this and \a other 30 | * 31 | * The template parameter \a CustomBinaryOp is the type of the functor 32 | * of the custom operator (see class CwiseBinaryOp for an example) 33 | * 34 | * Here is an example illustrating the use of custom functors: 35 | * \include class_CwiseBinaryOp.cpp 36 | * Output: \verbinclude class_CwiseBinaryOp.out 37 | * 38 | * \sa class CwiseBinaryOp, operator+(), operator-(), cwiseProduct() 39 | */ 40 | template 41 | EIGEN_STRONG_INLINE const CwiseBinaryOp 42 | binaryExpr(const EIGEN_CURRENT_STORAGE_BASE_CLASS &other, const CustomBinaryOp& func = CustomBinaryOp()) const 43 | { 44 | return CwiseBinaryOp(derived(), other.derived(), func); 45 | } 46 | 47 | -------------------------------------------------------------------------------- /src/Surfworks/PreViewMeshQC/FEAutoMesher.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | class FEMesh; 4 | 5 | //----------------------------------------------------------------------------- 6 | class FEAutoMesher 7 | { 8 | public: 9 | FEAutoMesher(); 10 | void BuildMesh(FEMesh* pm); 11 | 12 | public: 13 | void AutoPartitionSurface(FEMesh& m); 14 | void AutoPartitionEdges(FEMesh& m); 15 | void AutoPartitionNodes(FEMesh& m); 16 | 17 | void Repartition(FEMesh& m); 18 | 19 | void SetSmoothingAngle(double w) { m_wsmooth = w; } 20 | double GetSmoothingAngle() { return m_wsmooth; } 21 | 22 | protected: 23 | void BuildFaces(FEMesh& m); 24 | void BuildEdges(FEMesh& m); 25 | 26 | protected: 27 | FEMesh* m_pm; 28 | 29 | double m_wsmooth; 30 | }; 31 | -------------------------------------------------------------------------------- /src/Surfworks/PreViewMeshQC/FECVDDecimationModifier.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "math3d.h" 3 | #include "FEMesh.h" 4 | #include 5 | using namespace std; 6 | 7 | //----------------------------------------------------------------------------- 8 | //! This class implements a modifier that coarses a plygonal mesh using an 9 | //! approximated centroidal voronoi diagram. 10 | class FECVDDecimationModifier 11 | { 12 | private: 13 | class Cluster 14 | { 15 | public: 16 | Cluster() : m_sgamma(vec3d(0,0,0)), m_srho(0.0) {} 17 | 18 | int faces() const { return (int) m_fid.size(); } 19 | 20 | public: 21 | vec3d m_sgamma; // sum of "gamma's" 22 | double m_srho; // sum of "rho's" 23 | vector m_fid; //face ids of the faces in this cluster 24 | 25 | }; 26 | 27 | struct EDGE 28 | { 29 | int face[2]; // the indices of the two faces sharing this edge 30 | int node[2]; // the nodes of the edge 31 | }; 32 | 33 | // a node which contains a list of clusters it belongs to 34 | class NODE 35 | { 36 | public: 37 | enum {MAX_CLUSTERS=23}; 38 | public: 39 | NODE() : nc(0){} 40 | 41 | bool AttachToCluster(int n); 42 | public: 43 | int c[MAX_CLUSTERS]; // cluster ID's 44 | int nc; // nr of clusters 45 | }; 46 | 47 | public: 48 | //! Constructor 49 | FECVDDecimationModifier(); 50 | 51 | //! Apply the decimation modifier 52 | FEMesh* Apply(FEMesh* pm); 53 | 54 | private: 55 | //! Initialize data structures 56 | bool Initialize(FEMesh* pm); 57 | 58 | //! Minimize the energy 59 | bool Minimize(FEMesh* pm); 60 | 61 | //! Triangulate 62 | FEMesh* Triangulate(FEMesh* pm); 63 | FEMesh* Triangulate2(FEMesh* pm); // uses hole-filling algorithm 64 | 65 | FEMesh* CalculateCVD(FEMesh* pm); 66 | void InterpolateShellThickness(FEMesh* pm); // to interpolate shell thickness 67 | 68 | //! swap triangles 69 | bool Swap(FEFace& face, int nface, int ncluster); 70 | 71 | public: 72 | double m_pct; //!< percentage of target number of clusters/vertices 73 | bool m_bcvd; 74 | double m_sel_pct; // percentage of clusters in selected region 75 | double m_gradient; //gradiant for curvature 76 | 77 | private: 78 | vector m_Cluster; 79 | vector m_tag; 80 | vector m_rho; // rho for all triangles 81 | vector m_gamma; // centroids of all triangles 82 | list m_Edge; // edge list 83 | vector m_st;//each node shell thickness 84 | //vector hashmap; //hashmap for selected faces 85 | }; 86 | -------------------------------------------------------------------------------- /src/Surfworks/PreViewMeshQC/FECoreMesh.cpp: -------------------------------------------------------------------------------- 1 | #include "FECoreMesh.h" 2 | 3 | //----------------------------------------------------------------------------- 4 | //! constructor 5 | FECoreMesh::FECoreMesh() 6 | { 7 | } 8 | 9 | //----------------------------------------------------------------------------- 10 | //! destructor 11 | FECoreMesh::~FECoreMesh() 12 | { 13 | } 14 | 15 | //----------------------------------------------------------------------------- 16 | //! This function checks if all elements are of the type specified in the argument 17 | bool FECoreMesh::IsType(int ntype) 18 | { 19 | int NE = Elements(); 20 | for (int i=0; i 4 | 5 | //----------------------------------------------------------------------------- 6 | //! This class defines a simple mesh structure that provides basic container 7 | //! services for storing mesh data. 8 | class FECoreMesh 9 | { 10 | public: 11 | //! constructor 12 | FECoreMesh(); 13 | 14 | //! destructor 15 | virtual ~FECoreMesh(); 16 | 17 | //! allocate space for mesh 18 | virtual void Create(int nodes, int elems, int faces = 0, int edges = 0) = 0; 19 | 20 | //! check the type of the mesh 21 | bool IsType(int ntype); 22 | 23 | public: // interface for accessing elements 24 | 25 | //! total number of elements 26 | virtual int Elements() const = 0; 27 | 28 | //! return reference to element 29 | virtual FEElement_& ElementRef(int n) = 0; 30 | 31 | //! return pointer to element 32 | virtual FEElement* ElementPtr(int n=0) = 0; 33 | 34 | public: // interface for accessing mesh items (except elements) 35 | 36 | int Nodes () const { return m_Node.size(); } 37 | int Edges () const { return m_Edge.size(); } 38 | int Faces () const { return m_Face.size(); } 39 | 40 | FENode& Node (int n) { return m_Node[n]; } 41 | FEEdge& Edge (int n) { return m_Edge[n]; } 42 | FEFace& Face (int n) { return m_Face[n]; } 43 | 44 | FENode* NodePtr (int n=0) { return ((n>=0) && (n<(int)m_Node.size())? &m_Node[n] : 0); } 45 | FEEdge* EdgePtr (int n=0) { return ((n>=0) && (n<(int)m_Edge.size())? &m_Edge[n] : 0); } 46 | FEFace* FacePtr (int n=0) { return ((n>=0) && (n<(int)m_Face.size())? &m_Face[n] : 0); } 47 | 48 | protected: 49 | std::vector m_Node; //!< FE nodes 50 | std::vector m_Edge; //!< FE edges 51 | std::vector m_Face; //!< FE faces 52 | }; 53 | -------------------------------------------------------------------------------- /src/Surfworks/PreViewMeshQC/FEFixMesh.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "FEMesh.h" 3 | 4 | //----------------------------------------------------------------------------- 5 | // This modifier implements a list of tools to fixing meshes 6 | class FEFixMesh 7 | { 8 | public: 9 | FEFixMesh() { m_ntask = 0; } 10 | FEMesh* Apply(FEMesh* pm); 11 | 12 | // set the task to do 13 | void SetTask(int n); 14 | //set max thickness in case 6 15 | void SetThickness(double m); 16 | 17 | public: 18 | FEMesh* RemoveDuplicateElements (FEMesh* pm); 19 | FEMesh* RemoveNonManifoldElements(FEMesh* pm); 20 | FEMesh* FixElementWinding (FEMesh* pm); 21 | FEMesh* FillAllHoles (FEMesh* pm); 22 | FEMesh* FixinvertedElements (FEMesh* pm); 23 | FEMesh* FixReferenceSurface (FEMesh* pm); 24 | FEMesh* InterpolateShellThickness(FEMesh* pm); 25 | private: 26 | int m_ntask; 27 | double m_limitThickness; 28 | }; 29 | -------------------------------------------------------------------------------- /src/Surfworks/PreViewMeshQC/FEMeshSmoothingModifier.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "math3d.h" 3 | 4 | class FEMesh; 5 | 6 | //----------------------------------------------------------------------------- 7 | //! This class implements a modifier that coarses a plygonal mesh using an 8 | //! approximated centroidal voronoi diagram. 9 | class FEMeshSmoothingModifier 10 | { 11 | 12 | public: 13 | //! Constructor 14 | FEMeshSmoothingModifier(); 15 | 16 | //! Apply the smoothing modifier 17 | FEMesh* Apply(FEMesh* pm); 18 | 19 | protected: 20 | double area_triangle(vec3d r[3]); 21 | double distance(vec3d x,vec3d y ); 22 | double random(); 23 | void Laplacian_Smoothing(FEMesh* pm,vector hashmap); 24 | void Laplacian_Smoothing2(FEMesh* pm,vector hashmap); 25 | void Taubin_Smoothing(FEMesh* pm,vector hashmap); 26 | void Crease_Enhancing_Diffusion(FEMesh* pm,vector hashmap); 27 | void Add_Noise(FEMesh* pm,vector hashmap); 28 | 29 | public: 30 | double m_threshold1; 31 | double m_threshold2; 32 | double m_iteration; 33 | int m_method; 34 | }; 35 | -------------------------------------------------------------------------------- /src/Surfworks/PreViewMeshQC/FENodeElementList.cpp: -------------------------------------------------------------------------------- 1 | #include "stdafx.h" 2 | #include "FENodeElementList.h" 3 | #include "FEMesh.h" 4 | 5 | FENodeElementList::FENodeElementList(FEMesh* pm) 6 | { 7 | m_pm = pm; 8 | } 9 | 10 | FENodeElementList::~FENodeElementList() 11 | { 12 | } 13 | 14 | void FENodeElementList::Build() 15 | { 16 | assert(m_pm); 17 | int i, j; 18 | int NN = m_pm->Nodes(); 19 | int NE = m_pm->Elements(); 20 | 21 | m_val.assign(NN, 0); 22 | int nsize = 0; 23 | for (i=0; iElement(i); 26 | int ne = el.Nodes(); 27 | for (j=0; jElement(i); 41 | int ne = el.Nodes(); 42 | for (j=0; j 4 | using namespace std; 5 | 6 | #include "FEMesh.h" 7 | 8 | class FENodeElementList 9 | { 10 | public: 11 | FENodeElementList(FEMesh* pm); 12 | ~FENodeElementList(); 13 | 14 | void Build(); 15 | 16 | int Valence(int n) { return m_val[n]; } 17 | FEElement* Element(int n, int j) { return m_pelem[m_off[n] + j]; } 18 | 19 | protected: 20 | FEMesh* m_pm; 21 | 22 | vector m_val; 23 | vector m_off; 24 | vector m_pelem; 25 | }; 26 | -------------------------------------------------------------------------------- /src/Surfworks/PreViewMeshQC/FENodeFaceList.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | using namespace std; 5 | 6 | #include "FEMesh.h" 7 | 8 | class FENodeFaceList 9 | { 10 | public: 11 | FENodeFaceList(FEMesh* pm); 12 | ~FENodeFaceList(void); 13 | 14 | void Build(); 15 | void BuildSorted(); 16 | 17 | int Nodes() { return (int) m_node.size(); } 18 | FENode& Node(int i) { return m_pm->Node(m_node[i]); } 19 | 20 | int Valence(int i) { return m_val[i]; } 21 | FEFace* Face(int n, int i) { return m_pface[m_off[n] + i]; } 22 | 23 | bool HasFace(int n, FEFace* pf); 24 | 25 | protected: 26 | void Sort(int node); 27 | 28 | protected: 29 | FEMesh* m_pm; 30 | vector m_node; 31 | vector m_val; 32 | vector m_pface; 33 | vector m_off; 34 | }; 35 | -------------------------------------------------------------------------------- /src/Surfworks/PreViewMeshQC/FENodeNodeList.cpp: -------------------------------------------------------------------------------- 1 | #include "stdafx.h" 2 | #include "FENodeNodeList.h" 3 | #include "FENodeElementList.h" 4 | #include "FEMesh.h" 5 | 6 | FENodeNodeList::FENodeNodeList(FEMesh* pm) 7 | { 8 | m_pm = pm; 9 | } 10 | 11 | FENodeNodeList::~FENodeNodeList() 12 | { 13 | } 14 | 15 | void FENodeNodeList::Build() 16 | { 17 | assert(m_pm); 18 | FENodeElementList NEL(m_pm); 19 | NEL.Build(); 20 | 21 | int i, j, k, n; 22 | int NN = m_pm->Nodes(); 23 | vector tag; tag.assign(NN, -1); 24 | 25 | m_val.resize(NN); 26 | int nsize = 0; 27 | 28 | for (i=0; iNodes(); 35 | for (k=0; km_node[k]; 38 | if ((nn != i) && (tag[nn] != i)) 39 | { 40 | tag[nn] = i; 41 | n++; 42 | } 43 | } 44 | 45 | m_val[i] = n; 46 | nsize += n; 47 | } 48 | } 49 | 50 | m_off.resize(NN); 51 | m_off[0] = 0; 52 | for (i=1; iNodes(); 66 | for (k=0; km_node[k]; 69 | if ((nn != i) && (tag[nn] != i)) 70 | { 71 | tag[nn] = i; 72 | m_node[noff + n] = nn; 73 | n++; 74 | } 75 | } 76 | } 77 | } 78 | } 79 | -------------------------------------------------------------------------------- /src/Surfworks/PreViewMeshQC/FENodeNodeList.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | using namespace std; 5 | 6 | class FEMesh; 7 | 8 | class FENodeNodeList 9 | { 10 | public: 11 | FENodeNodeList(FEMesh* pm); 12 | ~FENodeNodeList(); 13 | 14 | void Build(); 15 | 16 | int Valence(int n) { return m_val[n]; } 17 | int Node(int n, int j) { return m_node[ m_off[n] + j]; } 18 | 19 | protected: 20 | FEMesh* m_pm; 21 | 22 | vector m_val; 23 | vector m_off; 24 | vector m_node; 25 | }; 26 | -------------------------------------------------------------------------------- /src/Surfworks/PreViewMeshQC/FEVTKExport.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | class FEMesh; 4 | 5 | //----------------------------------------------------------------------------- 6 | struct VTKEXPORT 7 | { 8 | bool bshellthick; // shell thickness 9 | bool bscalar_data; //user scalar data 10 | }; 11 | 12 | 13 | class FEVTKExport 14 | { 15 | public: 16 | FEVTKExport(void); 17 | ~FEVTKExport(void); 18 | 19 | bool Export(FEMesh& mesh, const char* szfile); 20 | void SetOptions(VTKEXPORT o) { m_ops = o; } 21 | 22 | protected: 23 | void Close(); 24 | 25 | private: 26 | FILE* m_fp; 27 | VTKEXPORT m_ops; 28 | }; 29 | -------------------------------------------------------------------------------- /src/Surfworks/PreViewMeshQC/FEVTKImport.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include 3 | #include 4 | #include 5 | using namespace std; 6 | 7 | class FEMesh; 8 | 9 | class FEVTKimport 10 | { 11 | public: 12 | FEVTKimport(); 13 | ~FEVTKimport(void); 14 | 15 | FEMesh* Load(const char* szfile); 16 | 17 | protected: 18 | bool BuildMesh(); 19 | FEMesh* errf(const char* sz, ...); 20 | void Close(); 21 | 22 | private: 23 | FILE* m_fp; 24 | }; 25 | -------------------------------------------------------------------------------- /src/Surfworks/PreViewMeshQC/stdafx.h: -------------------------------------------------------------------------------- 1 | // stdafx.h : include file for standard system include files, 2 | // or project specific include files that are used frequently, but 3 | // are changed infrequently 4 | // 5 | 6 | #pragma once 7 | 8 | #include 9 | 10 | 11 | // TODO: reference additional headers your program requires here 12 | -------------------------------------------------------------------------------- /src/TinyXML/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | 2 | FILE(GLOB SRCS *.cpp) 3 | FILE(GLOB HDRS *.h) 4 | 5 | ADD_LIBRARY(TinyXML ${SRCS} ${HDRS}) -------------------------------------------------------------------------------- /src/TinyXML/tinyxmlerror.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | www.sourceforge.net/projects/tinyxml 3 | Original code (2.0 and earlier )copyright (c) 2000-2006 Lee Thomason (www.grinninglizard.com) 4 | 5 | This software is provided 'as-is', without any express or implied 6 | warranty. In no event will the authors be held liable for any 7 | damages arising from the use of this software. 8 | 9 | Permission is granted to anyone to use this software for any 10 | purpose, including commercial applications, and to alter it and 11 | redistribute it freely, subject to the following restrictions: 12 | 13 | 1. The origin of this software must not be misrepresented; you must 14 | not claim that you wrote the original software. If you use this 15 | software in a product, an acknowledgment in the product documentation 16 | would be appreciated but is not required. 17 | 18 | 2. Altered source versions must be plainly marked as such, and 19 | must not be misrepresented as being the original software. 20 | 21 | 3. This notice may not be removed or altered from any source 22 | distribution. 23 | */ 24 | 25 | #include "tinyxml.h" 26 | 27 | // The goal of the seperate error file is to make the first 28 | // step towards localization. tinyxml (currently) only supports 29 | // english error messages, but the could now be translated. 30 | // 31 | // It also cleans up the code a bit. 32 | // 33 | 34 | const char* TiXmlBase::errorString[ TiXmlBase::TIXML_ERROR_STRING_COUNT ] = 35 | { 36 | "No error", 37 | "Error", 38 | "Failed to open file", 39 | "Error parsing Element.", 40 | "Failed to read Element name", 41 | "Error reading Element value.", 42 | "Error reading Attributes.", 43 | "Error: empty tag.", 44 | "Error reading end tag.", 45 | "Error parsing Unknown.", 46 | "Error parsing Comment.", 47 | "Error parsing Declaration.", 48 | "Error document empty.", 49 | "Error null (0) or unexpected EOF found in input stream.", 50 | "Error parsing CDATA.", 51 | "Error when TiXmlDocument added to document, because TiXmlDocument can only be at the root.", 52 | }; 53 | -------------------------------------------------------------------------------- /user_guide/ShapeWorksStudioLab_v2.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SCIInstitute/ShapeWorksStudio/795388bdd6b167a61114b839208af185421c46df/user_guide/ShapeWorksStudioLab_v2.pdf -------------------------------------------------------------------------------- /user_guide/figs_v2/._add.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SCIInstitute/ShapeWorksStudio/795388bdd6b167a61114b839208af185421c46df/user_guide/figs_v2/._add.png -------------------------------------------------------------------------------- /user_guide/figs_v2/._ellipsoid_relative_weighting.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SCIInstitute/ShapeWorksStudio/795388bdd6b167a61114b839208af185421c46df/user_guide/figs_v2/._ellipsoid_relative_weighting.png -------------------------------------------------------------------------------- /user_guide/figs_v2/._filemenu.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SCIInstitute/ShapeWorksStudio/795388bdd6b167a61114b839208af185421c46df/user_guide/figs_v2/._filemenu.png -------------------------------------------------------------------------------- /user_guide/figs_v2/._groomed.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SCIInstitute/ShapeWorksStudio/795388bdd6b167a61114b839208af185421c46df/user_guide/figs_v2/._groomed.png -------------------------------------------------------------------------------- /user_guide/figs_v2/._grooming.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SCIInstitute/ShapeWorksStudio/795388bdd6b167a61114b839208af185421c46df/user_guide/figs_v2/._grooming.png -------------------------------------------------------------------------------- /user_guide/figs_v2/._import.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SCIInstitute/ShapeWorksStudio/795388bdd6b167a61114b839208af185421c46df/user_guide/figs_v2/._import.png -------------------------------------------------------------------------------- /user_guide/figs_v2/._qtwin.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SCIInstitute/ShapeWorksStudio/795388bdd6b167a61114b839208af185421c46df/user_guide/figs_v2/._qtwin.png -------------------------------------------------------------------------------- /user_guide/figs_v2/._reconstructed.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SCIInstitute/ShapeWorksStudio/795388bdd6b167a61114b839208af185421c46df/user_guide/figs_v2/._reconstructed.png -------------------------------------------------------------------------------- /user_guide/figs_v2/._reconstructing.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SCIInstitute/ShapeWorksStudio/795388bdd6b167a61114b839208af185421c46df/user_guide/figs_v2/._reconstructing.png -------------------------------------------------------------------------------- /user_guide/figs_v2/._remove.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SCIInstitute/ShapeWorksStudio/795388bdd6b167a61114b839208af185421c46df/user_guide/figs_v2/._remove.png -------------------------------------------------------------------------------- /user_guide/figs_v2/._render.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SCIInstitute/ShapeWorksStudio/795388bdd6b167a61114b839208af185421c46df/user_guide/figs_v2/._render.png -------------------------------------------------------------------------------- /user_guide/figs_v2/._save.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SCIInstitute/ShapeWorksStudio/795388bdd6b167a61114b839208af185421c46df/user_guide/figs_v2/._save.png -------------------------------------------------------------------------------- /user_guide/figs_v2/._set_dir.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SCIInstitute/ShapeWorksStudio/795388bdd6b167a61114b839208af185421c46df/user_guide/figs_v2/._set_dir.png -------------------------------------------------------------------------------- /user_guide/figs_v2/._spectrums.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SCIInstitute/ShapeWorksStudio/795388bdd6b167a61114b839208af185421c46df/user_guide/figs_v2/._spectrums.png -------------------------------------------------------------------------------- /user_guide/figs_v2/._zoom.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SCIInstitute/ShapeWorksStudio/795388bdd6b167a61114b839208af185421c46df/user_guide/figs_v2/._zoom.png -------------------------------------------------------------------------------- /user_guide/figs_v2/add.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SCIInstitute/ShapeWorksStudio/795388bdd6b167a61114b839208af185421c46df/user_guide/figs_v2/add.png -------------------------------------------------------------------------------- /user_guide/figs_v2/analysis.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SCIInstitute/ShapeWorksStudio/795388bdd6b167a61114b839208af185421c46df/user_guide/figs_v2/analysis.png -------------------------------------------------------------------------------- /user_guide/figs_v2/close.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SCIInstitute/ShapeWorksStudio/795388bdd6b167a61114b839208af185421c46df/user_guide/figs_v2/close.png -------------------------------------------------------------------------------- /user_guide/figs_v2/ellipsoid_images.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SCIInstitute/ShapeWorksStudio/795388bdd6b167a61114b839208af185421c46df/user_guide/figs_v2/ellipsoid_images.png -------------------------------------------------------------------------------- /user_guide/figs_v2/ellipsoid_relative_weighting.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SCIInstitute/ShapeWorksStudio/795388bdd6b167a61114b839208af185421c46df/user_guide/figs_v2/ellipsoid_relative_weighting.png -------------------------------------------------------------------------------- /user_guide/figs_v2/ellipsoid_w001_corr_qc_1.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SCIInstitute/ShapeWorksStudio/795388bdd6b167a61114b839208af185421c46df/user_guide/figs_v2/ellipsoid_w001_corr_qc_1.png -------------------------------------------------------------------------------- /user_guide/figs_v2/ellipsoid_w001_corr_qc_2.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SCIInstitute/ShapeWorksStudio/795388bdd6b167a61114b839208af185421c46df/user_guide/figs_v2/ellipsoid_w001_corr_qc_2.png -------------------------------------------------------------------------------- /user_guide/figs_v2/ellipsoid_w1_corr_qc_1.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SCIInstitute/ShapeWorksStudio/795388bdd6b167a61114b839208af185421c46df/user_guide/figs_v2/ellipsoid_w1_corr_qc_1.png -------------------------------------------------------------------------------- /user_guide/figs_v2/ellipsoid_w1_corr_qc_2.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SCIInstitute/ShapeWorksStudio/795388bdd6b167a61114b839208af185421c46df/user_guide/figs_v2/ellipsoid_w1_corr_qc_2.png -------------------------------------------------------------------------------- /user_guide/figs_v2/femur_analyze_mean.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SCIInstitute/ShapeWorksStudio/795388bdd6b167a61114b839208af185421c46df/user_guide/figs_v2/femur_analyze_mean.png -------------------------------------------------------------------------------- /user_guide/figs_v2/femur_analyze_mode1_mean.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SCIInstitute/ShapeWorksStudio/795388bdd6b167a61114b839208af185421c46df/user_guide/figs_v2/femur_analyze_mode1_mean.png -------------------------------------------------------------------------------- /user_guide/figs_v2/femur_analyze_mode1_neg2std.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SCIInstitute/ShapeWorksStudio/795388bdd6b167a61114b839208af185421c46df/user_guide/figs_v2/femur_analyze_mode1_neg2std.png -------------------------------------------------------------------------------- /user_guide/figs_v2/femur_analyze_mode1_pos2std.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SCIInstitute/ShapeWorksStudio/795388bdd6b167a61114b839208af185421c46df/user_guide/figs_v2/femur_analyze_mode1_pos2std.png -------------------------------------------------------------------------------- /user_guide/figs_v2/femur_analyze_mode2_neg2std.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SCIInstitute/ShapeWorksStudio/795388bdd6b167a61114b839208af185421c46df/user_guide/figs_v2/femur_analyze_mode2_neg2std.png -------------------------------------------------------------------------------- /user_guide/figs_v2/femur_analyze_mode2_pos2std.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SCIInstitute/ShapeWorksStudio/795388bdd6b167a61114b839208af185421c46df/user_guide/figs_v2/femur_analyze_mode2_pos2std.png -------------------------------------------------------------------------------- /user_guide/figs_v2/femur_analyze_mode3_neg2std.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SCIInstitute/ShapeWorksStudio/795388bdd6b167a61114b839208af185421c46df/user_guide/figs_v2/femur_analyze_mode3_neg2std.png -------------------------------------------------------------------------------- /user_guide/figs_v2/femur_analyze_mode3_pos2std.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SCIInstitute/ShapeWorksStudio/795388bdd6b167a61114b839208af185421c46df/user_guide/figs_v2/femur_analyze_mode3_pos2std.png -------------------------------------------------------------------------------- /user_guide/figs_v2/femur_analyze_mode4_mean.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SCIInstitute/ShapeWorksStudio/795388bdd6b167a61114b839208af185421c46df/user_guide/figs_v2/femur_analyze_mode4_mean.png -------------------------------------------------------------------------------- /user_guide/figs_v2/femur_analyze_mode4_neg2std.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SCIInstitute/ShapeWorksStudio/795388bdd6b167a61114b839208af185421c46df/user_guide/figs_v2/femur_analyze_mode4_neg2std.png -------------------------------------------------------------------------------- /user_guide/figs_v2/femur_analyze_mode4_pos2std.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SCIInstitute/ShapeWorksStudio/795388bdd6b167a61114b839208af185421c46df/user_guide/figs_v2/femur_analyze_mode4_pos2std.png -------------------------------------------------------------------------------- /user_guide/figs_v2/femur_data.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SCIInstitute/ShapeWorksStudio/795388bdd6b167a61114b839208af185421c46df/user_guide/figs_v2/femur_data.png -------------------------------------------------------------------------------- /user_guide/figs_v2/femur_groom.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SCIInstitute/ShapeWorksStudio/795388bdd6b167a61114b839208af185421c46df/user_guide/figs_v2/femur_groom.png -------------------------------------------------------------------------------- /user_guide/figs_v2/femur_optimize.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SCIInstitute/ShapeWorksStudio/795388bdd6b167a61114b839208af185421c46df/user_guide/figs_v2/femur_optimize.png -------------------------------------------------------------------------------- /user_guide/figs_v2/femur_optimize_reconstructed.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SCIInstitute/ShapeWorksStudio/795388bdd6b167a61114b839208af185421c46df/user_guide/figs_v2/femur_optimize_reconstructed.png -------------------------------------------------------------------------------- /user_guide/figs_v2/femur_optimize_reconstructed1.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SCIInstitute/ShapeWorksStudio/795388bdd6b167a61114b839208af185421c46df/user_guide/figs_v2/femur_optimize_reconstructed1.png -------------------------------------------------------------------------------- /user_guide/figs_v2/femur_optimize_reconstructed_hover1.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SCIInstitute/ShapeWorksStudio/795388bdd6b167a61114b839208af185421c46df/user_guide/figs_v2/femur_optimize_reconstructed_hover1.png -------------------------------------------------------------------------------- /user_guide/figs_v2/femur_optimize_reconstructed_hover2.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SCIInstitute/ShapeWorksStudio/795388bdd6b167a61114b839208af185421c46df/user_guide/figs_v2/femur_optimize_reconstructed_hover2.png -------------------------------------------------------------------------------- /user_guide/figs_v2/filemenu.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SCIInstitute/ShapeWorksStudio/795388bdd6b167a61114b839208af185421c46df/user_guide/figs_v2/filemenu.png -------------------------------------------------------------------------------- /user_guide/figs_v2/groom.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SCIInstitute/ShapeWorksStudio/795388bdd6b167a61114b839208af185421c46df/user_guide/figs_v2/groom.png -------------------------------------------------------------------------------- /user_guide/figs_v2/groomed.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SCIInstitute/ShapeWorksStudio/795388bdd6b167a61114b839208af185421c46df/user_guide/figs_v2/groomed.png -------------------------------------------------------------------------------- /user_guide/figs_v2/grooming.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SCIInstitute/ShapeWorksStudio/795388bdd6b167a61114b839208af185421c46df/user_guide/figs_v2/grooming.png -------------------------------------------------------------------------------- /user_guide/figs_v2/imagefiles.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SCIInstitute/ShapeWorksStudio/795388bdd6b167a61114b839208af185421c46df/user_guide/figs_v2/imagefiles.png -------------------------------------------------------------------------------- /user_guide/figs_v2/import.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SCIInstitute/ShapeWorksStudio/795388bdd6b167a61114b839208af185421c46df/user_guide/figs_v2/import.png -------------------------------------------------------------------------------- /user_guide/figs_v2/optimize.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SCIInstitute/ShapeWorksStudio/795388bdd6b167a61114b839208af185421c46df/user_guide/figs_v2/optimize.png -------------------------------------------------------------------------------- /user_guide/figs_v2/overview.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SCIInstitute/ShapeWorksStudio/795388bdd6b167a61114b839208af185421c46df/user_guide/figs_v2/overview.png -------------------------------------------------------------------------------- /user_guide/figs_v2/pref.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SCIInstitute/ShapeWorksStudio/795388bdd6b167a61114b839208af185421c46df/user_guide/figs_v2/pref.png -------------------------------------------------------------------------------- /user_guide/figs_v2/qtwin.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SCIInstitute/ShapeWorksStudio/795388bdd6b167a61114b839208af185421c46df/user_guide/figs_v2/qtwin.png -------------------------------------------------------------------------------- /user_guide/figs_v2/reconstructed.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SCIInstitute/ShapeWorksStudio/795388bdd6b167a61114b839208af185421c46df/user_guide/figs_v2/reconstructed.png -------------------------------------------------------------------------------- /user_guide/figs_v2/reconstructing.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SCIInstitute/ShapeWorksStudio/795388bdd6b167a61114b839208af185421c46df/user_guide/figs_v2/reconstructing.png -------------------------------------------------------------------------------- /user_guide/figs_v2/remove.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SCIInstitute/ShapeWorksStudio/795388bdd6b167a61114b839208af185421c46df/user_guide/figs_v2/remove.png -------------------------------------------------------------------------------- /user_guide/figs_v2/render.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SCIInstitute/ShapeWorksStudio/795388bdd6b167a61114b839208af185421c46df/user_guide/figs_v2/render.png -------------------------------------------------------------------------------- /user_guide/figs_v2/save.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SCIInstitute/ShapeWorksStudio/795388bdd6b167a61114b839208af185421c46df/user_guide/figs_v2/save.png -------------------------------------------------------------------------------- /user_guide/figs_v2/set_dir.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SCIInstitute/ShapeWorksStudio/795388bdd6b167a61114b839208af185421c46df/user_guide/figs_v2/set_dir.png -------------------------------------------------------------------------------- /user_guide/figs_v2/spectrums.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SCIInstitute/ShapeWorksStudio/795388bdd6b167a61114b839208af185421c46df/user_guide/figs_v2/spectrums.png -------------------------------------------------------------------------------- /user_guide/figs_v2/studio.bmp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SCIInstitute/ShapeWorksStudio/795388bdd6b167a61114b839208af185421c46df/user_guide/figs_v2/studio.bmp -------------------------------------------------------------------------------- /user_guide/figs_v2/studio.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SCIInstitute/ShapeWorksStudio/795388bdd6b167a61114b839208af185421c46df/user_guide/figs_v2/studio.png -------------------------------------------------------------------------------- /user_guide/figs_v2/torus_analyze_mean.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SCIInstitute/ShapeWorksStudio/795388bdd6b167a61114b839208af185421c46df/user_guide/figs_v2/torus_analyze_mean.png -------------------------------------------------------------------------------- /user_guide/figs_v2/torus_analyze_mode1_neg2std.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SCIInstitute/ShapeWorksStudio/795388bdd6b167a61114b839208af185421c46df/user_guide/figs_v2/torus_analyze_mode1_neg2std.png -------------------------------------------------------------------------------- /user_guide/figs_v2/torus_analyze_mode1_pos2std.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SCIInstitute/ShapeWorksStudio/795388bdd6b167a61114b839208af185421c46df/user_guide/figs_v2/torus_analyze_mode1_pos2std.png -------------------------------------------------------------------------------- /user_guide/figs_v2/torus_analyze_mode2_neg2std.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SCIInstitute/ShapeWorksStudio/795388bdd6b167a61114b839208af185421c46df/user_guide/figs_v2/torus_analyze_mode2_neg2std.png -------------------------------------------------------------------------------- /user_guide/figs_v2/torus_analyze_mode2_pos2std.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SCIInstitute/ShapeWorksStudio/795388bdd6b167a61114b839208af185421c46df/user_guide/figs_v2/torus_analyze_mode2_pos2std.png -------------------------------------------------------------------------------- /user_guide/figs_v2/torus_data.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SCIInstitute/ShapeWorksStudio/795388bdd6b167a61114b839208af185421c46df/user_guide/figs_v2/torus_data.png -------------------------------------------------------------------------------- /user_guide/figs_v2/torus_groom.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SCIInstitute/ShapeWorksStudio/795388bdd6b167a61114b839208af185421c46df/user_guide/figs_v2/torus_groom.png -------------------------------------------------------------------------------- /user_guide/figs_v2/torus_optimize_reconstructed.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SCIInstitute/ShapeWorksStudio/795388bdd6b167a61114b839208af185421c46df/user_guide/figs_v2/torus_optimize_reconstructed.png -------------------------------------------------------------------------------- /user_guide/figs_v2/torus_optimize_reconstructed_hover1.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SCIInstitute/ShapeWorksStudio/795388bdd6b167a61114b839208af185421c46df/user_guide/figs_v2/torus_optimize_reconstructed_hover1.png -------------------------------------------------------------------------------- /user_guide/figs_v2/torus_optimize_reconstructed_hover2.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SCIInstitute/ShapeWorksStudio/795388bdd6b167a61114b839208af185421c46df/user_guide/figs_v2/torus_optimize_reconstructed_hover2.png -------------------------------------------------------------------------------- /user_guide/figs_v2/zoom.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SCIInstitute/ShapeWorksStudio/795388bdd6b167a61114b839208af185421c46df/user_guide/figs_v2/zoom.png --------------------------------------------------------------------------------