Restyle ParticleSystemEvaluation.

Author: akenmorris

Libs/Particles/ParticleSystemEvaluation.cpp

@@ -7,13 +7,14 @@
 
 namespace shapeworks {
 
-ParticleSystemEvaluation::ParticleSystemEvaluation(const std::vector<std::string>& _paths) {
-  if (_paths.empty()) {
+//---------------------------------------------------------------------------
+ParticleSystemEvaluation::ParticleSystemEvaluation(const std::vector<std::string>& paths) {
+  if (paths.empty()) {
     throw std::runtime_error("No filenames passed to readParticleSystemEvaluation");
   }
 
-  this->paths = _paths;
-  const int N = paths.size();
+  paths_ = paths;
+  const int N = paths_.size();
   const int VDimension = 3;
   assert(N > 0);
 
@@ -23,41 +24,44 @@ ParticleSystemEvaluation::ParticleSystemEvaluation(const std::vector<std::string
   //  huge problem for now because the particle files are quite small)
 
   // Read the first file to find dimensions
-  auto points0 = particles::read_particles_as_vector(paths[0]);
+  auto points0 = particles::read_particles_as_vector(paths_[0]);
   const int D = points0.size() * VDimension;
 
-  P.resize(D, N);
-  P.col(0) = Eigen::Map<const Eigen::VectorXd>((double*)points0.data(), D);
+  matrix_.resize(D, N);
+  matrix_.col(0) = Eigen::Map<const Eigen::VectorXd>((double*)points0.data(), D);
 
   for (int i = 1; i < N; i++) {
-    auto points = particles::read_particles_as_vector(paths[i]);
+    auto points = particles::read_particles_as_vector(paths_[i]);
     int count = points.size() * VDimension;
     if (count != D) {
       throw std::runtime_error("ParticleSystemEvaluation files must have the same number of particles");
     }
-    P.col(i) = Eigen::Map<const Eigen::VectorXd>((double*)points.data(), D);
+    matrix_.col(i) = Eigen::Map<const Eigen::VectorXd>((double*)points.data(), D);
   }
 }
 
-ParticleSystemEvaluation::ParticleSystemEvaluation(const Eigen::MatrixXd& matrix) { this->P = matrix; }
+//---------------------------------------------------------------------------
+ParticleSystemEvaluation::ParticleSystemEvaluation(const Eigen::MatrixXd& matrix) { matrix_ = matrix; }
 
+//---------------------------------------------------------------------------
 bool ParticleSystemEvaluation::ExactCompare(const ParticleSystemEvaluation& other) const {
-  if (P.rows() != other.P.rows() || P.cols() != other.P.cols()) {
+  if (matrix_.rows() != other.matrix_.rows() || matrix_.cols() != other.matrix_.cols()) {
     std::cerr << "Rows/Columns mismatch\n";
     return false;
   }
   bool same = true;
-  for (int r = 0; r < P.rows(); r++) {
-    for (int c = 0; c < P.cols(); c++) {
-      if (!epsEqual(P(r, c), other.P(r, c), 0.001)) {
-        std::cerr << "(" << r << "," << c << "): " << P(r, c) << " vs " << other.P(r, c) << "\n";
+  for (int r = 0; r < matrix_.rows(); r++) {
+    for (int c = 0; c < matrix_.cols(); c++) {
+      if (!epsEqual(matrix_(r, c), other.matrix_(r, c), 0.001)) {
+        std::cerr << "(" << r << "," << c << "): " << matrix_(r, c) << " vs " << other.matrix_(r, c) << "\n";
         same = false;
       }
     }
   }
   return same;
 }
 
+//---------------------------------------------------------------------------
 bool ParticleSystemEvaluation::EvaluationCompare(const ParticleSystemEvaluation& other) const {
   auto compactness1 = ShapeEvaluation::ComputeFullCompactness(*this);
   auto compactness2 = ShapeEvaluation::ComputeFullCompactness(other);
@@ -113,9 +117,12 @@ bool ParticleSystemEvaluation::EvaluationCompare(const ParticleSystemEvaluation&
   return good;
 }
 
+//---------------------------------------------------------------------------
 bool ParticleSystemEvaluation::ReadParticleFile(std::string filename, Eigen::VectorXd& points) {
   points = particles::read_particles(filename);
   return true;
 }
 
+//---------------------------------------------------------------------------
+
 }  // namespace shapeworks

Libs/Particles/ParticleSystemEvaluation.h

@@ -12,15 +12,15 @@ class ParticleSystemEvaluation {
   // Initialize particle system from eigen matrix (rows=dimensions, cols=num_samples)
   ParticleSystemEvaluation(const Eigen::MatrixXd& matrix);
 
-  const Eigen::MatrixXd& Particles() const { return P; };
+  const Eigen::MatrixXd& Particles() const { return matrix_; };
 
-  const std::vector<std::string>& Paths() const { return paths; }
+  const std::vector<std::string>& Paths() const { return paths_; }
 
   //! Number of samples
-  int N() const { return P.cols(); }
+  int N() const { return matrix_.cols(); }
 
   //! Dimensions (e.g. x/y/z * number of particles)
-  int D() const { return P.rows(); }
+  int D() const { return matrix_.rows(); }
 
   bool ExactCompare(const ParticleSystemEvaluation& other) const;
 
@@ -34,7 +34,7 @@ class ParticleSystemEvaluation {
   ParticleSystemEvaluation() {
   }  // only for use by SharedCommandData since a ParticleSystem should always be valid, never "empty"
 
-  Eigen::MatrixXd P;
-  std::vector<std::string> paths;
+  Eigen::MatrixXd matrix_;
+  std::vector<std::string> paths_;
 };
 }  // namespace shapeworks