Changeset 7e45c4 for src/Fragmentation/Exporters/SphericalPointDistribution.cpp

Timestamp:

Aug 20, 2014, 1:07:11 PM (11 years ago)

Author:

Frederik Heber <heber@…>

Children:

907198

Parents:

39616b

git-author:

Frederik Heber <heber@…> (07/21/14 08:20:10)

git-committer:

Frederik Heber <heber@…> (08/20/14 13:07:11)

Message:

tempcommit: Modified calculateErrorOfMatching() to measure error as deviation from mean rotation angle.

• distances between points for a equidistantly distributed set of points on a sphere does not sound too sensible. We now calculate the average rotation angle between the two given sets of points and give the L1/L2 error as maximum and squared average difference to this mean.

File:

• src/Fragmentation/Exporters/SphericalPointDistribution.cpp (modified) (1 diff)

src/Fragmentation/Exporters/SphericalPointDistribution.cpp

@@ -471 +471 @@
   std::pair<double, double> errors( std::make_pair( 0., 0. ) );
 
-  if (_Matching.size() > 1) {
-    LOG(5, "INFO: Matching is " << _Matching);
-
-    // calculate all pair-wise distances
-    IndexTupleList_t keys(_old.size(), IndexList_t() );
-    std::generate (keys.begin(), keys.end(), UniqueNumberList);
-
-    const DistanceArray_t firstdistances = calculatePairwiseDistances(_old, keys);
-    const DistanceArray_t seconddistances = calculatePairwiseDistances(_new, _Matching);
-
-    ASSERT( firstdistances.size() == seconddistances.size(),
-        "calculateL2ErrorOfMatching() - mismatch in pair-wise distance array sizes.");
-    DistanceArray_t::const_iterator firstiter = firstdistances.begin();
-    DistanceArray_t::const_iterator seconditer = seconddistances.begin();
-    for (;(firstiter != firstdistances.end()) && (seconditer != seconddistances.end());
-        ++firstiter, ++seconditer) {
-      const double gap = fabs(*firstiter - *seconditer);
-      // L1 error
-      if (errors.first < gap)
-        errors.first = gap;
-      // L2 error
-      errors.second += gap*gap;
-    }
-    // there is at least one distance, we've checked that before
-    errors.second *= 1./(double)firstdistances.size();
-  } else {
-    // check whether we have any zero centers: Combining points on new sphere may result
-    // in zero centers
-    for (SphericalPointDistribution::IndexTupleList_t::const_iterator iter = _Matching.begin();
-        iter != _Matching.end(); ++iter) {
-      if ((iter->size() != 1) && (calculateCenter( _new, *iter).IsZero())) {
-        errors.first = 2.;
-        errors.second = 2.;
-      }
-    }
-  }
+  // the error is the deviation from the mean angle
+  std::vector<double> distances;
+  double mean = 0.;
+  for (IndexTupleList_t::const_iterator matchingiter = _Matching.begin();
+      matchingiter != _Matching.end(); ++matchingiter) {
+    // calculate distance on surface as rotation angle
+    const Vector newcenter = calculateCenter(_new, *matchingiter);
+    const Vector &oldcenter = _old[std::distance(_Matching.begin(), matchingiter)];
+    Vector axis = newcenter;
+    axis.VectorProduct(oldcenter);
+    axis.Normalize();
+    const double distance = newcenter.Angle(oldcenter);
+    distances.push_back(distance);
+    mean += distance;
+  }
+  if (!_Matching.empty())
+    mean *= 1./(double)_Matching.size();
+  LOG(5, "DEBUG: Mean distance is " << mean << " for " << _Matching.size() << " points.");
+
+  // analyse errors
+  for (std::vector<double>::const_iterator iter = distances.begin();
+      iter != distances.end(); ++iter) {
+    const double difference = fabs(*iter - mean);
+    if (errors.first < difference) {
+      errors.first = difference;
+    }
+    errors.second += difference*difference;
+
+  }
+  errors.second = sqrt(errors.second);
+
+//  if (!_Matching.empty()) {
+//    // there is at least one distance, we've checked that before
+//    errors.second *= 1./(double)_Matching.size();
+//  }
+
+//  if (_Matching.size() > 1) {
+//    LOG(5, "INFO: Matching is " << _Matching);
+//
+//    // calculate all pair-wise distances
+//    IndexTupleList_t keys(_old.size(), IndexList_t() );
+//    std::generate (keys.begin(), keys.end(), UniqueNumberList);
+//
+//    const DistanceArray_t firstdistances = calculatePairwiseDistances(_old, keys);
+//    const DistanceArray_t seconddistances = calculatePairwiseDistances(_new, _Matching);
+//
+//    ASSERT( firstdistances.size() == seconddistances.size(),
+//        "calculateL2ErrorOfMatching() - mismatch in pair-wise distance array sizes.");
+//    DistanceArray_t::const_iterator firstiter = firstdistances.begin();
+//    DistanceArray_t::const_iterator seconditer = seconddistances.begin();
+//    for (;(firstiter != firstdistances.end()) && (seconditer != seconddistances.end());
+//        ++firstiter, ++seconditer) {
+//      const double gap = fabs(*firstiter - *seconditer);
+//      // L1 error
+//      if (errors.first < gap)
+//        errors.first = gap;
+//      // L2 error
+//      errors.second += gap*gap;
+//    }
+//    // there is at least one distance, we've checked that before
+//    errors.second *= 1./(double)firstdistances.size();
+//  } else {
+//    // check whether we have any zero centers: Combining points on new sphere may result
+//    // in zero centers
+//    for (SphericalPointDistribution::IndexTupleList_t::const_iterator iter = _Matching.begin();
+//        iter != _Matching.end(); ++iter) {
+//      if ((iter->size() != 1) && (calculateCenter( _new, *iter).IsZero())) {
+//        errors.first = 2.;
+//        errors.second = 2.;
+//      }
+//    }
+//  }
   LOG(4, "INFO: Resulting errors for matching (L1, L2): "
       << errors.first << "," << errors.second << ".");