comparison base/ColumnOp.h @ 1265:e2e66bfd4a88 3.0-integration

Start tests for ColumnOp (+ some resulting fixes)

 #define COLUMN_OP_H
 
 #include "BaseTypes.h"
 
 #include <cmath>
+#include <vector>
+#include <algorithm>
+#include <iostream>
 
 /**
  * Display normalization types for columns in e.g. grid plots.
  *
  * Max1 means to normalize to max value = 1.0.

 	}
 	return out;
     }
 
     /**
-     * Scale an FFT output by half the FFT size.
+     * Scale an FFT output downward by half the FFT size.
      */
     static Column fftScale(const Column &in, int fftSize) {
         return applyGain(in, 2.0 / fftSize);
     }
 
     /**
      * Determine whether an index points to a local peak.
      */
     static bool isPeak(const Column &in, int ix) {
-	
-	if (!in_range_for(in, ix-1)) return false;
-	if (!in_range_for(in, ix+1)) return false;
-	if (in[ix] < in[ix+1]) return false;
-	if (in[ix] < in[ix-1]) return false;
-	
+        if (!in_range_for(in, ix)) {
+            return false;
+        }
+        if (ix == 0) {
+            return in[0] >= in[1];
+        }
+        if (!in_range_for(in, ix+1)) {
+            return in[ix] > in[ix-1];
+        }
+	if (in[ix] < in[ix+1]) {
+            return false;
+        }
+	if (in[ix] <= in[ix-1]) {
+            return false;
+        }
 	return true;
     }
 
     /**
      * Return a column containing only the local peak values (all

      * Return a column normalized from the input column according to
      * the given normalization scheme.
      */
     static Column normalize(const Column &in, ColumnNormalization n) {
 
-	if (n == ColumnNormalization::None) {
+	if (n == ColumnNormalization::None || in.empty()) {
 	    return in;
 	}
 
         float scale = 1.f;
         

 
     /**
      * Distribute the given column into a target vector of a different
      * size, optionally using linear interpolation. The binfory vector
      * contains a mapping from y coordinate (i.e. index into the
-     * target vector) to bin (i.e. index into the source column).
+     * target vector) to bin (i.e. index into the source column). The
+     * source column ("in") may be a partial column; it's assumed to
+     * contain enough bins to span the destination range, starting
+     * with the bin of index minbin.
      */
     static Column distribute(const Column &in,
 			     int h,
 			     const std::vector<double> &binfory,
 			     int minbin,

 	    double sy0 = binfory[y] - minbin;
 	    double sy1 = sy0 + 1;
 	    if (y+1 < h) {
 		sy1 = binfory[y+1] - minbin;
 	    }
+
+            std::cerr << "y = " << y << " of " << h << ", sy0 = " << sy0 << ", sy1 = " << sy1 << std::endl;
         
 	    if (interpolate && fabs(sy1 - sy0) < 1.0) {
             
 		double centre = (sy0 + sy1) / 2;
 		double dist = (centre - 0.5) - rint(centre - 0.5);