Libs/Particles/ReconstructSurface.h

Namespaces

Name
shapeworks User usage reporting (telemetry)

Classes

	Name
class	shapeworks::ReconstructSurface

Source code

```cpp

pragma once

include "Libs/Alignment/Transforms/itkThinPlateSplineKernelTransform2.h"

include "Libs/Alignment/Transforms/itkCompactlySupportedRBFSparseKernelTransform.h"

include "Mesh.h"

include

namespace shapeworks {

using ThinPlateSplineTransform = itk::ThinPlateSplineKernelTransform2; using RBFSSparseTransform = itk::CompactlySupportedRBFSparseKernelTransform;

template class ReconstructSurface { public: using TransformTypePtr = typename TransformType::Pointer; using PointSetType = typename TransformType::PointSetType; using PointIdType = typename PointSetType::PointIdentifier;

ReconstructSurface() = default; ReconstructSurface(const std::string &denseFile, const std::string &sparseFile, const std::string &goodPointsFile);

double computeAverageDistanceToNeighbors(vtkSmartPointer points, std::vector particlesIndices);

void checkMapping(TransformTypePtr transform, vtkSmartPointer sourcePoints, vtkSmartPointer targetPoints);

void generateWarpedMeshes(TransformTypePtr transform, vtkSmartPointer& outputMesh);

Mesh getMesh(PointArray localPoints);

vtkSmartPointer convertToImageCoordinates(vtkSmartPointer particles, const Vector& spacing, const Point3& origin);

int computeMedianShape(std::vector& shapeList);

void performKMeansClustering(std::vector worldPoints, int numberOfParticles, std::vector& centroidIndices);

Eigen::MatrixXd computeParticlesNormals(vtkSmartPointer particles, Image dt);

vtkSmartPointer getDenseMean(std::vector localPoints, std::vector worldPoints, std::vector distance_transform);

void computeDenseMean(std::vector localPoints, std::vector worldPoints, std::vector distanceTransform);

std::vector computeSparseMean(std::vector localPoints, Point3 commonCenter);

void writeMeanInfo();

void surface(const std::vector localPointsFiles);

void samplesAlongPCAModes(const std::vector worldPointsFiles);

void meanSurface(const std::vector distanceTransformFiles, const std::vector localPointsFiles, const std::vector worldPointsFiles);

// set operations //

void setOutPrefix(std::string prefix) { this->outPrefix = prefix; }

void setOutPath(std::string path) { this->outPath = path; }

void setDoProcrustes(bool doProcrusts) { this->doProcrustes = doProcrustes; }

void setDoProcrustesScaling(bool doProcrustsScaling) { this->doProcrustesScaling = doProcrustesScaling; }

void setPairwiseNormalsDiffForGoodBad(bool pairwiseNormalsDiffForGoodBad) { this->pairwiseNormalsDiffForGoodBad = pairwiseNormalsDiffForGoodBad; }

void setMeanBeforeWarp(bool meanBeforeWarp) { this->meanBeforeWarp = meanBeforeWarp; }

void setEnableOutput(bool enableOutput) { this->enableOutput = enableOutput; }

void setModeIndex(int modeIndex) { this->modeIndex = modeIndex; }

void setNumOfModes(int numOfModes) { this->numOfModes = numOfModes; }

void setNumOfSamplesPerMode(int numOfSamplesPerMode) { this->numOfSamplesPerMode = numOfSamplesPerMode; }

void setNumOfParticles(int numOfParticles) { this->numOfParticles = numOfParticles; }

void setNumOfClusters(int numOfClusters) { this->numOfClusters = numOfClusters; }

void setMaxStdDev(float maxStdDev) { this->maxStdDev = maxStdDev; }

void setMaxVarianceCaptured(float maxVarianceCaptured) { this->maxVarianceCaptured = maxVarianceCaptured; }

void setMaxAngleDegrees(float maxAngleDegrees) { this->maxAngleDegrees = maxAngleDegrees; }

private: float normalAngle = Pi/2.0; std::vector localPointsFiles; std::vector worldPointsFiles; std::vector distanceTransformFiles; vtkSmartPointer denseMean; vtkSmartPointer sparseMean; std::vector goodPoints; std::string outPrefix; std::string outPath; bool denseDone = true; bool doProcrustes; bool doProcrustesScaling; bool pairwiseNormalsDiffForGoodBad = false; bool meanBeforeWarp = true; bool enableOutput = true; int modeIndex = -1; int numOfModes = -1; int numOfSamplesPerMode = -1; int numOfParticles = -1; int numOfClusters = -1; float maxStdDev = 0; float maxVarianceCaptured = 0; float maxAngleDegrees = 0;

vtkSmartPointer setSparseMean(const std::string& sparsePath); std::vector setGoodPoints(const std::string& pointsPath); std::vector setLocalPointsFiles(const std::vector localPointsFiles); std::vector setWorldPointsFiles(const std::vector worldPointsFiles);

};

} // shapeworks ```

---

Updated on 2026-03-31 at 16:02:11 +0000