comparison base/ColumnOp.h @ 1527:710e6250a401 zoom

Merge from default branch

  * Display normalization types for columns in e.g. grid plots.
  *
  * Max1 means to normalize to max value = 1.0.
  * Sum1 means to normalize to sum of values = 1.0.
  *
+ * Range01 means to normalize such that the max value = 1.0 and the
+ * min value (if different from the max value) = 0.0.
+ *
  * Hybrid means normalize to max = 1.0 and then multiply by
  * log10 of the max value, to retain some difference between
  * levels of neighbouring columns.
  *
  * Area normalization is handled separately.
  */
 enum class ColumnNormalization {
     None,
     Max1,
     Sum1,
+    Range01,
     Hybrid
 };
 
 /**
  * Class containing static functions for simple operations on data

     /**
      * Scale the given column using the given gain multiplier.
      */
     static Column applyGain(const Column &in, double gain) {
         if (gain == 1.0) return in;
-	Column out;
-	out.reserve(in.size());
-	for (auto v: in) out.push_back(float(v * gain));
-	return out;
+        Column out;
+        out.reserve(in.size());
+        for (auto v: in) out.push_back(float(v * gain));
+        return out;
+    }
+
+    /**
+     * Shift the values in the given column by the given offset.
+     */
+    static Column applyShift(const Column &in, float offset) {
+        if (offset == 0.f) return in;
+        Column out;
+        out.reserve(in.size());
+        for (auto v: in) out.push_back(v + offset);
+        return out;
     }
 
     /**
      * Scale an FFT output downward by half the FFT size.
      */

             return in[0] >= in[1];
         }
         if (!in_range_for(in, ix+1)) {
             return in[ix] > in[ix-1];
         }
-	if (in[ix] < in[ix+1]) {
+        if (in[ix] < in[ix+1]) {
             return false;
         }
-	if (in[ix] <= in[ix-1]) {
+        if (in[ix] <= in[ix-1]) {
             return false;
         }
-	return true;
+        return true;
     }
 
     /**
      * Return a column containing only the local peak values (all
      * others zero).

      * 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,
-			     bool interpolate);
+                             int h,
+                             const std::vector<double> &binfory,
+                             int minbin,
+                             bool interpolate);
 
 };
 
 #endif