comparison layer/Colour3DPlotLayer.cpp @ 130:10eec0da9efe last-cc-copyright

* Move the current DenseThreeDimensionalModel to EditableDenseThreeDimensionalModel
  (wow!), and make DTDM an abstract base
* Move FFTFuzzyAdapter to FFTModel as a new subclass of DTDM

 
     int x = pos.x();
     int y = pos.y();
 
     size_t modelStart = m_model->getStartFrame();
-    size_t modelWindow = m_model->getWindowSize();
-
-    int sx0 = modelWindow *
-	int((v->getFrameForX(x) - long(modelStart)) / long(modelWindow));
-    int sx1 = sx0 + modelWindow;
+    size_t modelResolution = m_model->getResolution();
+
+    int sx0 = modelResolution *
+	int((v->getFrameForX(x) - long(modelStart)) / long(modelResolution));
+    int sx1 = sx0 + modelResolution;
 
     float binHeight = float(v->height()) / m_model->getYBinCount();
     int sy = (v->height() - y) / binHeight;
 
     float value = m_model->getBinValue(sx0, sy);

 	return;
     }
 
     size_t modelStart = m_model->getStartFrame();
     size_t modelEnd = m_model->getEndFrame();
-    size_t modelWindow = m_model->getWindowSize();
-
-    size_t cacheWidth = (modelEnd - modelStart) / modelWindow + 1;
+    size_t modelResolution = m_model->getResolution();
+
+    size_t cacheWidth = (modelEnd - modelStart) / modelResolution + 1;
     size_t cacheHeight = m_model->getYBinCount();
 
     if (m_cache &&
 	(m_cache->width() != cacheWidth ||
 	 m_cache->height() != cacheHeight)) {

 	    m_cache->setColor(value, qRgba(colour.red(), colour.green(), colour.blue(), 80));
 	}
 
 	m_cache->fill(min);
 
-	for (size_t f = modelStart; f <= modelEnd; f += modelWindow) {
+	for (size_t f = modelStart; f <= modelEnd; f += modelResolution) {
 	
 	    values.clear();
 	    m_model->getBinValues(f, values);
 	    
 	    for (size_t y = 0; y < m_model->getYBinCount(); ++y) {

 
 		int pixel = int(((value - min) * 256) / (max - min));
                 if (pixel < 0) pixel = 0;
 		if (pixel > 255) pixel = 255;
 
-		m_cache->setPixel(f / modelWindow, y, pixel);
+		m_cache->setPixel(f / modelResolution, y, pixel);
 	    }
 	}
     }
 
     if (m_model->getYBinCount() >= v->height()) {

     //!!! Strictly speaking we want quite different paint mechanisms
     //for models that have more than one bin per pixel in either
     //direction.  This one is only really appropriate for models with
     //far fewer bins in both directions.
 
-    int sx0 = int((v->getFrameForX(x0) - long(modelStart)) / long(modelWindow));
-    int sx1 = int((v->getFrameForX(x1) - long(modelStart)) / long(modelWindow));
+    int sx0 = int((v->getFrameForX(x0) - long(modelStart)) / long(modelResolution));
+    int sx1 = int((v->getFrameForX(x1) - long(modelStart)) / long(modelResolution));
     int sw = sx1 - sx0;
     int sh = m_model->getYBinCount();
 
 #ifdef DEBUG_COLOUR_3D_PLOT_LAYER_PAINT
     std::cerr << "Colour3DPlotLayer::paint: w " << w << ", h " << h << ", sx0 " << sx0 << ", sx1 " << sx1 << ", sw " << sw << ", sh " << sh << std::endl;
-    std::cerr << "Colour3DPlotLayer: sample rate is " << m_model->getSampleRate() << ", window size " << m_model->getWindowSize() << std::endl;
+    std::cerr << "Colour3DPlotLayer: sample rate is " << m_model->getSampleRate() << ", resolution " << m_model->getResolution() << std::endl;
 #endif
 
     QPoint illuminatePos;
     bool illuminate = v->shouldIlluminateLocalFeatures(this, illuminatePos);
     char labelbuf[10];
 
     for (int sx = sx0 - 1; sx <= sx1; ++sx) {
 
-	int fx = sx * int(modelWindow);
-
-	if (fx + modelWindow < int(modelStart) ||
+	int fx = sx * int(modelResolution);
+
+	if (fx + modelResolution < int(modelStart) ||
 	    fx > int(modelEnd)) continue;
 
 	int rx0 = v->getXForFrame(fx + int(modelStart));
-	int rx1 = v->getXForFrame(fx + int(modelStart) + int(modelWindow));
+	int rx1 = v->getXForFrame(fx + int(modelStart) + int(modelResolution));
 
 	int w = rx1 - rx0;
 	if (w < 1) w = 1;
 
 	bool showLabel = (w > 10 &&

     long startFrame = v->getStartFrame();
     int zoomLevel = v->getZoomLevel();
 
     size_t modelStart = m_model->getStartFrame();
     size_t modelEnd = m_model->getEndFrame();
-    size_t modelWindow = m_model->getWindowSize();
+    size_t modelResolution = m_model->getResolution();
 
     int x0 = rect.left();
     int x1 = rect.right() + 1;
 
     int w = x1 - x0;

                 img.setPixel(x - x0, y, m_cache->color(0));
             }
             continue;
         }
 
-        float sx0 = (float(xf) - modelStart) / modelWindow;
-        float sx1 = (float(v->getFrameForX(x+1)) - modelStart) / modelWindow;
+        float sx0 = (float(xf) - modelStart) / modelResolution;
+        float sx1 = (float(v->getFrameForX(x+1)) - modelStart) / modelResolution;
             
         int sx0i = int(sx0 + 0.001);
         int sx1i = int(sx1);
 
         for (int y = 0; y < h; ++y) {

 {
     if (!m_model) {
 	return Layer::snapToFeatureFrame(v, frame, resolution, snap);
     }
 
-    resolution = m_model->getWindowSize();
+    resolution = m_model->getResolution();
     int left = (frame / resolution) * resolution;
     int right = left + resolution;
 
     switch (snap) {
     case SnapLeft:  frame = left;  break;