comparison layer/Colour3DPlotLayer.cpp @ 509:f8b98f63f200

* Add Absolute plot scale, in colour 3d plot layer only for the moment

     if (!deflt) deflt = &garbage2;
 
     if (name == "Colour Scale") {
 
 	*min = 0;
-	*max = 2;
+	*max = 3;
         *deflt = (int)LinearScale;
 
 	val = (int)m_colourScale;
 
     } else if (name == "Colour") {

 	switch (value) {
 	default:
 	case 0: return tr("Linear");
 	case 1: return tr("Log");
 	case 2: return tr("+/-1");
+	case 3: return tr("Absolute");
 	}
     }
     return tr("<unknown>");
 }
 

 	switch (value) {
 	default:
 	case 0: setColourScale(LinearScale); break;
 	case 1: setColourScale(LogScale); break;
 	case 2: setColourScale(PlusMinusOneScale); break;
+	case 3: setColourScale(AbsoluteScale); break;
 	}
     } else if (name == "Colour") {
         setColourMap(value);
     } else if (name == "Normalize Columns") {
 	setNormalizeColumns(value ? true : false);

         if (m_colourScale == LogScale) {
             LogRange::mapRange(mmin, mmax);
         } else if (m_colourScale == PlusMinusOneScale) {
             mmin = -1.f;
             mmax = 1.f;
+        } else if (m_colourScale == AbsoluteScale) {
+            if (mmin < 0) {
+                if (fabsf(mmin) > fabsf(mmax)) mmax = fabsf(mmin);
+                else mmax = fabsf(mmax);
+                mmin = 0;
+            } else {
+                mmin = fabsf(mmin);
+                mmax = fabsf(mmax);
+            }
         }
     
         if (max == min) max = min + 1.0;
         if (mmax == mmin) mmax = mmin + 1.0;
     

     if (m_colourScale == LogScale) {
         LogRange::mapRange(min, max);
     } else if (m_colourScale == PlusMinusOneScale) {
         min = -1.f;
         max = 1.f;
+    } else if (m_colourScale == AbsoluteScale) {
+        if (min < 0) {
+            if (fabsf(min) > fabsf(max)) max = fabsf(min);
+            else max = fabsf(max);
+            min = 0;
+        } else {
+            min = fabsf(min);
+            max = fabsf(max);
+        }
     }
     
     if (max == min) max = min + 1.0;
     
     ColourMapper mapper(m_colourMap, 0.f, 255.f);

 
         if (m_colourScale == LogScale) {
             visibleMin = LogRange::map(visibleMin);
             visibleMax = LogRange::map(visibleMax);
             if (visibleMin > visibleMax) std::swap(visibleMin, visibleMax);
+        } else if (m_colourScale == AbsoluteScale) {
+            if (visibleMin < 0) {
+                if (fabsf(visibleMin) > fabsf(visibleMax)) visibleMax = fabsf(visibleMin);
+                else visibleMax = fabsf(visibleMax);
+                visibleMin = 0;
+            } else {
+                visibleMin = fabsf(visibleMin);
+                visibleMax = fabsf(visibleMax);
+            }
         }
     }
     
     if (visibleMin == visibleMax) visibleMax = visibleMin + 1;
 

                 value = values.at(y);
             }
 
             if (m_colourScale == LogScale) {
                 value = LogRange::map(value);
+            } else if (m_colourScale == AbsoluteScale) {
+                value = fabsf(value);
             }
             
             if (normalizeVisible) {
                 float norm = (value - visibleMin) / (visibleMax - visibleMin);
                 value = min + (max - min) * norm;

 	    if (sx >= 0 && sx < m_cache->width() &&
 		sy >= 0 && sy < m_cache->height()) {
 		pixel = m_cache->pixel(sx, sy);
 	    }
 
-	    QRect r(rx0, ry0 - h / (symax - symin) - 1,
+	    QRect r(rx0, ry0 - h / (symax - symin),
                     rw, h / (symax - symin) + 1);
 
             if (rw == 1) {
                 paint.setPen(pixel);
                 paint.setBrush(Qt::NoBrush);