comparison src/DistanceMetric.cpp @ 190:48f9c50587dc re-minimise

Print some info about scale range, so we can work out what scale factor to use

 #include <cmath>
 #include <iostream>
 
 using namespace std;
 
-//#define DEBUG_DISTANCE_METRIC 1
+#define DEBUG_DISTANCE_METRIC 1
 
 template <> uint8_t
 DistanceMetric::scaleIntoRange(double distance)
 {
     double scaled = m_params.scale * distance;
-    if (scaled < 0) scaled = 0;
-    if (scaled > 255) scaled = 255;
+    if (scaled < 0) {
+        scaled = 0;
+    }
+    if (scaled > MaxDistance) {
+        scaled = MaxDistance;
+        ++m_overcount;
+    }
     return uint8_t(scaled);
 }
 
 template <> float
 DistanceMetric::scaleIntoRange(double distance)

 {
     return distance;
 }
 
 DistanceMetric::DistanceMetric(Parameters params) :
-    m_params(params)
+    m_params(params),
+    m_max(0),
+    m_overcount(0)
 {
 #ifdef DEBUG_DISTANCE_METRIC
-    cerr << "*** DistanceMetric: norm = " << m_params.norm
+    cerr << "*** DistanceMetric: metric = " << m_params.metric
+         << ", norm = " << m_params.norm
+         << ", noise = " << m_params.noise
+         << ", scale = " << m_params.scale
          << endl;
+#endif
+}
+
+DistanceMetric::~DistanceMetric()
+{
+#ifdef DEBUG_DISTANCE_METRIC
+    cerr << "*** DistanceMetric::~DistanceMetric: metric = " << m_params.metric
+         << ", norm = " << m_params.norm
+         << ", noise = " << m_params.noise;
+#ifdef USE_COMPACT_TYPES
+    cerr << ", scale = " << m_params.scale;
+    cerr << "\n*** DistanceMetric::~DistanceMetric: max scaled value = "
+         << distance_print_t(m_max)
+         << ", " << m_overcount << " clipped" << endl;
+#else
+    cerr << ", no scaling";
+    cerr << "\n*** DistanceMetric::~DistanceMetric: max value = "
+         << distance_print_t(m_max)
+         << endl;
+#endif
 #endif
 }
 
 distance_t
 DistanceMetric::scaleValueIntoDistanceRange(double value)
 {
     return scaleIntoRange<distance_t>(value);
 }
-    
+
+distance_t
+DistanceMetric::scaleAndTally(double value)
+{
+    distance_t dist = scaleIntoRange<distance_t>(value);
+    if (dist > m_max) m_max = dist;
+    return dist;
+}
+
 distance_t
 DistanceMetric::calcDistance(const feature_t &f1,
 			     const feature_t &f2)
 {
     double d = 0;

         if (m_params.noise == AddNoise) {
             d += 1e-2;
         }
         if (d > 1.0) d = 1.0;
         
-        return scaleIntoRange<distance_t>(d); // normalisation param ignored
+        return scaleAndTally(d); // normalisation param ignored
     }
 
     if (m_params.metric == Manhattan) {
         for (int i = 0; i < featureSize; i++) {
             d += fabs(f1[i] - f2[i]);

         d += noise;
         sum += noise;
     }
     
     if (sum == 0) {
-        return scaleIntoRange<distance_t>(0);
+        return scaleAndTally(0);
     }
 
     double distance = 0;
 
     if (m_params.norm == NormaliseDistanceToSum) {

     } else {
 
         distance = d;
     }
     
-    return scaleIntoRange<distance_t>(distance);
+    return scaleAndTally(distance);
 }