annotate layer/SpectrogramLayer.cpp @ 1036:bc9b4a163926 spectrogram-minor-refactor

Fix cache validity boundary condition
author Chris Cannam
date Tue, 02 Feb 2016 14:28:00 +0000
parents 55ac6ac1982e
children 6f7a471826d1
rev   line source
Chris@58 1 /* -*- c-basic-offset: 4 indent-tabs-mode: nil -*- vi:set ts=8 sts=4 sw=4: */
Chris@0 2
Chris@0 3 /*
Chris@59 4 Sonic Visualiser
Chris@59 5 An audio file viewer and annotation editor.
Chris@59 6 Centre for Digital Music, Queen Mary, University of London.
Chris@484 7 This file copyright 2006-2009 Chris Cannam and QMUL.
Chris@0 8
Chris@59 9 This program is free software; you can redistribute it and/or
Chris@59 10 modify it under the terms of the GNU General Public License as
Chris@59 11 published by the Free Software Foundation; either version 2 of the
Chris@59 12 License, or (at your option) any later version. See the file
Chris@59 13 COPYING included with this distribution for more information.
Chris@0 14 */
Chris@0 15
Chris@0 16 #include "SpectrogramLayer.h"
Chris@0 17
Chris@128 18 #include "view/View.h"
Chris@0 19 #include "base/Profiler.h"
Chris@0 20 #include "base/AudioLevel.h"
Chris@0 21 #include "base/Window.h"
Chris@24 22 #include "base/Pitch.h"
Chris@118 23 #include "base/Preferences.h"
Chris@167 24 #include "base/RangeMapper.h"
Chris@253 25 #include "base/LogRange.h"
Chris@376 26 #include "widgets/CommandHistory.h"
Chris@376 27 #include "ColourMapper.h"
Chris@283 28 #include "ImageRegionFinder.h"
Chris@484 29 #include "data/model/Dense3DModelPeakCache.h"
Chris@690 30 #include "PianoScale.h"
Chris@0 31
Chris@0 32 #include <QPainter>
Chris@0 33 #include <QImage>
Chris@0 34 #include <QPixmap>
Chris@0 35 #include <QRect>
Chris@92 36 #include <QApplication>
Chris@178 37 #include <QMessageBox>
Chris@283 38 #include <QMouseEvent>
Chris@316 39 #include <QTextStream>
Chris@1017 40 #include <QSettings>
Chris@0 41
Chris@0 42 #include <iostream>
Chris@0 43
Chris@0 44 #include <cassert>
Chris@0 45 #include <cmath>
Chris@0 46
Chris@545 47 #ifndef __GNUC__
Chris@545 48 #include <alloca.h>
Chris@545 49 #endif
Chris@545 50
Chris@1025 51 #define DEBUG_SPECTROGRAM_REPAINT 1
Chris@1025 52
Chris@1025 53 using namespace std;
Chris@907 54
Chris@44 55 SpectrogramLayer::SpectrogramLayer(Configuration config) :
Chris@0 56 m_model(0),
Chris@0 57 m_channel(0),
Chris@0 58 m_windowSize(1024),
Chris@0 59 m_windowType(HanningWindow),
Chris@97 60 m_windowHopLevel(2),
Chris@109 61 m_zeroPadLevel(0),
Chris@107 62 m_fftSize(1024),
Chris@0 63 m_gain(1.0),
Chris@215 64 m_initialGain(1.0),
Chris@37 65 m_threshold(0.0),
Chris@215 66 m_initialThreshold(0.0),
Chris@9 67 m_colourRotation(0),
Chris@215 68 m_initialRotation(0),
Chris@119 69 m_minFrequency(10),
Chris@0 70 m_maxFrequency(8000),
Chris@135 71 m_initialMaxFrequency(8000),
Chris@0 72 m_colourScale(dBColourScale),
Chris@197 73 m_colourMap(0),
Chris@0 74 m_frequencyScale(LinearFrequencyScale),
Chris@37 75 m_binDisplay(AllBins),
Chris@862 76 m_normalization(NoNormalization),
Chris@133 77 m_lastEmittedZoomStep(-1),
Chris@390 78 m_synchronous(false),
Chris@608 79 m_haveDetailedScale(false),
Chris@193 80 m_exiting(false),
Chris@193 81 m_sliceableModel(0)
Chris@0 82 {
Chris@1017 83 QString colourConfigName = "spectrogram-colour";
Chris@1017 84 int colourConfigDefault = int(ColourMapper::Green);
Chris@1017 85
Chris@215 86 if (config == FullRangeDb) {
Chris@215 87 m_initialMaxFrequency = 0;
Chris@215 88 setMaxFrequency(0);
Chris@215 89 } else if (config == MelodicRange) {
Chris@0 90 setWindowSize(8192);
Chris@97 91 setWindowHopLevel(4);
Chris@215 92 m_initialMaxFrequency = 1500;
Chris@215 93 setMaxFrequency(1500);
Chris@215 94 setMinFrequency(40);
Chris@0 95 setColourScale(LinearColourScale);
Chris@215 96 setColourMap(ColourMapper::Sunset);
Chris@215 97 setFrequencyScale(LogFrequencyScale);
Chris@1017 98 colourConfigName = "spectrogram-melodic-colour";
Chris@1017 99 colourConfigDefault = int(ColourMapper::Sunset);
Chris@224 100 // setGain(20);
Chris@37 101 } else if (config == MelodicPeaks) {
Chris@37 102 setWindowSize(4096);
Chris@97 103 setWindowHopLevel(5);
Chris@135 104 m_initialMaxFrequency = 2000;
Chris@40 105 setMaxFrequency(2000);
Chris@37 106 setMinFrequency(40);
Chris@37 107 setFrequencyScale(LogFrequencyScale);
Chris@215 108 setColourScale(LinearColourScale);
Chris@37 109 setBinDisplay(PeakFrequencies);
Chris@862 110 setNormalization(NormalizeColumns);
Chris@1017 111 colourConfigName = "spectrogram-melodic-colour";
Chris@1017 112 colourConfigDefault = int(ColourMapper::Sunset);
Chris@0 113 }
Chris@110 114
Chris@1017 115 QSettings settings;
Chris@1017 116 settings.beginGroup("Preferences");
Chris@1017 117 setColourMap(settings.value(colourConfigName, colourConfigDefault).toInt());
Chris@1017 118 settings.endGroup();
Chris@1017 119
Chris@122 120 Preferences *prefs = Preferences::getInstance();
Chris@122 121 connect(prefs, SIGNAL(propertyChanged(PropertyContainer::PropertyName)),
Chris@122 122 this, SLOT(preferenceChanged(PropertyContainer::PropertyName)));
Chris@122 123 setWindowType(prefs->getWindowType());
Chris@122 124
Chris@197 125 initialisePalette();
Chris@0 126 }
Chris@0 127
Chris@0 128 SpectrogramLayer::~SpectrogramLayer()
Chris@0 129 {
Chris@130 130 invalidateFFTModels();
Chris@0 131 }
Chris@0 132
Chris@0 133 void
Chris@0 134 SpectrogramLayer::setModel(const DenseTimeValueModel *model)
Chris@0 135 {
Chris@682 136 // cerr << "SpectrogramLayer(" << this << "): setModel(" << model << ")" << endl;
Chris@34 137
Chris@110 138 if (model == m_model) return;
Chris@110 139
Chris@0 140 m_model = model;
Chris@130 141 invalidateFFTModels();
Chris@0 142
Chris@0 143 if (!m_model || !m_model->isOK()) return;
Chris@0 144
Chris@320 145 connectSignals(m_model);
Chris@0 146
Chris@0 147 connect(m_model, SIGNAL(modelChanged()), this, SLOT(cacheInvalid()));
Chris@906 148 connect(m_model, SIGNAL(modelChangedWithin(sv_frame_t, sv_frame_t)),
Chris@906 149 this, SLOT(cacheInvalid(sv_frame_t, sv_frame_t)));
Chris@0 150
Chris@0 151 emit modelReplaced();
Chris@110 152 }
Chris@115 153
Chris@0 154 Layer::PropertyList
Chris@0 155 SpectrogramLayer::getProperties() const
Chris@0 156 {
Chris@0 157 PropertyList list;
Chris@87 158 list.push_back("Colour");
Chris@87 159 list.push_back("Colour Scale");
Chris@87 160 list.push_back("Window Size");
Chris@97 161 list.push_back("Window Increment");
Chris@862 162 list.push_back("Normalization");
Chris@87 163 list.push_back("Bin Display");
Chris@87 164 list.push_back("Threshold");
Chris@87 165 list.push_back("Gain");
Chris@87 166 list.push_back("Colour Rotation");
Chris@153 167 // list.push_back("Min Frequency");
Chris@153 168 // list.push_back("Max Frequency");
Chris@87 169 list.push_back("Frequency Scale");
Chris@153 170 //// list.push_back("Zero Padding");
Chris@0 171 return list;
Chris@0 172 }
Chris@0 173
Chris@87 174 QString
Chris@87 175 SpectrogramLayer::getPropertyLabel(const PropertyName &name) const
Chris@87 176 {
Chris@87 177 if (name == "Colour") return tr("Colour");
Chris@87 178 if (name == "Colour Scale") return tr("Colour Scale");
Chris@87 179 if (name == "Window Size") return tr("Window Size");
Chris@112 180 if (name == "Window Increment") return tr("Window Overlap");
Chris@862 181 if (name == "Normalization") return tr("Normalization");
Chris@87 182 if (name == "Bin Display") return tr("Bin Display");
Chris@87 183 if (name == "Threshold") return tr("Threshold");
Chris@87 184 if (name == "Gain") return tr("Gain");
Chris@87 185 if (name == "Colour Rotation") return tr("Colour Rotation");
Chris@87 186 if (name == "Min Frequency") return tr("Min Frequency");
Chris@87 187 if (name == "Max Frequency") return tr("Max Frequency");
Chris@87 188 if (name == "Frequency Scale") return tr("Frequency Scale");
Chris@109 189 if (name == "Zero Padding") return tr("Smoothing");
Chris@87 190 return "";
Chris@87 191 }
Chris@87 192
Chris@335 193 QString
Chris@862 194 SpectrogramLayer::getPropertyIconName(const PropertyName &) const
Chris@335 195 {
Chris@335 196 return "";
Chris@335 197 }
Chris@335 198
Chris@0 199 Layer::PropertyType
Chris@0 200 SpectrogramLayer::getPropertyType(const PropertyName &name) const
Chris@0 201 {
Chris@87 202 if (name == "Gain") return RangeProperty;
Chris@87 203 if (name == "Colour Rotation") return RangeProperty;
Chris@87 204 if (name == "Threshold") return RangeProperty;
Chris@109 205 if (name == "Zero Padding") return ToggleProperty;
Chris@0 206 return ValueProperty;
Chris@0 207 }
Chris@0 208
Chris@0 209 QString
Chris@0 210 SpectrogramLayer::getPropertyGroupName(const PropertyName &name) const
Chris@0 211 {
Chris@153 212 if (name == "Bin Display" ||
Chris@153 213 name == "Frequency Scale") return tr("Bins");
Chris@87 214 if (name == "Window Size" ||
Chris@109 215 name == "Window Increment" ||
Chris@109 216 name == "Zero Padding") return tr("Window");
Chris@87 217 if (name == "Colour" ||
Chris@87 218 name == "Threshold" ||
Chris@87 219 name == "Colour Rotation") return tr("Colour");
Chris@862 220 if (name == "Normalization" ||
Chris@153 221 name == "Gain" ||
Chris@87 222 name == "Colour Scale") return tr("Scale");
Chris@0 223 return QString();
Chris@0 224 }
Chris@0 225
Chris@0 226 int
Chris@0 227 SpectrogramLayer::getPropertyRangeAndValue(const PropertyName &name,
Chris@216 228 int *min, int *max, int *deflt) const
Chris@0 229 {
Chris@216 230 int val = 0;
Chris@216 231
Chris@216 232 int garbage0, garbage1, garbage2;
Chris@55 233 if (!min) min = &garbage0;
Chris@55 234 if (!max) max = &garbage1;
Chris@216 235 if (!deflt) deflt = &garbage2;
Chris@10 236
Chris@87 237 if (name == "Gain") {
Chris@0 238
Chris@0 239 *min = -50;
Chris@0 240 *max = 50;
Chris@0 241
Chris@906 242 *deflt = int(lrint(log10(m_initialGain) * 20.0));
Chris@216 243 if (*deflt < *min) *deflt = *min;
Chris@216 244 if (*deflt > *max) *deflt = *max;
Chris@216 245
Chris@906 246 val = int(lrint(log10(m_gain) * 20.0));
Chris@216 247 if (val < *min) val = *min;
Chris@216 248 if (val > *max) val = *max;
Chris@0 249
Chris@87 250 } else if (name == "Threshold") {
Chris@37 251
Chris@37 252 *min = -50;
Chris@37 253 *max = 0;
Chris@37 254
Chris@906 255 *deflt = int(lrint(AudioLevel::multiplier_to_dB(m_initialThreshold)));
Chris@216 256 if (*deflt < *min) *deflt = *min;
Chris@216 257 if (*deflt > *max) *deflt = *max;
Chris@216 258
Chris@906 259 val = int(lrint(AudioLevel::multiplier_to_dB(m_threshold)));
Chris@216 260 if (val < *min) val = *min;
Chris@216 261 if (val > *max) val = *max;
Chris@37 262
Chris@87 263 } else if (name == "Colour Rotation") {
Chris@9 264
Chris@9 265 *min = 0;
Chris@9 266 *max = 256;
Chris@216 267 *deflt = m_initialRotation;
Chris@216 268
Chris@216 269 val = m_colourRotation;
Chris@9 270
Chris@87 271 } else if (name == "Colour Scale") {
Chris@0 272
Chris@0 273 *min = 0;
Chris@176 274 *max = 4;
Chris@216 275 *deflt = int(dBColourScale);
Chris@216 276
Chris@216 277 val = (int)m_colourScale;
Chris@0 278
Chris@87 279 } else if (name == "Colour") {
Chris@0 280
Chris@0 281 *min = 0;
Chris@196 282 *max = ColourMapper::getColourMapCount() - 1;
Chris@216 283 *deflt = 0;
Chris@216 284
Chris@216 285 val = m_colourMap;
Chris@0 286
Chris@87 287 } else if (name == "Window Size") {
Chris@0 288
Chris@0 289 *min = 0;
Chris@0 290 *max = 10;
Chris@216 291 *deflt = 5;
Chris@0 292
Chris@216 293 val = 0;
Chris@0 294 int ws = m_windowSize;
Chris@216 295 while (ws > 32) { ws >>= 1; val ++; }
Chris@0 296
Chris@97 297 } else if (name == "Window Increment") {
Chris@0 298
Chris@0 299 *min = 0;
Chris@97 300 *max = 5;
Chris@216 301 *deflt = 2;
Chris@216 302
Chris@216 303 val = m_windowHopLevel;
Chris@0 304
Chris@109 305 } else if (name == "Zero Padding") {
Chris@109 306
Chris@109 307 *min = 0;
Chris@109 308 *max = 1;
Chris@216 309 *deflt = 0;
Chris@109 310
Chris@216 311 val = m_zeroPadLevel > 0 ? 1 : 0;
Chris@109 312
Chris@87 313 } else if (name == "Min Frequency") {
Chris@37 314
Chris@37 315 *min = 0;
Chris@37 316 *max = 9;
Chris@216 317 *deflt = 1;
Chris@37 318
Chris@37 319 switch (m_minFrequency) {
Chris@216 320 case 0: default: val = 0; break;
Chris@216 321 case 10: val = 1; break;
Chris@216 322 case 20: val = 2; break;
Chris@216 323 case 40: val = 3; break;
Chris@216 324 case 100: val = 4; break;
Chris@216 325 case 250: val = 5; break;
Chris@216 326 case 500: val = 6; break;
Chris@216 327 case 1000: val = 7; break;
Chris@216 328 case 4000: val = 8; break;
Chris@216 329 case 10000: val = 9; break;
Chris@37 330 }
Chris@37 331
Chris@87 332 } else if (name == "Max Frequency") {
Chris@0 333
Chris@0 334 *min = 0;
Chris@0 335 *max = 9;
Chris@216 336 *deflt = 6;
Chris@0 337
Chris@0 338 switch (m_maxFrequency) {
Chris@216 339 case 500: val = 0; break;
Chris@216 340 case 1000: val = 1; break;
Chris@216 341 case 1500: val = 2; break;
Chris@216 342 case 2000: val = 3; break;
Chris@216 343 case 4000: val = 4; break;
Chris@216 344 case 6000: val = 5; break;
Chris@216 345 case 8000: val = 6; break;
Chris@216 346 case 12000: val = 7; break;
Chris@216 347 case 16000: val = 8; break;
Chris@216 348 default: val = 9; break;
Chris@0 349 }
Chris@0 350
Chris@87 351 } else if (name == "Frequency Scale") {
Chris@0 352
Chris@0 353 *min = 0;
Chris@0 354 *max = 1;
Chris@216 355 *deflt = int(LinearFrequencyScale);
Chris@216 356 val = (int)m_frequencyScale;
Chris@0 357
Chris@87 358 } else if (name == "Bin Display") {
Chris@35 359
Chris@35 360 *min = 0;
Chris@35 361 *max = 2;
Chris@216 362 *deflt = int(AllBins);
Chris@216 363 val = (int)m_binDisplay;
Chris@35 364
Chris@862 365 } else if (name == "Normalization") {
Chris@36 366
Chris@862 367 *min = 0;
Chris@862 368 *max = 3;
Chris@862 369 *deflt = int(NoNormalization);
Chris@862 370 val = (int)m_normalization;
Chris@120 371
Chris@0 372 } else {
Chris@216 373 val = Layer::getPropertyRangeAndValue(name, min, max, deflt);
Chris@0 374 }
Chris@0 375
Chris@216 376 return val;
Chris@0 377 }
Chris@0 378
Chris@0 379 QString
Chris@0 380 SpectrogramLayer::getPropertyValueLabel(const PropertyName &name,
Chris@9 381 int value) const
Chris@0 382 {
Chris@87 383 if (name == "Colour") {
Chris@196 384 return ColourMapper::getColourMapName(value);
Chris@0 385 }
Chris@87 386 if (name == "Colour Scale") {
Chris@0 387 switch (value) {
Chris@0 388 default:
Chris@37 389 case 0: return tr("Linear");
Chris@37 390 case 1: return tr("Meter");
Chris@215 391 case 2: return tr("dBV^2");
Chris@215 392 case 3: return tr("dBV");
Chris@119 393 case 4: return tr("Phase");
Chris@0 394 }
Chris@0 395 }
Chris@862 396 if (name == "Normalization") {
Chris@862 397 return ""; // icon only
Chris@862 398 }
Chris@87 399 if (name == "Window Size") {
Chris@0 400 return QString("%1").arg(32 << value);
Chris@0 401 }
Chris@97 402 if (name == "Window Increment") {
Chris@0 403 switch (value) {
Chris@0 404 default:
Chris@112 405 case 0: return tr("None");
Chris@112 406 case 1: return tr("25 %");
Chris@112 407 case 2: return tr("50 %");
Chris@112 408 case 3: return tr("75 %");
Chris@112 409 case 4: return tr("87.5 %");
Chris@112 410 case 5: return tr("93.75 %");
Chris@0 411 }
Chris@0 412 }
Chris@109 413 if (name == "Zero Padding") {
Chris@109 414 if (value == 0) return tr("None");
Chris@109 415 return QString("%1x").arg(value + 1);
Chris@109 416 }
Chris@87 417 if (name == "Min Frequency") {
Chris@37 418 switch (value) {
Chris@37 419 default:
Chris@38 420 case 0: return tr("No min");
Chris@37 421 case 1: return tr("10 Hz");
Chris@37 422 case 2: return tr("20 Hz");
Chris@37 423 case 3: return tr("40 Hz");
Chris@37 424 case 4: return tr("100 Hz");
Chris@37 425 case 5: return tr("250 Hz");
Chris@37 426 case 6: return tr("500 Hz");
Chris@37 427 case 7: return tr("1 KHz");
Chris@37 428 case 8: return tr("4 KHz");
Chris@37 429 case 9: return tr("10 KHz");
Chris@37 430 }
Chris@37 431 }
Chris@87 432 if (name == "Max Frequency") {
Chris@0 433 switch (value) {
Chris@0 434 default:
Chris@0 435 case 0: return tr("500 Hz");
Chris@0 436 case 1: return tr("1 KHz");
Chris@0 437 case 2: return tr("1.5 KHz");
Chris@0 438 case 3: return tr("2 KHz");
Chris@0 439 case 4: return tr("4 KHz");
Chris@0 440 case 5: return tr("6 KHz");
Chris@0 441 case 6: return tr("8 KHz");
Chris@0 442 case 7: return tr("12 KHz");
Chris@0 443 case 8: return tr("16 KHz");
Chris@38 444 case 9: return tr("No max");
Chris@0 445 }
Chris@0 446 }
Chris@87 447 if (name == "Frequency Scale") {
Chris@0 448 switch (value) {
Chris@0 449 default:
Chris@0 450 case 0: return tr("Linear");
Chris@0 451 case 1: return tr("Log");
Chris@0 452 }
Chris@0 453 }
Chris@87 454 if (name == "Bin Display") {
Chris@35 455 switch (value) {
Chris@35 456 default:
Chris@37 457 case 0: return tr("All Bins");
Chris@37 458 case 1: return tr("Peak Bins");
Chris@37 459 case 2: return tr("Frequencies");
Chris@35 460 }
Chris@35 461 }
Chris@0 462 return tr("<unknown>");
Chris@0 463 }
Chris@0 464
Chris@862 465 QString
Chris@862 466 SpectrogramLayer::getPropertyValueIconName(const PropertyName &name,
Chris@862 467 int value) const
Chris@862 468 {
Chris@862 469 if (name == "Normalization") {
Chris@862 470 switch(value) {
Chris@862 471 default:
Chris@862 472 case 0: return "normalise-none";
Chris@862 473 case 1: return "normalise-columns";
Chris@862 474 case 2: return "normalise";
Chris@862 475 case 3: return "normalise-hybrid";
Chris@862 476 }
Chris@862 477 }
Chris@862 478 return "";
Chris@862 479 }
Chris@862 480
Chris@167 481 RangeMapper *
Chris@167 482 SpectrogramLayer::getNewPropertyRangeMapper(const PropertyName &name) const
Chris@167 483 {
Chris@167 484 if (name == "Gain") {
Chris@167 485 return new LinearRangeMapper(-50, 50, -25, 25, tr("dB"));
Chris@167 486 }
Chris@167 487 if (name == "Threshold") {
Chris@167 488 return new LinearRangeMapper(-50, 0, -50, 0, tr("dB"));
Chris@167 489 }
Chris@167 490 return 0;
Chris@167 491 }
Chris@167 492
Chris@0 493 void
Chris@0 494 SpectrogramLayer::setProperty(const PropertyName &name, int value)
Chris@0 495 {
Chris@87 496 if (name == "Gain") {
Chris@906 497 setGain(float(pow(10, float(value)/20.0)));
Chris@87 498 } else if (name == "Threshold") {
Chris@37 499 if (value == -50) setThreshold(0.0);
Chris@906 500 else setThreshold(float(AudioLevel::dB_to_multiplier(value)));
Chris@87 501 } else if (name == "Colour Rotation") {
Chris@9 502 setColourRotation(value);
Chris@87 503 } else if (name == "Colour") {
Chris@197 504 setColourMap(value);
Chris@87 505 } else if (name == "Window Size") {
Chris@0 506 setWindowSize(32 << value);
Chris@97 507 } else if (name == "Window Increment") {
Chris@97 508 setWindowHopLevel(value);
Chris@109 509 } else if (name == "Zero Padding") {
Chris@109 510 setZeroPadLevel(value > 0.1 ? 3 : 0);
Chris@87 511 } else if (name == "Min Frequency") {
Chris@37 512 switch (value) {
Chris@37 513 default:
Chris@37 514 case 0: setMinFrequency(0); break;
Chris@37 515 case 1: setMinFrequency(10); break;
Chris@37 516 case 2: setMinFrequency(20); break;
Chris@37 517 case 3: setMinFrequency(40); break;
Chris@37 518 case 4: setMinFrequency(100); break;
Chris@37 519 case 5: setMinFrequency(250); break;
Chris@37 520 case 6: setMinFrequency(500); break;
Chris@37 521 case 7: setMinFrequency(1000); break;
Chris@37 522 case 8: setMinFrequency(4000); break;
Chris@37 523 case 9: setMinFrequency(10000); break;
Chris@37 524 }
Chris@133 525 int vs = getCurrentVerticalZoomStep();
Chris@133 526 if (vs != m_lastEmittedZoomStep) {
Chris@133 527 emit verticalZoomChanged();
Chris@133 528 m_lastEmittedZoomStep = vs;
Chris@133 529 }
Chris@87 530 } else if (name == "Max Frequency") {
Chris@0 531 switch (value) {
Chris@0 532 case 0: setMaxFrequency(500); break;
Chris@0 533 case 1: setMaxFrequency(1000); break;
Chris@0 534 case 2: setMaxFrequency(1500); break;
Chris@0 535 case 3: setMaxFrequency(2000); break;
Chris@0 536 case 4: setMaxFrequency(4000); break;
Chris@0 537 case 5: setMaxFrequency(6000); break;
Chris@0 538 case 6: setMaxFrequency(8000); break;
Chris@0 539 case 7: setMaxFrequency(12000); break;
Chris@0 540 case 8: setMaxFrequency(16000); break;
Chris@0 541 default:
Chris@0 542 case 9: setMaxFrequency(0); break;
Chris@0 543 }
Chris@133 544 int vs = getCurrentVerticalZoomStep();
Chris@133 545 if (vs != m_lastEmittedZoomStep) {
Chris@133 546 emit verticalZoomChanged();
Chris@133 547 m_lastEmittedZoomStep = vs;
Chris@133 548 }
Chris@87 549 } else if (name == "Colour Scale") {
Chris@0 550 switch (value) {
Chris@0 551 default:
Chris@0 552 case 0: setColourScale(LinearColourScale); break;
Chris@0 553 case 1: setColourScale(MeterColourScale); break;
Chris@215 554 case 2: setColourScale(dBSquaredColourScale); break;
Chris@215 555 case 3: setColourScale(dBColourScale); break;
Chris@119 556 case 4: setColourScale(PhaseColourScale); break;
Chris@0 557 }
Chris@87 558 } else if (name == "Frequency Scale") {
Chris@0 559 switch (value) {
Chris@0 560 default:
Chris@0 561 case 0: setFrequencyScale(LinearFrequencyScale); break;
Chris@0 562 case 1: setFrequencyScale(LogFrequencyScale); break;
Chris@0 563 }
Chris@87 564 } else if (name == "Bin Display") {
Chris@35 565 switch (value) {
Chris@35 566 default:
Chris@37 567 case 0: setBinDisplay(AllBins); break;
Chris@37 568 case 1: setBinDisplay(PeakBins); break;
Chris@37 569 case 2: setBinDisplay(PeakFrequencies); break;
Chris@35 570 }
Chris@862 571 } else if (name == "Normalization") {
Chris@862 572 switch (value) {
Chris@862 573 default:
Chris@862 574 case 0: setNormalization(NoNormalization); break;
Chris@862 575 case 1: setNormalization(NormalizeColumns); break;
Chris@862 576 case 2: setNormalization(NormalizeVisibleArea); break;
Chris@862 577 case 3: setNormalization(NormalizeHybrid); break;
Chris@862 578 }
Chris@0 579 }
Chris@0 580 }
Chris@0 581
Chris@0 582 void
Chris@478 583 SpectrogramLayer::invalidateImageCaches()
Chris@95 584 {
Chris@478 585 for (ViewImageCache::iterator i = m_imageCaches.begin();
Chris@478 586 i != m_imageCaches.end(); ++i) {
Chris@1030 587 i->second.invalidate();
Chris@95 588 }
Chris@95 589 }
Chris@95 590
Chris@95 591 void
Chris@122 592 SpectrogramLayer::preferenceChanged(PropertyContainer::PropertyName name)
Chris@122 593 {
Chris@587 594 SVDEBUG << "SpectrogramLayer::preferenceChanged(" << name << ")" << endl;
Chris@122 595
Chris@122 596 if (name == "Window Type") {
Chris@122 597 setWindowType(Preferences::getInstance()->getWindowType());
Chris@122 598 return;
Chris@122 599 }
Chris@490 600 if (name == "Spectrogram Y Smoothing") {
Chris@490 601 invalidateImageCaches();
Chris@490 602 invalidateMagnitudes();
Chris@490 603 emit layerParametersChanged();
Chris@490 604 }
Chris@490 605 if (name == "Spectrogram X Smoothing") {
Chris@478 606 invalidateImageCaches();
Chris@122 607 invalidateMagnitudes();
Chris@122 608 emit layerParametersChanged();
Chris@122 609 }
Chris@122 610 if (name == "Tuning Frequency") {
Chris@122 611 emit layerParametersChanged();
Chris@122 612 }
Chris@122 613 }
Chris@122 614
Chris@122 615 void
Chris@0 616 SpectrogramLayer::setChannel(int ch)
Chris@0 617 {
Chris@0 618 if (m_channel == ch) return;
Chris@0 619
Chris@478 620 invalidateImageCaches();
Chris@0 621 m_channel = ch;
Chris@130 622 invalidateFFTModels();
Chris@9 623
Chris@0 624 emit layerParametersChanged();
Chris@0 625 }
Chris@0 626
Chris@0 627 int
Chris@0 628 SpectrogramLayer::getChannel() const
Chris@0 629 {
Chris@0 630 return m_channel;
Chris@0 631 }
Chris@0 632
Chris@0 633 void
Chris@805 634 SpectrogramLayer::setWindowSize(int ws)
Chris@0 635 {
Chris@0 636 if (m_windowSize == ws) return;
Chris@0 637
Chris@478 638 invalidateImageCaches();
Chris@0 639
Chris@0 640 m_windowSize = ws;
Chris@109 641 m_fftSize = ws * (m_zeroPadLevel + 1);
Chris@0 642
Chris@130 643 invalidateFFTModels();
Chris@9 644
Chris@9 645 emit layerParametersChanged();
Chris@0 646 }
Chris@0 647
Chris@805 648 int
Chris@0 649 SpectrogramLayer::getWindowSize() const
Chris@0 650 {
Chris@0 651 return m_windowSize;
Chris@0 652 }
Chris@0 653
Chris@0 654 void
Chris@805 655 SpectrogramLayer::setWindowHopLevel(int v)
Chris@0 656 {
Chris@97 657 if (m_windowHopLevel == v) return;
Chris@0 658
Chris@478 659 invalidateImageCaches();
Chris@0 660
Chris@97 661 m_windowHopLevel = v;
Chris@0 662
Chris@130 663 invalidateFFTModels();
Chris@9 664
Chris@9 665 emit layerParametersChanged();
Chris@9 666
Chris@110 667 // fillCache();
Chris@0 668 }
Chris@0 669
Chris@805 670 int
Chris@97 671 SpectrogramLayer::getWindowHopLevel() const
Chris@0 672 {
Chris@97 673 return m_windowHopLevel;
Chris@0 674 }
Chris@0 675
Chris@0 676 void
Chris@805 677 SpectrogramLayer::setZeroPadLevel(int v)
Chris@109 678 {
Chris@109 679 if (m_zeroPadLevel == v) return;
Chris@109 680
Chris@478 681 invalidateImageCaches();
Chris@109 682
Chris@109 683 m_zeroPadLevel = v;
Chris@109 684 m_fftSize = m_windowSize * (v + 1);
Chris@110 685
Chris@130 686 invalidateFFTModels();
Chris@109 687
Chris@109 688 emit layerParametersChanged();
Chris@109 689 }
Chris@109 690
Chris@805 691 int
Chris@109 692 SpectrogramLayer::getZeroPadLevel() const
Chris@109 693 {
Chris@109 694 return m_zeroPadLevel;
Chris@109 695 }
Chris@109 696
Chris@109 697 void
Chris@0 698 SpectrogramLayer::setWindowType(WindowType w)
Chris@0 699 {
Chris@0 700 if (m_windowType == w) return;
Chris@0 701
Chris@478 702 invalidateImageCaches();
Chris@0 703
Chris@0 704 m_windowType = w;
Chris@110 705
Chris@130 706 invalidateFFTModels();
Chris@9 707
Chris@9 708 emit layerParametersChanged();
Chris@0 709 }
Chris@0 710
Chris@0 711 WindowType
Chris@0 712 SpectrogramLayer::getWindowType() const
Chris@0 713 {
Chris@0 714 return m_windowType;
Chris@0 715 }
Chris@0 716
Chris@0 717 void
Chris@0 718 SpectrogramLayer::setGain(float gain)
Chris@0 719 {
Chris@587 720 // SVDEBUG << "SpectrogramLayer::setGain(" << gain << ") (my gain is now "
Chris@585 721 // << m_gain << ")" << endl;
Chris@55 722
Chris@40 723 if (m_gain == gain) return;
Chris@0 724
Chris@478 725 invalidateImageCaches();
Chris@0 726
Chris@0 727 m_gain = gain;
Chris@0 728
Chris@9 729 emit layerParametersChanged();
Chris@0 730 }
Chris@0 731
Chris@0 732 float
Chris@0 733 SpectrogramLayer::getGain() const
Chris@0 734 {
Chris@0 735 return m_gain;
Chris@0 736 }
Chris@0 737
Chris@0 738 void
Chris@37 739 SpectrogramLayer::setThreshold(float threshold)
Chris@37 740 {
Chris@40 741 if (m_threshold == threshold) return;
Chris@37 742
Chris@478 743 invalidateImageCaches();
Chris@37 744
Chris@37 745 m_threshold = threshold;
Chris@37 746
Chris@37 747 emit layerParametersChanged();
Chris@37 748 }
Chris@37 749
Chris@37 750 float
Chris@37 751 SpectrogramLayer::getThreshold() const
Chris@37 752 {
Chris@37 753 return m_threshold;
Chris@37 754 }
Chris@37 755
Chris@37 756 void
Chris@805 757 SpectrogramLayer::setMinFrequency(int mf)
Chris@37 758 {
Chris@37 759 if (m_minFrequency == mf) return;
Chris@37 760
Chris@587 761 // SVDEBUG << "SpectrogramLayer::setMinFrequency: " << mf << endl;
Chris@187 762
Chris@478 763 invalidateImageCaches();
Chris@119 764 invalidateMagnitudes();
Chris@37 765
Chris@37 766 m_minFrequency = mf;
Chris@37 767
Chris@37 768 emit layerParametersChanged();
Chris@37 769 }
Chris@37 770
Chris@805 771 int
Chris@37 772 SpectrogramLayer::getMinFrequency() const
Chris@37 773 {
Chris@37 774 return m_minFrequency;
Chris@37 775 }
Chris@37 776
Chris@37 777 void
Chris@805 778 SpectrogramLayer::setMaxFrequency(int mf)
Chris@0 779 {
Chris@0 780 if (m_maxFrequency == mf) return;
Chris@0 781
Chris@587 782 // SVDEBUG << "SpectrogramLayer::setMaxFrequency: " << mf << endl;
Chris@187 783
Chris@478 784 invalidateImageCaches();
Chris@119 785 invalidateMagnitudes();
Chris@0 786
Chris@0 787 m_maxFrequency = mf;
Chris@0 788
Chris@9 789 emit layerParametersChanged();
Chris@0 790 }
Chris@0 791
Chris@805 792 int
Chris@0 793 SpectrogramLayer::getMaxFrequency() const
Chris@0 794 {
Chris@0 795 return m_maxFrequency;
Chris@0 796 }
Chris@0 797
Chris@0 798 void
Chris@9 799 SpectrogramLayer::setColourRotation(int r)
Chris@9 800 {
Chris@478 801 invalidateImageCaches();
Chris@9 802
Chris@9 803 if (r < 0) r = 0;
Chris@9 804 if (r > 256) r = 256;
Chris@9 805 int distance = r - m_colourRotation;
Chris@9 806
Chris@9 807 if (distance != 0) {
Chris@197 808 rotatePalette(-distance);
Chris@9 809 m_colourRotation = r;
Chris@9 810 }
Chris@9 811
Chris@9 812 emit layerParametersChanged();
Chris@9 813 }
Chris@9 814
Chris@9 815 void
Chris@0 816 SpectrogramLayer::setColourScale(ColourScale colourScale)
Chris@0 817 {
Chris@0 818 if (m_colourScale == colourScale) return;
Chris@0 819
Chris@478 820 invalidateImageCaches();
Chris@0 821
Chris@0 822 m_colourScale = colourScale;
Chris@0 823
Chris@9 824 emit layerParametersChanged();
Chris@0 825 }
Chris@0 826
Chris@0 827 SpectrogramLayer::ColourScale
Chris@0 828 SpectrogramLayer::getColourScale() const
Chris@0 829 {
Chris@0 830 return m_colourScale;
Chris@0 831 }
Chris@0 832
Chris@0 833 void
Chris@197 834 SpectrogramLayer::setColourMap(int map)
Chris@0 835 {
Chris@197 836 if (m_colourMap == map) return;
Chris@0 837
Chris@478 838 invalidateImageCaches();
Chris@0 839
Chris@197 840 m_colourMap = map;
Chris@197 841 initialisePalette();
Chris@9 842
Chris@0 843 emit layerParametersChanged();
Chris@0 844 }
Chris@0 845
Chris@196 846 int
Chris@197 847 SpectrogramLayer::getColourMap() const
Chris@0 848 {
Chris@197 849 return m_colourMap;
Chris@0 850 }
Chris@0 851
Chris@0 852 void
Chris@0 853 SpectrogramLayer::setFrequencyScale(FrequencyScale frequencyScale)
Chris@0 854 {
Chris@0 855 if (m_frequencyScale == frequencyScale) return;
Chris@0 856
Chris@478 857 invalidateImageCaches();
Chris@0 858 m_frequencyScale = frequencyScale;
Chris@9 859
Chris@9 860 emit layerParametersChanged();
Chris@0 861 }
Chris@0 862
Chris@0 863 SpectrogramLayer::FrequencyScale
Chris@0 864 SpectrogramLayer::getFrequencyScale() const
Chris@0 865 {
Chris@0 866 return m_frequencyScale;
Chris@0 867 }
Chris@0 868
Chris@0 869 void
Chris@37 870 SpectrogramLayer::setBinDisplay(BinDisplay binDisplay)
Chris@35 871 {
Chris@37 872 if (m_binDisplay == binDisplay) return;
Chris@35 873
Chris@478 874 invalidateImageCaches();
Chris@37 875 m_binDisplay = binDisplay;
Chris@35 876
Chris@35 877 emit layerParametersChanged();
Chris@35 878 }
Chris@35 879
Chris@37 880 SpectrogramLayer::BinDisplay
Chris@37 881 SpectrogramLayer::getBinDisplay() const
Chris@35 882 {
Chris@37 883 return m_binDisplay;
Chris@35 884 }
Chris@35 885
Chris@35 886 void
Chris@862 887 SpectrogramLayer::setNormalization(Normalization n)
Chris@36 888 {
Chris@862 889 if (m_normalization == n) return;
Chris@36 890
Chris@478 891 invalidateImageCaches();
Chris@119 892 invalidateMagnitudes();
Chris@862 893 m_normalization = n;
Chris@36 894
Chris@36 895 emit layerParametersChanged();
Chris@36 896 }
Chris@36 897
Chris@862 898 SpectrogramLayer::Normalization
Chris@862 899 SpectrogramLayer::getNormalization() const
Chris@36 900 {
Chris@862 901 return m_normalization;
Chris@36 902 }
Chris@36 903
Chris@36 904 void
Chris@918 905 SpectrogramLayer::setLayerDormant(const LayerGeometryProvider *v, bool dormant)
Chris@29 906 {
Chris@33 907 if (dormant) {
Chris@33 908
Chris@331 909 #ifdef DEBUG_SPECTROGRAM_REPAINT
Chris@985 910 cerr << "SpectrogramLayer::setLayerDormant(" << dormant << ")"
Chris@585 911 << endl;
Chris@331 912 #endif
Chris@331 913
Chris@131 914 if (isLayerDormant(v)) {
Chris@131 915 return;
Chris@131 916 }
Chris@131 917
Chris@131 918 Layer::setLayerDormant(v, true);
Chris@33 919
Chris@920 920 const View *view = v->getView();
Chris@920 921
Chris@478 922 invalidateImageCaches();
Chris@988 923
Chris@1030 924 m_imageCaches.erase(view->getId());
Chris@1030 925
Chris@1030 926 if (m_fftModels.find(view->getId()) != m_fftModels.end()) {
Chris@1030 927
Chris@1030 928 if (m_sliceableModel == m_fftModels[view->getId()]) {
Chris@193 929 bool replaced = false;
Chris@193 930 for (ViewFFTMap::iterator i = m_fftModels.begin();
Chris@193 931 i != m_fftModels.end(); ++i) {
Chris@985 932 if (i->second != m_sliceableModel) {
Chris@985 933 emit sliceableModelReplaced(m_sliceableModel, i->second);
Chris@193 934 replaced = true;
Chris@193 935 break;
Chris@193 936 }
Chris@193 937 }
Chris@193 938 if (!replaced) emit sliceableModelReplaced(m_sliceableModel, 0);
Chris@193 939 }
Chris@193 940
Chris@1030 941 delete m_fftModels[view->getId()];
Chris@1030 942 m_fftModels.erase(view->getId());
Chris@1030 943
Chris@1030 944 delete m_peakCaches[view->getId()];
Chris@1030 945 m_peakCaches.erase(view->getId());
Chris@114 946 }
Chris@33 947
Chris@33 948 } else {
Chris@33 949
Chris@131 950 Layer::setLayerDormant(v, false);
Chris@33 951 }
Chris@29 952 }
Chris@29 953
Chris@29 954 void
Chris@0 955 SpectrogramLayer::cacheInvalid()
Chris@0 956 {
Chris@391 957 #ifdef DEBUG_SPECTROGRAM_REPAINT
Chris@985 958 cerr << "SpectrogramLayer::cacheInvalid()" << endl;
Chris@391 959 #endif
Chris@391 960
Chris@478 961 invalidateImageCaches();
Chris@119 962 invalidateMagnitudes();
Chris@0 963 }
Chris@0 964
Chris@0 965 void
Chris@906 966 SpectrogramLayer::cacheInvalid(sv_frame_t from, sv_frame_t to)
Chris@0 967 {
Chris@391 968 #ifdef DEBUG_SPECTROGRAM_REPAINT
Chris@985 969 cerr << "SpectrogramLayer::cacheInvalid(" << from << ", " << to << ")" << endl;
Chris@391 970 #endif
Chris@391 971
Chris@1030 972 // We used to call invalidateMagnitudes(from, to) to invalidate
Chris@1030 973 // only those caches whose views contained some of the (from, to)
Chris@1030 974 // range. That's the right thing to do; it has been lost in
Chris@1030 975 // pulling out the image cache code, but it might not matter very
Chris@1030 976 // much, since the underlying models for spectrogram layers don't
Chris@1030 977 // change very often. Let's see.
Chris@1030 978 invalidateImageCaches();
Chris@391 979 invalidateMagnitudes();
Chris@0 980 }
Chris@0 981
Chris@224 982 bool
Chris@224 983 SpectrogramLayer::hasLightBackground() const
Chris@224 984 {
Chris@287 985 return ColourMapper(m_colourMap, 1.f, 255.f).hasLightBackground();
Chris@224 986 }
Chris@224 987
Chris@0 988 void
Chris@197 989 SpectrogramLayer::initialisePalette()
Chris@0 990 {
Chris@10 991 int formerRotation = m_colourRotation;
Chris@10 992
Chris@197 993 if (m_colourMap == (int)ColourMapper::BlackOnWhite) {
Chris@197 994 m_palette.setColour(NO_VALUE, Qt::white);
Chris@38 995 } else {
Chris@197 996 m_palette.setColour(NO_VALUE, Qt::black);
Chris@38 997 }
Chris@0 998
Chris@197 999 ColourMapper mapper(m_colourMap, 1.f, 255.f);
Chris@196 1000
Chris@0 1001 for (int pixel = 1; pixel < 256; ++pixel) {
Chris@907 1002 m_palette.setColour((unsigned char)pixel, mapper.map(pixel));
Chris@0 1003 }
Chris@9 1004
Chris@196 1005 m_crosshairColour = mapper.getContrastingColour();
Chris@196 1006
Chris@9 1007 m_colourRotation = 0;
Chris@197 1008 rotatePalette(m_colourRotation - formerRotation);
Chris@10 1009 m_colourRotation = formerRotation;
Chris@478 1010
Chris@478 1011 m_drawBuffer = QImage();
Chris@9 1012 }
Chris@9 1013
Chris@9 1014 void
Chris@197 1015 SpectrogramLayer::rotatePalette(int distance)
Chris@9 1016 {
Chris@31 1017 QColor newPixels[256];
Chris@9 1018
Chris@197 1019 newPixels[NO_VALUE] = m_palette.getColour(NO_VALUE);
Chris@9 1020
Chris@9 1021 for (int pixel = 1; pixel < 256; ++pixel) {
Chris@9 1022 int target = pixel + distance;
Chris@9 1023 while (target < 1) target += 255;
Chris@9 1024 while (target > 255) target -= 255;
Chris@907 1025 newPixels[target] = m_palette.getColour((unsigned char)pixel);
Chris@9 1026 }
Chris@9 1027
Chris@9 1028 for (int pixel = 0; pixel < 256; ++pixel) {
Chris@907 1029 m_palette.setColour((unsigned char)pixel, newPixels[pixel]);
Chris@9 1030 }
Chris@478 1031
Chris@478 1032 m_drawBuffer = QImage();
Chris@0 1033 }
Chris@0 1034
Chris@38 1035 unsigned char
Chris@918 1036 SpectrogramLayer::getDisplayValue(LayerGeometryProvider *v, double input) const
Chris@38 1037 {
Chris@38 1038 int value;
Chris@37 1039
Chris@907 1040 double min = 0.0;
Chris@907 1041 double max = 1.0;
Chris@120 1042
Chris@862 1043 if (m_normalization == NormalizeVisibleArea) {
Chris@1030 1044 min = m_viewMags[v->getId()].getMin();
Chris@1030 1045 max = m_viewMags[v->getId()].getMax();
Chris@862 1046 } else if (m_normalization != NormalizeColumns) {
Chris@224 1047 if (m_colourScale == LinearColourScale //||
Chris@224 1048 // m_colourScale == MeterColourScale) {
Chris@224 1049 ) {
Chris@907 1050 max = 0.1;
Chris@120 1051 }
Chris@120 1052 }
Chris@120 1053
Chris@907 1054 double thresh = -80.0;
Chris@907 1055
Chris@907 1056 if (max == 0.0) max = 1.0;
Chris@907 1057 if (max == min) min = max - 0.0001;
Chris@119 1058
Chris@40 1059 switch (m_colourScale) {
Chris@40 1060
Chris@40 1061 default:
Chris@40 1062 case LinearColourScale:
Chris@907 1063 value = int(((input - min) / (max - min)) * 255.0) + 1;
Chris@40 1064 break;
Chris@40 1065
Chris@40 1066 case MeterColourScale:
Chris@210 1067 value = AudioLevel::multiplier_to_preview
Chris@210 1068 ((input - min) / (max - min), 254) + 1;
Chris@40 1069 break;
Chris@119 1070
Chris@210 1071 case dBSquaredColourScale:
Chris@215 1072 input = ((input - min) * (input - min)) / ((max - min) * (max - min));
Chris@907 1073 if (input > 0.0) {
Chris@907 1074 input = 10.0 * log10(input);
Chris@133 1075 } else {
Chris@133 1076 input = thresh;
Chris@133 1077 }
Chris@907 1078 if (min > 0.0) {
Chris@907 1079 thresh = 10.0 * log10(min * min);
Chris@907 1080 if (thresh < -80.0) thresh = -80.0;
Chris@119 1081 }
Chris@119 1082 input = (input - thresh) / (-thresh);
Chris@907 1083 if (input < 0.0) input = 0.0;
Chris@907 1084 if (input > 1.0) input = 1.0;
Chris@907 1085 value = int(input * 255.0) + 1;
Chris@119 1086 break;
Chris@40 1087
Chris@215 1088 case dBColourScale:
Chris@215 1089 //!!! experiment with normalizing the visible area this way.
Chris@215 1090 //In any case, we need to have some indication of what the dB
Chris@215 1091 //scale is relative to.
Chris@215 1092 input = (input - min) / (max - min);
Chris@907 1093 if (input > 0.0) {
Chris@907 1094 input = 10.0 * log10(input);
Chris@215 1095 } else {
Chris@215 1096 input = thresh;
Chris@215 1097 }
Chris@907 1098 if (min > 0.0) {
Chris@907 1099 thresh = 10.0 * log10(min);
Chris@907 1100 if (thresh < -80.0) thresh = -80.0;
Chris@215 1101 }
Chris@215 1102 input = (input - thresh) / (-thresh);
Chris@907 1103 if (input < 0.0) input = 0.0;
Chris@907 1104 if (input > 1.0) input = 1.0;
Chris@907 1105 value = int(input * 255.0) + 1;
Chris@215 1106 break;
Chris@215 1107
Chris@40 1108 case PhaseColourScale:
Chris@40 1109 value = int((input * 127.0 / M_PI) + 128);
Chris@40 1110 break;
Chris@0 1111 }
Chris@210 1112
Chris@38 1113 if (value > UCHAR_MAX) value = UCHAR_MAX;
Chris@38 1114 if (value < 0) value = 0;
Chris@907 1115 return (unsigned char)value;
Chris@0 1116 }
Chris@0 1117
Chris@905 1118 double
Chris@40 1119 SpectrogramLayer::getEffectiveMinFrequency() const
Chris@40 1120 {
Chris@907 1121 sv_samplerate_t sr = m_model->getSampleRate();
Chris@905 1122 double minf = double(sr) / m_fftSize;
Chris@40 1123
Chris@40 1124 if (m_minFrequency > 0.0) {
Chris@805 1125 int minbin = int((double(m_minFrequency) * m_fftSize) / sr + 0.01);
Chris@40 1126 if (minbin < 1) minbin = 1;
Chris@107 1127 minf = minbin * sr / m_fftSize;
Chris@40 1128 }
Chris@40 1129
Chris@40 1130 return minf;
Chris@40 1131 }
Chris@40 1132
Chris@905 1133 double
Chris@40 1134 SpectrogramLayer::getEffectiveMaxFrequency() const
Chris@40 1135 {
Chris@907 1136 sv_samplerate_t sr = m_model->getSampleRate();
Chris@905 1137 double maxf = double(sr) / 2;
Chris@40 1138
Chris@40 1139 if (m_maxFrequency > 0.0) {
Chris@805 1140 int maxbin = int((double(m_maxFrequency) * m_fftSize) / sr + 0.1);
Chris@107 1141 if (maxbin > m_fftSize / 2) maxbin = m_fftSize / 2;
Chris@107 1142 maxf = maxbin * sr / m_fftSize;
Chris@40 1143 }
Chris@40 1144
Chris@40 1145 return maxf;
Chris@40 1146 }
Chris@40 1147
Chris@0 1148 bool
Chris@918 1149 SpectrogramLayer::getYBinRange(LayerGeometryProvider *v, int y, double &q0, double &q1) const
Chris@0 1150 {
Chris@382 1151 Profiler profiler("SpectrogramLayer::getYBinRange");
Chris@382 1152
Chris@918 1153 int h = v->getPaintHeight();
Chris@0 1154 if (y < 0 || y >= h) return false;
Chris@0 1155
Chris@907 1156 sv_samplerate_t sr = m_model->getSampleRate();
Chris@905 1157 double minf = getEffectiveMinFrequency();
Chris@905 1158 double maxf = getEffectiveMaxFrequency();
Chris@0 1159
Chris@38 1160 bool logarithmic = (m_frequencyScale == LogFrequencyScale);
Chris@38 1161
Chris@44 1162 q0 = v->getFrequencyForY(y, minf, maxf, logarithmic);
Chris@44 1163 q1 = v->getFrequencyForY(y - 1, minf, maxf, logarithmic);
Chris@38 1164
Chris@490 1165 // Now map these on to ("proportions of") actual bins, using raw
Chris@490 1166 // FFT size (unsmoothed)
Chris@490 1167
Chris@490 1168 q0 = (q0 * m_fftSize) / sr;
Chris@490 1169 q1 = (q1 * m_fftSize) / sr;
Chris@0 1170
Chris@0 1171 return true;
Chris@0 1172 }
Chris@486 1173
Chris@486 1174 bool
Chris@918 1175 SpectrogramLayer::getSmoothedYBinRange(LayerGeometryProvider *v, int y, double &q0, double &q1) const
Chris@486 1176 {
Chris@486 1177 Profiler profiler("SpectrogramLayer::getSmoothedYBinRange");
Chris@486 1178
Chris@918 1179 int h = v->getPaintHeight();
Chris@486 1180 if (y < 0 || y >= h) return false;
Chris@486 1181
Chris@907 1182 sv_samplerate_t sr = m_model->getSampleRate();
Chris@905 1183 double minf = getEffectiveMinFrequency();
Chris@905 1184 double maxf = getEffectiveMaxFrequency();
Chris@486 1185
Chris@486 1186 bool logarithmic = (m_frequencyScale == LogFrequencyScale);
Chris@486 1187
Chris@486 1188 q0 = v->getFrequencyForY(y, minf, maxf, logarithmic);
Chris@486 1189 q1 = v->getFrequencyForY(y - 1, minf, maxf, logarithmic);
Chris@486 1190
Chris@490 1191 // Now map these on to ("proportions of") actual bins, using raw
Chris@490 1192 // FFT size (unsmoothed)
Chris@490 1193
Chris@490 1194 q0 = (q0 * getFFTSize(v)) / sr;
Chris@490 1195 q1 = (q1 * getFFTSize(v)) / sr;
Chris@486 1196
Chris@486 1197 return true;
Chris@486 1198 }
Chris@38 1199
Chris@0 1200 bool
Chris@918 1201 SpectrogramLayer::getXBinRange(LayerGeometryProvider *v, int x, double &s0, double &s1) const
Chris@0 1202 {
Chris@907 1203 sv_frame_t modelStart = m_model->getStartFrame();
Chris@907 1204 sv_frame_t modelEnd = m_model->getEndFrame();
Chris@0 1205
Chris@0 1206 // Each pixel column covers an exact range of sample frames:
Chris@907 1207 sv_frame_t f0 = v->getFrameForX(x) - modelStart;
Chris@907 1208 sv_frame_t f1 = v->getFrameForX(x + 1) - modelStart - 1;
Chris@20 1209
Chris@41 1210 if (f1 < int(modelStart) || f0 > int(modelEnd)) {
Chris@41 1211 return false;
Chris@41 1212 }
Chris@20 1213
Chris@0 1214 // And that range may be drawn from a possibly non-integral
Chris@0 1215 // range of spectrogram windows:
Chris@0 1216
Chris@805 1217 int windowIncrement = getWindowIncrement();
Chris@905 1218 s0 = double(f0) / windowIncrement;
Chris@905 1219 s1 = double(f1) / windowIncrement;
Chris@0 1220
Chris@0 1221 return true;
Chris@0 1222 }
Chris@0 1223
Chris@0 1224 bool
Chris@918 1225 SpectrogramLayer::getXBinSourceRange(LayerGeometryProvider *v, int x, RealTime &min, RealTime &max) const
Chris@0 1226 {
Chris@905 1227 double s0 = 0, s1 = 0;
Chris@44 1228 if (!getXBinRange(v, x, s0, s1)) return false;
Chris@0 1229
Chris@0 1230 int s0i = int(s0 + 0.001);
Chris@0 1231 int s1i = int(s1);
Chris@0 1232
Chris@0 1233 int windowIncrement = getWindowIncrement();
Chris@0 1234 int w0 = s0i * windowIncrement - (m_windowSize - windowIncrement)/2;
Chris@0 1235 int w1 = s1i * windowIncrement + windowIncrement +
Chris@0 1236 (m_windowSize - windowIncrement)/2 - 1;
Chris@0 1237
Chris@0 1238 min = RealTime::frame2RealTime(w0, m_model->getSampleRate());
Chris@0 1239 max = RealTime::frame2RealTime(w1, m_model->getSampleRate());
Chris@0 1240 return true;
Chris@0 1241 }
Chris@0 1242
Chris@0 1243 bool
Chris@918 1244 SpectrogramLayer::getYBinSourceRange(LayerGeometryProvider *v, int y, double &freqMin, double &freqMax)
Chris@0 1245 const
Chris@0 1246 {
Chris@905 1247 double q0 = 0, q1 = 0;
Chris@44 1248 if (!getYBinRange(v, y, q0, q1)) return false;
Chris@0 1249
Chris@0 1250 int q0i = int(q0 + 0.001);
Chris@0 1251 int q1i = int(q1);
Chris@0 1252
Chris@907 1253 sv_samplerate_t sr = m_model->getSampleRate();
Chris@0 1254
Chris@0 1255 for (int q = q0i; q <= q1i; ++q) {
Chris@121 1256 if (q == q0i) freqMin = (sr * q) / m_fftSize;
Chris@121 1257 if (q == q1i) freqMax = (sr * (q+1)) / m_fftSize;
Chris@0 1258 }
Chris@0 1259 return true;
Chris@0 1260 }
Chris@35 1261
Chris@35 1262 bool
Chris@918 1263 SpectrogramLayer::getAdjustedYBinSourceRange(LayerGeometryProvider *v, int x, int y,
Chris@905 1264 double &freqMin, double &freqMax,
Chris@905 1265 double &adjFreqMin, double &adjFreqMax)
Chris@35 1266 const
Chris@35 1267 {
Chris@277 1268 if (!m_model || !m_model->isOK() || !m_model->isReady()) {
Chris@277 1269 return false;
Chris@277 1270 }
Chris@277 1271
Chris@130 1272 FFTModel *fft = getFFTModel(v);
Chris@114 1273 if (!fft) return false;
Chris@110 1274
Chris@905 1275 double s0 = 0, s1 = 0;
Chris@44 1276 if (!getXBinRange(v, x, s0, s1)) return false;
Chris@35 1277
Chris@905 1278 double q0 = 0, q1 = 0;
Chris@44 1279 if (!getYBinRange(v, y, q0, q1)) return false;
Chris@35 1280
Chris@35 1281 int s0i = int(s0 + 0.001);
Chris@35 1282 int s1i = int(s1);
Chris@35 1283
Chris@35 1284 int q0i = int(q0 + 0.001);
Chris@35 1285 int q1i = int(q1);
Chris@35 1286
Chris@907 1287 sv_samplerate_t sr = m_model->getSampleRate();
Chris@35 1288
Chris@35 1289 bool haveAdj = false;
Chris@35 1290
Chris@37 1291 bool peaksOnly = (m_binDisplay == PeakBins ||
Chris@37 1292 m_binDisplay == PeakFrequencies);
Chris@37 1293
Chris@35 1294 for (int q = q0i; q <= q1i; ++q) {
Chris@35 1295
Chris@35 1296 for (int s = s0i; s <= s1i; ++s) {
Chris@35 1297
Chris@905 1298 double binfreq = (double(sr) * q) / m_windowSize;
Chris@35 1299 if (q == q0i) freqMin = binfreq;
Chris@35 1300 if (q == q1i) freqMax = binfreq;
Chris@37 1301
Chris@114 1302 if (peaksOnly && !fft->isLocalPeak(s, q)) continue;
Chris@38 1303
Chris@907 1304 if (!fft->isOverThreshold(s, q, float(m_threshold * double(m_fftSize)/2.0))) continue;
Chris@907 1305
Chris@907 1306 double freq = binfreq;
Chris@40 1307
Chris@114 1308 if (s < int(fft->getWidth()) - 1) {
Chris@38 1309
Chris@277 1310 fft->estimateStableFrequency(s, q, freq);
Chris@35 1311
Chris@38 1312 if (!haveAdj || freq < adjFreqMin) adjFreqMin = freq;
Chris@38 1313 if (!haveAdj || freq > adjFreqMax) adjFreqMax = freq;
Chris@35 1314
Chris@35 1315 haveAdj = true;
Chris@35 1316 }
Chris@35 1317 }
Chris@35 1318 }
Chris@35 1319
Chris@35 1320 if (!haveAdj) {
Chris@40 1321 adjFreqMin = adjFreqMax = 0.0;
Chris@35 1322 }
Chris@35 1323
Chris@35 1324 return haveAdj;
Chris@35 1325 }
Chris@0 1326
Chris@0 1327 bool
Chris@918 1328 SpectrogramLayer::getXYBinSourceRange(LayerGeometryProvider *v, int x, int y,
Chris@905 1329 double &min, double &max,
Chris@905 1330 double &phaseMin, double &phaseMax) const
Chris@0 1331 {
Chris@277 1332 if (!m_model || !m_model->isOK() || !m_model->isReady()) {
Chris@277 1333 return false;
Chris@277 1334 }
Chris@277 1335
Chris@905 1336 double q0 = 0, q1 = 0;
Chris@44 1337 if (!getYBinRange(v, y, q0, q1)) return false;
Chris@0 1338
Chris@905 1339 double s0 = 0, s1 = 0;
Chris@44 1340 if (!getXBinRange(v, x, s0, s1)) return false;
Chris@0 1341
Chris@0 1342 int q0i = int(q0 + 0.001);
Chris@0 1343 int q1i = int(q1);
Chris@0 1344
Chris@0 1345 int s0i = int(s0 + 0.001);
Chris@0 1346 int s1i = int(s1);
Chris@0 1347
Chris@37 1348 bool rv = false;
Chris@37 1349
Chris@805 1350 int zp = getZeroPadLevel(v);
Chris@122 1351 q0i *= zp + 1;
Chris@122 1352 q1i *= zp + 1;
Chris@122 1353
Chris@130 1354 FFTModel *fft = getFFTModel(v);
Chris@0 1355
Chris@114 1356 if (fft) {
Chris@114 1357
Chris@114 1358 int cw = fft->getWidth();
Chris@114 1359 int ch = fft->getHeight();
Chris@0 1360
Chris@110 1361 min = 0.0;
Chris@110 1362 max = 0.0;
Chris@110 1363 phaseMin = 0.0;
Chris@110 1364 phaseMax = 0.0;
Chris@110 1365 bool have = false;
Chris@0 1366
Chris@110 1367 for (int q = q0i; q <= q1i; ++q) {
Chris@110 1368 for (int s = s0i; s <= s1i; ++s) {
Chris@110 1369 if (s >= 0 && q >= 0 && s < cw && q < ch) {
Chris@117 1370
Chris@905 1371 double value;
Chris@38 1372
Chris@114 1373 value = fft->getPhaseAt(s, q);
Chris@110 1374 if (!have || value < phaseMin) { phaseMin = value; }
Chris@110 1375 if (!have || value > phaseMax) { phaseMax = value; }
Chris@91 1376
Chris@907 1377 value = fft->getMagnitudeAt(s, q) / (m_fftSize/2.0);
Chris@110 1378 if (!have || value < min) { min = value; }
Chris@110 1379 if (!have || value > max) { max = value; }
Chris@110 1380
Chris@110 1381 have = true;
Chris@110 1382 }
Chris@110 1383 }
Chris@110 1384 }
Chris@110 1385
Chris@110 1386 if (have) {
Chris@110 1387 rv = true;
Chris@110 1388 }
Chris@0 1389 }
Chris@0 1390
Chris@37 1391 return rv;
Chris@0 1392 }
Chris@0 1393
Chris@805 1394 int
Chris@918 1395 SpectrogramLayer::getZeroPadLevel(const LayerGeometryProvider *v) const
Chris@114 1396 {
Chris@114 1397 //!!! tidy all this stuff
Chris@114 1398
Chris@114 1399 if (m_binDisplay != AllBins) return 0;
Chris@221 1400
Chris@221 1401 Preferences::SpectrogramSmoothing smoothing =
Chris@221 1402 Preferences::getInstance()->getSpectrogramSmoothing();
Chris@221 1403
Chris@221 1404 if (smoothing == Preferences::NoSpectrogramSmoothing ||
Chris@221 1405 smoothing == Preferences::SpectrogramInterpolated) return 0;
Chris@221 1406
Chris@114 1407 if (m_frequencyScale == LogFrequencyScale) return 3;
Chris@114 1408
Chris@907 1409 sv_samplerate_t sr = m_model->getSampleRate();
Chris@114 1410
Chris@805 1411 int maxbin = m_fftSize / 2;
Chris@114 1412 if (m_maxFrequency > 0) {
Chris@184 1413 maxbin = int((double(m_maxFrequency) * m_fftSize) / sr + 0.1);
Chris@184 1414 if (maxbin > m_fftSize / 2) maxbin = m_fftSize / 2;
Chris@114 1415 }
Chris@114 1416
Chris@805 1417 int minbin = 1;
Chris@114 1418 if (m_minFrequency > 0) {
Chris@114 1419 minbin = int((double(m_minFrequency) * m_fftSize) / sr + 0.1);
Chris@114 1420 if (minbin < 1) minbin = 1;
Chris@184 1421 if (minbin >= maxbin) minbin = maxbin - 1;
Chris@114 1422 }
Chris@114 1423
Chris@905 1424 double perPixel =
Chris@918 1425 double(v->getPaintHeight()) /
Chris@905 1426 double((maxbin - minbin) / (m_zeroPadLevel + 1));
Chris@118 1427
Chris@118 1428 if (perPixel > 2.8) {
Chris@118 1429 return 3; // 4x oversampling
Chris@118 1430 } else if (perPixel > 1.5) {
Chris@118 1431 return 1; // 2x
Chris@114 1432 } else {
Chris@118 1433 return 0; // 1x
Chris@114 1434 }
Chris@114 1435 }
Chris@114 1436
Chris@805 1437 int
Chris@918 1438 SpectrogramLayer::getFFTSize(const LayerGeometryProvider *v) const
Chris@114 1439 {
Chris@114 1440 return m_fftSize * (getZeroPadLevel(v) + 1);
Chris@114 1441 }
Chris@114 1442
Chris@130 1443 FFTModel *
Chris@918 1444 SpectrogramLayer::getFFTModel(const LayerGeometryProvider *v) const
Chris@114 1445 {
Chris@114 1446 if (!m_model) return 0;
Chris@114 1447
Chris@805 1448 int fftSize = getFFTSize(v);
Chris@114 1449
Chris@920 1450 const View *view = v->getView();
Chris@920 1451
Chris@1030 1452 if (m_fftModels.find(view->getId()) != m_fftModels.end()) {
Chris@1030 1453 if (m_fftModels[view->getId()] == 0) {
Chris@184 1454 #ifdef DEBUG_SPECTROGRAM_REPAINT
Chris@985 1455 cerr << "SpectrogramLayer::getFFTModel(" << v << "): Found null model" << endl;
Chris@184 1456 #endif
Chris@184 1457 return 0;
Chris@184 1458 }
Chris@1030 1459 if (m_fftModels[view->getId()]->getHeight() != fftSize / 2 + 1) {
Chris@184 1460 #ifdef DEBUG_SPECTROGRAM_REPAINT
Chris@1030 1461 cerr << "SpectrogramLayer::getFFTModel(" << v << "): Found a model with the wrong height (" << m_fftModels[view->getId()]->getHeight() << ", wanted " << (fftSize / 2 + 1) << ")" << endl;
Chris@184 1462 #endif
Chris@1030 1463 delete m_fftModels[view->getId()];
Chris@1030 1464 m_fftModels.erase(view->getId());
Chris@1030 1465 delete m_peakCaches[view->getId()];
Chris@1030 1466 m_peakCaches.erase(view->getId());
Chris@184 1467 } else {
Chris@184 1468 #ifdef DEBUG_SPECTROGRAM_REPAINT
Chris@1030 1469 cerr << "SpectrogramLayer::getFFTModel(" << v << "): Found a good model of height " << m_fftModels[view->getId()]->getHeight() << endl;
Chris@184 1470 #endif
Chris@1030 1471 return m_fftModels[view->getId()];
Chris@114 1472 }
Chris@114 1473 }
Chris@114 1474
Chris@1030 1475 if (m_fftModels.find(view->getId()) == m_fftModels.end()) {
Chris@169 1476
Chris@169 1477 FFTModel *model = new FFTModel(m_model,
Chris@169 1478 m_channel,
Chris@169 1479 m_windowType,
Chris@169 1480 m_windowSize,
Chris@169 1481 getWindowIncrement(),
Chris@975 1482 fftSize);
Chris@169 1483
Chris@178 1484 if (!model->isOK()) {
Chris@178 1485 QMessageBox::critical
Chris@178 1486 (0, tr("FFT cache failed"),
Chris@178 1487 tr("Failed to create the FFT model for this spectrogram.\n"
Chris@178 1488 "There may be insufficient memory or disc space to continue."));
Chris@178 1489 delete model;
Chris@1030 1490 m_fftModels[view->getId()] = 0;
Chris@178 1491 return 0;
Chris@178 1492 }
Chris@178 1493
Chris@193 1494 if (!m_sliceableModel) {
Chris@248 1495 #ifdef DEBUG_SPECTROGRAM
Chris@682 1496 cerr << "SpectrogramLayer: emitting sliceableModelReplaced(0, " << model << ")" << endl;
Chris@248 1497 #endif
Chris@193 1498 ((SpectrogramLayer *)this)->sliceableModelReplaced(0, model);
Chris@193 1499 m_sliceableModel = model;
Chris@193 1500 }
Chris@193 1501
Chris@1030 1502 m_fftModels[view->getId()] = model;
Chris@114 1503 }
Chris@114 1504
Chris@1030 1505 return m_fftModels[view->getId()];
Chris@114 1506 }
Chris@114 1507
Chris@484 1508 Dense3DModelPeakCache *
Chris@918 1509 SpectrogramLayer::getPeakCache(const LayerGeometryProvider *v) const
Chris@484 1510 {
Chris@920 1511 const View *view = v->getView();
Chris@1030 1512 if (!m_peakCaches[view->getId()]) {
Chris@484 1513 FFTModel *f = getFFTModel(v);
Chris@484 1514 if (!f) return 0;
Chris@1030 1515 m_peakCaches[view->getId()] = new Dense3DModelPeakCache(f, 8);
Chris@484 1516 }
Chris@1030 1517 return m_peakCaches[view->getId()];
Chris@484 1518 }
Chris@484 1519
Chris@193 1520 const Model *
Chris@193 1521 SpectrogramLayer::getSliceableModel() const
Chris@193 1522 {
Chris@193 1523 if (m_sliceableModel) return m_sliceableModel;
Chris@193 1524 if (m_fftModels.empty()) return 0;
Chris@985 1525 m_sliceableModel = m_fftModels.begin()->second;
Chris@193 1526 return m_sliceableModel;
Chris@193 1527 }
Chris@193 1528
Chris@114 1529 void
Chris@130 1530 SpectrogramLayer::invalidateFFTModels()
Chris@114 1531 {
Chris@130 1532 for (ViewFFTMap::iterator i = m_fftModels.begin();
Chris@130 1533 i != m_fftModels.end(); ++i) {
Chris@985 1534 delete i->second;
Chris@114 1535 }
Chris@486 1536 for (PeakCacheMap::iterator i = m_peakCaches.begin();
Chris@486 1537 i != m_peakCaches.end(); ++i) {
Chris@486 1538 delete i->second;
Chris@486 1539 }
Chris@114 1540
Chris@130 1541 m_fftModels.clear();
Chris@486 1542 m_peakCaches.clear();
Chris@193 1543
Chris@193 1544 if (m_sliceableModel) {
Chris@682 1545 cerr << "SpectrogramLayer: emitting sliceableModelReplaced(" << m_sliceableModel << ", 0)" << endl;
Chris@193 1546 emit sliceableModelReplaced(m_sliceableModel, 0);
Chris@193 1547 m_sliceableModel = 0;
Chris@193 1548 }
Chris@114 1549 }
Chris@114 1550
Chris@0 1551 void
Chris@119 1552 SpectrogramLayer::invalidateMagnitudes()
Chris@119 1553 {
Chris@119 1554 m_viewMags.clear();
Chris@1025 1555 for (vector<MagnitudeRange>::iterator i = m_columnMags.begin();
Chris@119 1556 i != m_columnMags.end(); ++i) {
Chris@119 1557 *i = MagnitudeRange();
Chris@119 1558 }
Chris@119 1559 }
Chris@119 1560
Chris@119 1561 bool
Chris@918 1562 SpectrogramLayer::updateViewMagnitudes(LayerGeometryProvider *v) const
Chris@119 1563 {
Chris@119 1564 MagnitudeRange mag;
Chris@119 1565
Chris@918 1566 int x0 = 0, x1 = v->getPaintWidth();
Chris@905 1567 double s00 = 0, s01 = 0, s10 = 0, s11 = 0;
Chris@119 1568
Chris@203 1569 if (!getXBinRange(v, x0, s00, s01)) {
Chris@907 1570 s00 = s01 = double(m_model->getStartFrame()) / getWindowIncrement();
Chris@203 1571 }
Chris@203 1572
Chris@203 1573 if (!getXBinRange(v, x1, s10, s11)) {
Chris@907 1574 s10 = s11 = double(m_model->getEndFrame()) / getWindowIncrement();
Chris@203 1575 }
Chris@119 1576
Chris@1025 1577 int s0 = int(min(s00, s10) + 0.0001);
Chris@1025 1578 int s1 = int(max(s01, s11) + 0.0001);
Chris@203 1579
Chris@587 1580 // SVDEBUG << "SpectrogramLayer::updateViewMagnitudes: x0 = " << x0 << ", x1 = " << x1 << ", s00 = " << s00 << ", s11 = " << s11 << " s0 = " << s0 << ", s1 = " << s1 << endl;
Chris@119 1581
Chris@248 1582 if (int(m_columnMags.size()) <= s1) {
Chris@119 1583 m_columnMags.resize(s1 + 1);
Chris@119 1584 }
Chris@119 1585
Chris@119 1586 for (int s = s0; s <= s1; ++s) {
Chris@119 1587 if (m_columnMags[s].isSet()) {
Chris@119 1588 mag.sample(m_columnMags[s]);
Chris@119 1589 }
Chris@119 1590 }
Chris@119 1591
Chris@184 1592 #ifdef DEBUG_SPECTROGRAM_REPAINT
Chris@985 1593 cerr << "SpectrogramLayer::updateViewMagnitudes returning from cols "
Chris@585 1594 << s0 << " -> " << s1 << " inclusive" << endl;
Chris@184 1595 #endif
Chris@119 1596
Chris@119 1597 if (!mag.isSet()) return false;
Chris@1030 1598 if (mag == m_viewMags[v->getId()]) return false;
Chris@1030 1599 m_viewMags[v->getId()] = mag;
Chris@119 1600 return true;
Chris@119 1601 }
Chris@119 1602
Chris@119 1603 void
Chris@389 1604 SpectrogramLayer::setSynchronousPainting(bool synchronous)
Chris@389 1605 {
Chris@389 1606 m_synchronous = synchronous;
Chris@389 1607 }
Chris@389 1608
Chris@1030 1609 ScrollableImageCache &
Chris@1030 1610 SpectrogramLayer::getImageCacheReference(const LayerGeometryProvider *view) const
Chris@1030 1611 {
Chris@1030 1612 if (m_imageCaches.find(view->getId()) == m_imageCaches.end()) {
Chris@1030 1613 m_imageCaches[view->getId()] = ScrollableImageCache(view);
Chris@1030 1614 }
Chris@1030 1615 return m_imageCaches.at(view->getId());
Chris@1030 1616 }
Chris@1030 1617
Chris@389 1618 void
Chris@916 1619 SpectrogramLayer::paint(LayerGeometryProvider *v, QPainter &paint, QRect rect) const
Chris@0 1620 {
Chris@334 1621 Profiler profiler("SpectrogramLayer::paint", false);
Chris@334 1622
Chris@0 1623 #ifdef DEBUG_SPECTROGRAM_REPAINT
Chris@1026 1624 cerr << "SpectrogramLayer::paint() entering: m_model is " << m_model << ", zoom level is " << v->getZoomLevel() << endl;
Chris@95 1625
Chris@1026 1626 cerr << "SpectrogramLayer::paint(): rect is " << rect.x() << "," << rect.y() << " " << rect.width() << "x" << rect.height() << endl;
Chris@0 1627 #endif
Chris@95 1628
Chris@907 1629 sv_frame_t startFrame = v->getStartFrame();
Chris@44 1630
Chris@0 1631 if (!m_model || !m_model->isOK() || !m_model->isReady()) {
Chris@0 1632 return;
Chris@0 1633 }
Chris@0 1634
Chris@47 1635 if (isLayerDormant(v)) {
Chris@587 1636 SVDEBUG << "SpectrogramLayer::paint(): Layer is dormant, making it undormant again" << endl;
Chris@29 1637 }
Chris@29 1638
Chris@48 1639 // Need to do this even if !isLayerDormant, as that could mean v
Chris@48 1640 // is not in the dormancy map at all -- we need it to be present
Chris@48 1641 // and accountable for when determining whether we need the cache
Chris@48 1642 // in the cache-fill thread above.
Chris@806 1643 //!!! no inter use cache-fill thread
Chris@131 1644 const_cast<SpectrogramLayer *>(this)->Layer::setLayerDormant(v, false);
Chris@48 1645
Chris@805 1646 int fftSize = getFFTSize(v);
Chris@920 1647
Chris@920 1648 const View *view = v->getView();
Chris@1030 1649 ScrollableImageCache &cache = getImageCacheReference(view);
Chris@95 1650
Chris@95 1651 #ifdef DEBUG_SPECTROGRAM_REPAINT
Chris@1030 1652 cerr << "SpectrogramLayer::paint(): image cache valid area from " << cache.getValidLeft() << " width " << cache.getValidWidth() << ", height " << cache.getSize().height() << endl;
Chris@1030 1653 if (rect.x() + rect.width() + 1 < cache.getValidLeft() ||
Chris@1030 1654 rect.x() > cache.getValidRight()) {
Chris@1030 1655 cerr << "SpectrogramLayer: NOTE: requested rect is not contiguous with cache valid area" << endl;
Chris@1030 1656 }
Chris@95 1657 #endif
Chris@95 1658
Chris@44 1659 int zoomLevel = v->getZoomLevel();
Chris@0 1660
Chris@1030 1661 int x0 = v->getXForViewX(rect.x());
Chris@1030 1662 int x1 = v->getXForViewX(rect.x() + rect.width());
Chris@1030 1663 if (x0 < 0) x0 = 0;
Chris@1030 1664 if (x1 > v->getPaintWidth()) x1 = v->getPaintWidth();
Chris@1022 1665
Chris@1022 1666 if (updateViewMagnitudes(v)) {
Chris@1022 1667 #ifdef DEBUG_SPECTROGRAM_REPAINT
Chris@1030 1668 cerr << "SpectrogramLayer: magnitude range changed to [" << m_viewMags[v->getId()].getMin() << "->" << m_viewMags[v->getId()].getMax() << "]" << endl;
Chris@1022 1669 #endif
Chris@1022 1670 if (m_normalization == NormalizeVisibleArea) {
Chris@1030 1671 cache.invalidate();
Chris@1022 1672 }
Chris@1022 1673 }
Chris@1030 1674
Chris@1030 1675 if (cache.getZoomLevel() != zoomLevel ||
Chris@1030 1676 cache.getSize() != v->getPaintSize()) {
Chris@1031 1677 #ifdef DEBUG_SPECTROGRAM_REPAINT
Chris@1031 1678 cerr << "SpectrogramLayer: resizing image cache from "
Chris@1031 1679 << cache.getSize().width() << "x" << cache.getSize().height()
Chris@1031 1680 << " to "
Chris@1031 1681 << v->getPaintSize().width() << "x" << v->getPaintSize().height()
Chris@1031 1682 << " and updating zoom level from " << cache.getZoomLevel()
Chris@1031 1683 << " to " << zoomLevel
Chris@1031 1684 << endl;
Chris@1031 1685 #endif
Chris@1030 1686 cache.resize(v->getPaintSize());
Chris@1031 1687 cache.setZoomLevel(zoomLevel);
Chris@1031 1688 cache.setStartFrame(startFrame);
Chris@1030 1689 }
Chris@1023 1690
Chris@1030 1691 if (cache.isValid()) {
Chris@482 1692
Chris@1030 1693 if (v->getXForFrame(cache.getStartFrame()) ==
Chris@1030 1694 v->getXForFrame(startFrame) &&
Chris@1030 1695 cache.getValidLeft() <= x0 &&
Chris@1030 1696 cache.getValidRight() >= x1) {
Chris@1022 1697
Chris@0 1698 #ifdef DEBUG_SPECTROGRAM_REPAINT
Chris@1030 1699 cerr << "SpectrogramLayer: image cache hit!" << endl;
Chris@0 1700 #endif
Chris@0 1701
Chris@1030 1702 paint.drawImage(rect, cache.getImage(), rect);
Chris@1030 1703
Chris@1030 1704 illuminateLocalFeatures(v, paint);
Chris@1030 1705 return;
Chris@1030 1706
Chris@1030 1707 } else {
Chris@1030 1708
Chris@1030 1709 // cache doesn't begin at the right frame or doesn't
Chris@1030 1710 // contain the complete view, but might be scrollable or
Chris@1030 1711 // partially usable
Chris@1022 1712
Chris@0 1713 #ifdef DEBUG_SPECTROGRAM_REPAINT
Chris@1030 1714 cerr << "SpectrogramLayer: scrolling the image cache if applicable" << endl;
Chris@0 1715 #endif
Chris@0 1716
Chris@1030 1717 cache.scrollTo(startFrame);
Chris@1030 1718
Chris@0 1719 #ifdef DEBUG_SPECTROGRAM_REPAINT
Chris@1031 1720 cerr << "SpectrogramLayer: after scrolling, cache valid from "
Chris@1030 1721 << cache.getValidLeft() << " width " << cache.getValidWidth()
Chris@1030 1722 << endl;
Chris@0 1723 #endif
Chris@1030 1724 }
Chris@0 1725 }
Chris@95 1726
Chris@1030 1727 bool rightToLeft = false;
Chris@1030 1728
Chris@1030 1729 if (!cache.isValid()) {
Chris@1028 1730 if (!m_synchronous) {
Chris@1028 1731 // When rendering the whole thing, start from somewhere near
Chris@1028 1732 // the middle so that the region of interest appears first
Chris@1030 1733 if (x0 == 0 && x1 == v->getPaintWidth()) {
Chris@1030 1734 x0 = int(x1 * 0.4);
Chris@1030 1735 }
Chris@1028 1736 }
Chris@1030 1737 } else {
Chris@1030 1738 // When rendering only a part of the cache, we need to make
Chris@1030 1739 // sure that the part we're rendering is adjacent to (or
Chris@1030 1740 // overlapping) a valid area of cache, if we have one. The
Chris@1030 1741 // alternative is to ditch the valid area of cache and render
Chris@1030 1742 // only the requested area, but that's risky because this can
Chris@1030 1743 // happen when just waving the pointer over a small part of
Chris@1030 1744 // the view -- if we lose the partly-built cache every time
Chris@1030 1745 // the user does that, we'll never finish building it.
Chris@1030 1746 int left = x0;
Chris@1030 1747 int width = x1 - x0;
Chris@1030 1748 bool isLeftOfValidArea = false;
Chris@1031 1749 cache.adjustToTouchValidArea(left, width, isLeftOfValidArea);
Chris@1030 1750 x0 = left;
Chris@1030 1751 x1 = x0 + width;
Chris@1030 1752
Chris@1030 1753 // That call also told us whether we should be painting
Chris@1030 1754 // sub-regions of our target region in right-to-left order in
Chris@1030 1755 // order to ensure contiguity
Chris@1030 1756 rightToLeft = isLeftOfValidArea;
Chris@95 1757 }
Chris@1030 1758
Chris@224 1759 // We always paint the full height when refreshing the cache.
Chris@224 1760 // Smaller heights can be used when painting direct from cache
Chris@224 1761 // (further up in this function), but we want to ensure the cache
Chris@224 1762 // is coherent without having to worry about vertical matching of
Chris@224 1763 // required and valid areas as well as horizontal.
Chris@918 1764 int h = v->getPaintHeight();
Chris@1025 1765
Chris@1024 1766 int repaintWidth = x1 - x0;
Chris@0 1767
Chris@95 1768 #ifdef DEBUG_SPECTROGRAM_REPAINT
Chris@1026 1769 cerr << "SpectrogramLayer: x0 " << x0 << ", x1 " << x1
Chris@1026 1770 << ", repaintWidth " << repaintWidth << ", h " << h
Chris@1030 1771 << ", rightToLeft " << rightToLeft << endl;
Chris@95 1772 #endif
Chris@95 1773
Chris@907 1774 sv_samplerate_t sr = m_model->getSampleRate();
Chris@122 1775
Chris@122 1776 // Set minFreq and maxFreq to the frequency extents of the possibly
Chris@122 1777 // zero-padded visible bin range, and displayMinFreq and displayMaxFreq
Chris@122 1778 // to the actual scale frequency extents (presumably not zero padded).
Chris@253 1779
Chris@253 1780 // If we are zero padding, we want to use the zero-padded
Chris@253 1781 // equivalents of the bins that we would be using if not zero
Chris@253 1782 // padded, to avoid spaces at the top and bottom of the display.
Chris@253 1783
Chris@253 1784 // Note fftSize is the actual zero-padded fft size, m_fftSize the
Chris@253 1785 // nominal fft size.
Chris@35 1786
Chris@805 1787 int maxbin = m_fftSize / 2;
Chris@35 1788 if (m_maxFrequency > 0) {
Chris@253 1789 maxbin = int((double(m_maxFrequency) * m_fftSize) / sr + 0.001);
Chris@253 1790 if (maxbin > m_fftSize / 2) maxbin = m_fftSize / 2;
Chris@35 1791 }
Chris@111 1792
Chris@805 1793 int minbin = 1;
Chris@37 1794 if (m_minFrequency > 0) {
Chris@253 1795 minbin = int((double(m_minFrequency) * m_fftSize) / sr + 0.001);
Chris@682 1796 // cerr << "m_minFrequency = " << m_minFrequency << " -> minbin = " << minbin << endl;
Chris@40 1797 if (minbin < 1) minbin = 1;
Chris@184 1798 if (minbin >= maxbin) minbin = maxbin - 1;
Chris@37 1799 }
Chris@37 1800
Chris@253 1801 int zpl = getZeroPadLevel(v) + 1;
Chris@253 1802 minbin = minbin * zpl;
Chris@253 1803 maxbin = (maxbin + 1) * zpl - 1;
Chris@253 1804
Chris@905 1805 double minFreq = (double(minbin) * sr) / fftSize;
Chris@905 1806 double maxFreq = (double(maxbin) * sr) / fftSize;
Chris@905 1807
Chris@905 1808 double displayMinFreq = minFreq;
Chris@905 1809 double displayMaxFreq = maxFreq;
Chris@122 1810
Chris@122 1811 if (fftSize != m_fftSize) {
Chris@122 1812 displayMinFreq = getEffectiveMinFrequency();
Chris@122 1813 displayMaxFreq = getEffectiveMaxFrequency();
Chris@122 1814 }
Chris@122 1815
Chris@682 1816 // cerr << "(giving actual minFreq " << minFreq << " and display minFreq " << displayMinFreq << ")" << endl;
Chris@253 1817
Chris@518 1818 int increment = getWindowIncrement();
Chris@40 1819
Chris@40 1820 bool logarithmic = (m_frequencyScale == LogFrequencyScale);
Chris@1026 1821
Chris@1030 1822 MagnitudeRange overallMag = m_viewMags[v->getId()];
Chris@119 1823 bool overallMagChanged = false;
Chris@119 1824
Chris@137 1825 #ifdef DEBUG_SPECTROGRAM_REPAINT
Chris@1026 1826 cerr << "SpectrogramLayer: " << ((double(v->getFrameForX(1) - v->getFrameForX(0))) / increment) << " bin(s) per pixel" << endl;
Chris@137 1827 #endif
Chris@137 1828
Chris@1024 1829 if (repaintWidth == 0) {
Chris@1024 1830 SVDEBUG << "*** NOTE: repaintWidth == 0" << endl;
Chris@331 1831 }
Chris@331 1832
Chris@382 1833 Profiler outerprof("SpectrogramLayer::paint: all cols");
Chris@382 1834
Chris@481 1835 // The draw buffer contains a fragment at either our pixel
Chris@481 1836 // resolution (if there is more than one time-bin per pixel) or
Chris@481 1837 // time-bin resolution (if a time-bin spans more than one pixel).
Chris@481 1838 // We need to ensure that it starts and ends at points where a
Chris@481 1839 // time-bin boundary occurs at an exact pixel boundary, and with a
Chris@481 1840 // certain amount of overlap across existing pixels so that we can
Chris@481 1841 // scale and draw from it without smoothing errors at the edges.
Chris@481 1842
Chris@481 1843 // If (getFrameForX(x) / increment) * increment ==
Chris@481 1844 // getFrameForX(x), then x is a time-bin boundary. We want two
Chris@481 1845 // such boundaries at either side of the draw buffer -- one which
Chris@481 1846 // we draw up to, and one which we subsequently crop at.
Chris@481 1847
Chris@481 1848 bool bufferBinResolution = false;
Chris@481 1849 if (increment > zoomLevel) bufferBinResolution = true;
Chris@481 1850
Chris@907 1851 sv_frame_t leftBoundaryFrame = -1, leftCropFrame = -1;
Chris@907 1852 sv_frame_t rightBoundaryFrame = -1, rightCropFrame = -1;
Chris@481 1853
Chris@481 1854 int bufwid;
Chris@481 1855
Chris@481 1856 if (bufferBinResolution) {
Chris@481 1857
Chris@482 1858 for (int x = x0; ; --x) {
Chris@907 1859 sv_frame_t f = v->getFrameForX(x);
Chris@481 1860 if ((f / increment) * increment == f) {
Chris@481 1861 if (leftCropFrame == -1) leftCropFrame = f;
Chris@1024 1862 else if (x < x0 - 2) {
Chris@1024 1863 leftBoundaryFrame = f;
Chris@1024 1864 break;
Chris@1024 1865 }
Chris@481 1866 }
Chris@481 1867 }
Chris@1024 1868 for (int x = x0 + repaintWidth; ; ++x) {
Chris@907 1869 sv_frame_t f = v->getFrameForX(x);
Chris@481 1870 if ((f / increment) * increment == f) {
Chris@481 1871 if (rightCropFrame == -1) rightCropFrame = f;
Chris@1024 1872 else if (x > x0 + repaintWidth + 2) {
Chris@1024 1873 rightBoundaryFrame = f;
Chris@1024 1874 break;
Chris@1024 1875 }
Chris@481 1876 }
Chris@481 1877 }
Chris@485 1878 #ifdef DEBUG_SPECTROGRAM_REPAINT
Chris@481 1879 cerr << "Left: crop: " << leftCropFrame << " (bin " << leftCropFrame/increment << "); boundary: " << leftBoundaryFrame << " (bin " << leftBoundaryFrame/increment << ")" << endl;
Chris@481 1880 cerr << "Right: crop: " << rightCropFrame << " (bin " << rightCropFrame/increment << "); boundary: " << rightBoundaryFrame << " (bin " << rightBoundaryFrame/increment << ")" << endl;
Chris@485 1881 #endif
Chris@481 1882
Chris@907 1883 bufwid = int((rightBoundaryFrame - leftBoundaryFrame) / increment);
Chris@481 1884
Chris@481 1885 } else {
Chris@481 1886
Chris@1024 1887 bufwid = repaintWidth;
Chris@481 1888 }
Chris@481 1889
Chris@907 1890 vector<int> binforx(bufwid);
Chris@907 1891 vector<double> binfory(h);
Chris@907 1892
Chris@484 1893 bool usePeaksCache = false;
Chris@484 1894
Chris@481 1895 if (bufferBinResolution) {
Chris@481 1896 for (int x = 0; x < bufwid; ++x) {
Chris@907 1897 binforx[x] = int(leftBoundaryFrame / increment) + x;
Chris@481 1898 }
Chris@481 1899 m_drawBuffer = QImage(bufwid, h, QImage::Format_Indexed8);
Chris@481 1900 } else {
Chris@481 1901 for (int x = 0; x < bufwid; ++x) {
Chris@905 1902 double s0 = 0, s1 = 0;
Chris@481 1903 if (getXBinRange(v, x + x0, s0, s1)) {
Chris@481 1904 binforx[x] = int(s0 + 0.0001);
Chris@481 1905 } else {
Chris@487 1906 binforx[x] = -1; //???
Chris@481 1907 }
Chris@481 1908 }
Chris@1031 1909 if (m_drawBuffer.width() < bufwid || m_drawBuffer.height() != h) {
Chris@481 1910 m_drawBuffer = QImage(bufwid, h, QImage::Format_Indexed8);
Chris@480 1911 }
Chris@484 1912 usePeaksCache = (increment * 8) < zoomLevel;
Chris@487 1913 if (m_colourScale == PhaseColourScale) usePeaksCache = false;
Chris@480 1914 }
Chris@481 1915
Chris@481 1916 for (int pixel = 0; pixel < 256; ++pixel) {
Chris@907 1917 m_drawBuffer.setColor((unsigned char)pixel,
Chris@907 1918 m_palette.getColour((unsigned char)pixel).rgb());
Chris@481 1919 }
Chris@481 1920
Chris@481 1921 m_drawBuffer.fill(0);
Chris@1024 1922 int attainedBufwid = bufwid;
Chris@480 1923
Chris@488 1924 if (m_binDisplay != PeakFrequencies) {
Chris@488 1925
Chris@488 1926 for (int y = 0; y < h; ++y) {
Chris@905 1927 double q0 = 0, q1 = 0;
Chris@488 1928 if (!getSmoothedYBinRange(v, h-y-1, q0, q1)) {
Chris@488 1929 binfory[y] = -1;
Chris@488 1930 } else {
Chris@490 1931 binfory[y] = q0;
Chris@488 1932 }
Chris@480 1933 }
Chris@488 1934
Chris@1024 1935 attainedBufwid =
Chris@1026 1936 paintDrawBuffer(v, bufwid, h, binforx, binfory,
Chris@1026 1937 usePeaksCache,
Chris@1026 1938 overallMag, overallMagChanged,
Chris@1026 1939 rightToLeft);
Chris@488 1940
Chris@488 1941 } else {
Chris@488 1942
Chris@1024 1943 attainedBufwid =
Chris@1024 1944 paintDrawBufferPeakFrequencies(v, bufwid, h, binforx,
Chris@1024 1945 minbin, maxbin,
Chris@1024 1946 displayMinFreq, displayMaxFreq,
Chris@1024 1947 logarithmic,
Chris@1026 1948 overallMag, overallMagChanged,
Chris@1026 1949 rightToLeft);
Chris@480 1950 }
Chris@481 1951
Chris@1024 1952 int failedToRepaint = bufwid - attainedBufwid;
Chris@1031 1953
Chris@1031 1954 int paintedLeft = x0;
Chris@1031 1955 int paintedWidth = x1 - x0;
Chris@1031 1956
Chris@1025 1957 if (failedToRepaint > 0) {
Chris@1031 1958
Chris@1025 1959 #ifdef DEBUG_SPECTROGRAM_REPAINT
Chris@1026 1960 cerr << "SpectrogramLayer::paint(): Failed to repaint " << failedToRepaint << " of " << bufwid
Chris@1029 1961 << " columns in time (so managed to repaint " << bufwid - failedToRepaint << ")" << endl;
Chris@1025 1962 #endif
Chris@1031 1963
Chris@1031 1964 if (rightToLeft) {
Chris@1031 1965 paintedLeft += failedToRepaint;
Chris@1031 1966 }
Chris@1031 1967
Chris@1031 1968 paintedWidth -= failedToRepaint;
Chris@1031 1969
Chris@1031 1970 if (paintedWidth < 0) {
Chris@1031 1971 paintedWidth = 0;
Chris@1031 1972 }
Chris@1031 1973
Chris@1025 1974 } else if (failedToRepaint < 0) {
Chris@1024 1975 cerr << "WARNING: failedToRepaint < 0 (= " << failedToRepaint << ")"
Chris@1024 1976 << endl;
Chris@1024 1977 failedToRepaint = 0;
Chris@1024 1978 }
Chris@1031 1979
Chris@119 1980 if (overallMagChanged) {
Chris@1030 1981 m_viewMags[v->getId()] = overallMag;
Chris@209 1982 #ifdef DEBUG_SPECTROGRAM_REPAINT
Chris@1030 1983 cerr << "SpectrogramLayer: Overall mag is now [" << m_viewMags[v->getId()].getMin() << "->" << m_viewMags[v->getId()].getMax() << "] - will be updating" << endl;
Chris@209 1984 #endif
Chris@119 1985 }
Chris@119 1986
Chris@382 1987 outerprof.end();
Chris@382 1988
Chris@382 1989 Profiler profiler2("SpectrogramLayer::paint: draw image");
Chris@137 1990
Chris@1031 1991 if (paintedWidth > 0) {
Chris@1024 1992
Chris@224 1993 #ifdef DEBUG_SPECTROGRAM_REPAINT
Chris@1031 1994 cerr << "SpectrogramLayer: Copying " << paintedWidth << "x" << h
Chris@1031 1995 << " from draw buffer at " << paintedLeft - x0 << "," << 0
Chris@1031 1996 << " to " << paintedWidth << "x" << h << " on cache at "
Chris@585 1997 << x0 << "," << 0 << endl;
Chris@224 1998 #endif
Chris@224 1999
Chris@481 2000 if (bufferBinResolution) {
Chris@1031 2001
Chris@481 2002 int scaledLeft = v->getXForFrame(leftBoundaryFrame);
Chris@481 2003 int scaledRight = v->getXForFrame(rightBoundaryFrame);
Chris@1031 2004
Chris@485 2005 #ifdef DEBUG_SPECTROGRAM_REPAINT
Chris@1026 2006 cerr << "SpectrogramLayer: Rescaling image from " << bufwid
Chris@481 2007 << "x" << h << " to "
Chris@481 2008 << scaledRight-scaledLeft << "x" << h << endl;
Chris@485 2009 #endif
Chris@1031 2010
Chris@490 2011 Preferences::SpectrogramXSmoothing xsmoothing =
Chris@490 2012 Preferences::getInstance()->getSpectrogramXSmoothing();
Chris@1026 2013
Chris@481 2014 QImage scaled = m_drawBuffer.scaled
Chris@481 2015 (scaledRight - scaledLeft, h,
Chris@490 2016 Qt::IgnoreAspectRatio,
Chris@490 2017 ((xsmoothing == Preferences::SpectrogramXInterpolated) ?
Chris@490 2018 Qt::SmoothTransformation : Qt::FastTransformation));
Chris@1026 2019
Chris@481 2020 int scaledLeftCrop = v->getXForFrame(leftCropFrame);
Chris@481 2021 int scaledRightCrop = v->getXForFrame(rightCropFrame);
Chris@1031 2022
Chris@485 2023 #ifdef DEBUG_SPECTROGRAM_REPAINT
Chris@1026 2024 cerr << "SpectrogramLayer: Drawing image region of width " << scaledRightCrop - scaledLeftCrop << " to "
Chris@481 2025 << scaledLeftCrop << " from " << scaledLeftCrop - scaledLeft << endl;
Chris@485 2026 #endif
Chris@1030 2027
Chris@1031 2028 //!!! Update this for failedToRepaint logic
Chris@1031 2029
Chris@1030 2030 cache.drawImage
Chris@1030 2031 (scaledLeftCrop,
Chris@1030 2032 scaledRightCrop - scaledLeftCrop,
Chris@481 2033 scaled,
Chris@1030 2034 scaledLeftCrop - scaledLeft,
Chris@1030 2035 scaledRightCrop - scaledLeftCrop);
Chris@1024 2036
Chris@481 2037 } else {
Chris@1024 2038
Chris@1031 2039 cache.drawImage(paintedLeft, paintedWidth,
Chris@1030 2040 m_drawBuffer,
Chris@1031 2041 paintedLeft - x0, paintedWidth);
Chris@481 2042 }
Chris@331 2043 }
Chris@331 2044
Chris@1026 2045 #ifdef DEBUG_SPECTROGRAM_REPAINT
Chris@1030 2046 cerr << "SpectrogramLayer: Cache valid area now from " << cache.getValidLeft()
Chris@1030 2047 << " width " << cache.getValidWidth() << ", height "
Chris@1030 2048 << cache.getSize().height() << endl;
Chris@1026 2049 #endif
Chris@1030 2050
Chris@1030 2051 QRect pr = rect & cache.getValidArea();
Chris@337 2052
Chris@337 2053 #ifdef DEBUG_SPECTROGRAM_REPAINT
Chris@1026 2054 cerr << "SpectrogramLayer: Copying " << pr.width() << "x" << pr.height()
Chris@337 2055 << " from cache at " << pr.x() << "," << pr.y()
Chris@585 2056 << " to window" << endl;
Chris@337 2057 #endif
Chris@337 2058
Chris@1030 2059 paint.drawImage(pr.x(), pr.y(), cache.getImage(),
Chris@479 2060 pr.x(), pr.y(), pr.width(), pr.height());
Chris@337 2061
Chris@389 2062 if (!m_synchronous) {
Chris@389 2063
Chris@862 2064 if ((m_normalization != NormalizeVisibleArea) || !overallMagChanged) {
Chris@1031 2065
Chris@1031 2066 QRect areaLeft(0, 0, cache.getValidLeft(), h);
Chris@1031 2067 QRect areaRight(cache.getValidRight(), 0,
Chris@1031 2068 cache.getSize().width() - cache.getValidRight(), h);
Chris@1031 2069
Chris@1031 2070 bool haveSpaceLeft = (areaLeft.width() > 0);
Chris@1031 2071 bool haveSpaceRight = (areaRight.width() > 0);
Chris@1031 2072
Chris@1031 2073 bool updateLeft = haveSpaceLeft;
Chris@1031 2074 bool updateRight = haveSpaceRight;
Chris@1031 2075
Chris@1031 2076 if (updateLeft && updateRight) {
Chris@1031 2077 if (rightToLeft) {
Chris@1031 2078 // we just did something adjoining the cache on
Chris@1031 2079 // its left side, so now do something on its right
Chris@1031 2080 updateLeft = false;
Chris@1031 2081 } else {
Chris@1031 2082 updateRight = false;
Chris@1031 2083 }
Chris@389 2084 }
Chris@389 2085
Chris@1031 2086 if (updateLeft) {
Chris@1031 2087 #ifdef DEBUG_SPECTROGRAM_REPAINT
Chris@1031 2088 cerr << "SpectrogramLayer::paint() updating left ("
Chris@1031 2089 << areaLeft.x() << ", "
Chris@1031 2090 << areaLeft.width() << ")" << endl;
Chris@1031 2091 #endif
Chris@1031 2092 v->updatePaintRect(areaLeft);
Chris@1031 2093 }
Chris@1031 2094
Chris@1031 2095 if (updateRight) {
Chris@389 2096 #ifdef DEBUG_SPECTROGRAM_REPAINT
Chris@985 2097 cerr << "SpectrogramLayer::paint() updating right ("
Chris@1031 2098 << areaRight.x() << ", "
Chris@1031 2099 << areaRight.width() << ")" << endl;
Chris@389 2100 #endif
Chris@1031 2101 v->updatePaintRect(areaRight);
Chris@389 2102 }
Chris@1031 2103
Chris@389 2104 } else {
Chris@389 2105 // overallMagChanged
Chris@682 2106 cerr << "\noverallMagChanged - updating all\n" << endl;
Chris@1030 2107 cache.invalidate();
Chris@1030 2108 v->updatePaintRect(v->getPaintRect());
Chris@119 2109 }
Chris@95 2110 }
Chris@0 2111
Chris@121 2112 illuminateLocalFeatures(v, paint);
Chris@120 2113
Chris@0 2114 #ifdef DEBUG_SPECTROGRAM_REPAINT
Chris@985 2115 cerr << "SpectrogramLayer::paint() returning" << endl;
Chris@0 2116 #endif
Chris@0 2117 }
Chris@0 2118
Chris@1024 2119 int
Chris@918 2120 SpectrogramLayer::paintDrawBufferPeakFrequencies(LayerGeometryProvider *v,
Chris@488 2121 int w,
Chris@488 2122 int h,
Chris@907 2123 const vector<int> &binforx,
Chris@488 2124 int minbin,
Chris@488 2125 int maxbin,
Chris@905 2126 double displayMinFreq,
Chris@905 2127 double displayMaxFreq,
Chris@491 2128 bool logarithmic,
Chris@491 2129 MagnitudeRange &overallMag,
Chris@1026 2130 bool &overallMagChanged,
Chris@1026 2131 bool rightToLeft) const
Chris@488 2132 {
Chris@488 2133 Profiler profiler("SpectrogramLayer::paintDrawBufferPeakFrequencies");
Chris@488 2134
Chris@488 2135 #ifdef DEBUG_SPECTROGRAM_REPAINT
Chris@1026 2136 cerr << "SpectrogramLayer::paintDrawBufferPeakFrequencies: minbin " << minbin << ", maxbin " << maxbin << "; w " << w << ", h " << h << endl;
Chris@488 2137 #endif
Chris@488 2138 if (minbin < 0) minbin = 0;
Chris@488 2139 if (maxbin < 0) maxbin = minbin+1;
Chris@488 2140
Chris@488 2141 FFTModel *fft = getFFTModel(v);
Chris@1024 2142 if (!fft) return 0;
Chris@488 2143
Chris@488 2144 FFTModel::PeakSet peakfreqs;
Chris@488 2145
Chris@848 2146 int psx = -1;
Chris@545 2147
Chris@545 2148 #ifdef __GNUC__
Chris@488 2149 float values[maxbin - minbin + 1];
Chris@545 2150 #else
Chris@545 2151 float *values = (float *)alloca((maxbin - minbin + 1) * sizeof(float));
Chris@545 2152 #endif
Chris@488 2153
Chris@1027 2154 int minColumns = 4;
Chris@1027 2155 double maxTime = 0.15; // seconds; only for non-synchronous drawing
Chris@1027 2156 auto startTime = chrono::steady_clock::now();
Chris@1027 2157
Chris@1026 2158 int start = 0;
Chris@1026 2159 int finish = w;
Chris@1026 2160 int step = 1;
Chris@1026 2161
Chris@1026 2162 if (rightToLeft) {
Chris@1026 2163 start = w-1;
Chris@1026 2164 finish = -1;
Chris@1026 2165 step = -1;
Chris@1026 2166 }
Chris@1026 2167
Chris@1027 2168 int columnCount = 0;
Chris@1027 2169
Chris@1026 2170 for (int x = start; x != finish; x += step) {
Chris@488 2171
Chris@1027 2172 ++columnCount;
Chris@1027 2173
Chris@488 2174 if (binforx[x] < 0) continue;
Chris@488 2175
Chris@488 2176 int sx0 = binforx[x];
Chris@488 2177 int sx1 = sx0;
Chris@488 2178 if (x+1 < w) sx1 = binforx[x+1];
Chris@488 2179 if (sx0 < 0) sx0 = sx1 - 1;
Chris@488 2180 if (sx0 < 0) continue;
Chris@488 2181 if (sx1 <= sx0) sx1 = sx0 + 1;
Chris@488 2182
Chris@488 2183 for (int sx = sx0; sx < sx1; ++sx) {
Chris@488 2184
Chris@488 2185 if (sx < 0 || sx >= int(fft->getWidth())) continue;
Chris@488 2186
Chris@488 2187 MagnitudeRange mag;
Chris@488 2188
Chris@488 2189 if (sx != psx) {
Chris@488 2190 peakfreqs = fft->getPeakFrequencies(FFTModel::AllPeaks, sx,
Chris@488 2191 minbin, maxbin - 1);
Chris@488 2192 if (m_colourScale == PhaseColourScale) {
Chris@488 2193 fft->getPhasesAt(sx, values, minbin, maxbin - minbin + 1);
Chris@862 2194 } else if (m_normalization == NormalizeColumns) {
Chris@488 2195 fft->getNormalizedMagnitudesAt(sx, values, minbin, maxbin - minbin + 1);
Chris@862 2196 } else if (m_normalization == NormalizeHybrid) {
Chris@719 2197 fft->getNormalizedMagnitudesAt(sx, values, minbin, maxbin - minbin + 1);
Chris@905 2198 double max = fft->getMaximumMagnitudeAt(sx);
Chris@719 2199 if (max > 0.f) {
Chris@719 2200 for (int i = minbin; i <= maxbin; ++i) {
Chris@907 2201 values[i - minbin] = float(values[i - minbin] * log10(max));
Chris@719 2202 }
Chris@719 2203 }
Chris@488 2204 } else {
Chris@488 2205 fft->getMagnitudesAt(sx, values, minbin, maxbin - minbin + 1);
Chris@488 2206 }
Chris@488 2207 psx = sx;
Chris@488 2208 }
Chris@488 2209
Chris@488 2210 for (FFTModel::PeakSet::const_iterator pi = peakfreqs.begin();
Chris@488 2211 pi != peakfreqs.end(); ++pi) {
Chris@488 2212
Chris@488 2213 int bin = pi->first;
Chris@907 2214 double freq = pi->second;
Chris@488 2215
Chris@488 2216 if (bin < minbin) continue;
Chris@488 2217 if (bin > maxbin) break;
Chris@488 2218
Chris@907 2219 double value = values[bin - minbin];
Chris@488 2220
Chris@488 2221 if (m_colourScale != PhaseColourScale) {
Chris@862 2222 if (m_normalization != NormalizeColumns) {
Chris@907 2223 value /= (m_fftSize/2.0);
Chris@488 2224 }
Chris@907 2225 mag.sample(float(value));
Chris@488 2226 value *= m_gain;
Chris@488 2227 }
Chris@488 2228
Chris@905 2229 double y = v->getYForFrequency
Chris@488 2230 (freq, displayMinFreq, displayMaxFreq, logarithmic);
Chris@488 2231
Chris@558 2232 int iy = int(y + 0.5);
Chris@558 2233 if (iy < 0 || iy >= h) continue;
Chris@558 2234
Chris@558 2235 m_drawBuffer.setPixel(x, iy, getDisplayValue(v, value));
Chris@488 2236 }
Chris@488 2237
Chris@488 2238 if (mag.isSet()) {
Chris@488 2239 if (sx >= int(m_columnMags.size())) {
Chris@540 2240 #ifdef DEBUG_SPECTROGRAM
Chris@682 2241 cerr << "INTERNAL ERROR: " << sx << " >= "
Chris@488 2242 << m_columnMags.size()
Chris@488 2243 << " at SpectrogramLayer.cpp::paintDrawBuffer"
Chris@682 2244 << endl;
Chris@540 2245 #endif
Chris@490 2246 } else {
Chris@490 2247 m_columnMags[sx].sample(mag);
Chris@491 2248 if (overallMag.sample(mag)) overallMagChanged = true;
Chris@488 2249 }
Chris@488 2250 }
Chris@488 2251 }
Chris@1027 2252
Chris@1027 2253 if (!m_synchronous) {
Chris@1027 2254 if (columnCount >= minColumns) {
Chris@1027 2255 auto t = chrono::steady_clock::now();
Chris@1027 2256 double diff = chrono::duration<double>(t - startTime).count();
Chris@1027 2257 if (diff > maxTime) {
Chris@1027 2258 #ifdef DEBUG_SPECTROGRAM_REPAINT
Chris@1027 2259 cerr << "SpectrogramLayer::paintDrawBufferPeakFrequencies: Max time " << maxTime << " sec exceeded after "
Chris@1031 2260 << columnCount << " columns with time " << diff << endl;
Chris@1027 2261 #endif
Chris@1027 2262 return columnCount;
Chris@1027 2263 }
Chris@1027 2264 }
Chris@1027 2265 }
Chris@488 2266 }
Chris@1024 2267
Chris@1027 2268 return columnCount;
Chris@488 2269 }
Chris@488 2270
Chris@1024 2271 int
Chris@918 2272 SpectrogramLayer::paintDrawBuffer(LayerGeometryProvider *v,
Chris@481 2273 int w,
Chris@481 2274 int h,
Chris@907 2275 const vector<int> &binforx,
Chris@907 2276 const vector<double> &binfory,
Chris@491 2277 bool usePeaksCache,
Chris@491 2278 MagnitudeRange &overallMag,
Chris@1026 2279 bool &overallMagChanged,
Chris@1026 2280 bool rightToLeft) const
Chris@480 2281 {
Chris@481 2282 Profiler profiler("SpectrogramLayer::paintDrawBuffer");
Chris@480 2283
Chris@490 2284 int minbin = int(binfory[0] + 0.0001);
Chris@907 2285 int maxbin = int(binfory[h-1]);
Chris@480 2286
Chris@485 2287 #ifdef DEBUG_SPECTROGRAM_REPAINT
Chris@1026 2288 cerr << "SpectrogramLayer::paintDrawBuffer: minbin " << minbin << ", maxbin " << maxbin << "; w " << w << ", h " << h << endl;
Chris@485 2289 #endif
Chris@480 2290 if (minbin < 0) minbin = 0;
Chris@480 2291 if (maxbin < 0) maxbin = minbin+1;
Chris@480 2292
Chris@484 2293 DenseThreeDimensionalModel *sourceModel = 0;
Chris@484 2294 FFTModel *fft = 0;
Chris@484 2295 int divisor = 1;
Chris@485 2296 #ifdef DEBUG_SPECTROGRAM_REPAINT
Chris@1026 2297 cerr << "SpectrogramLayer::paintDrawBuffer: Note: bin display = " << m_binDisplay << ", w = " << w << ", binforx[" << w-1 << "] = " << binforx[w-1] << ", binforx[0] = " << binforx[0] << endl;
Chris@485 2298 #endif
Chris@484 2299 if (usePeaksCache) { //!!!
Chris@484 2300 sourceModel = getPeakCache(v);
Chris@484 2301 divisor = 8;//!!!
Chris@484 2302 minbin = 0;
Chris@484 2303 maxbin = sourceModel->getHeight();
Chris@484 2304 } else {
Chris@484 2305 sourceModel = fft = getFFTModel(v);
Chris@484 2306 }
Chris@484 2307
Chris@1024 2308 if (!sourceModel) return 0;
Chris@484 2309
Chris@490 2310 bool interpolate = false;
Chris@490 2311 Preferences::SpectrogramSmoothing smoothing =
Chris@490 2312 Preferences::getInstance()->getSpectrogramSmoothing();
Chris@490 2313 if (smoothing == Preferences::SpectrogramInterpolated ||
Chris@490 2314 smoothing == Preferences::SpectrogramZeroPaddedAndInterpolated) {
Chris@490 2315 if (m_binDisplay != PeakBins &&
Chris@490 2316 m_binDisplay != PeakFrequencies) {
Chris@490 2317 interpolate = true;
Chris@490 2318 }
Chris@490 2319 }
Chris@490 2320
Chris@480 2321 int psx = -1;
Chris@545 2322
Chris@545 2323 #ifdef __GNUC__
Chris@490 2324 float autoarray[maxbin - minbin + 1];
Chris@545 2325 float peaks[h];
Chris@545 2326 #else
Chris@545 2327 float *autoarray = (float *)alloca((maxbin - minbin + 1) * sizeof(float));
Chris@545 2328 float *peaks = (float *)alloca(h * sizeof(float));
Chris@545 2329 #endif
Chris@545 2330
Chris@490 2331 const float *values = autoarray;
Chris@484 2332 DenseThreeDimensionalModel::Column c;
Chris@480 2333
Chris@1027 2334 int minColumns = 4;
Chris@1027 2335 double maxTime = 0.1; // seconds; only for non-synchronous drawing
Chris@1027 2336 auto startTime = chrono::steady_clock::now();
Chris@1027 2337
Chris@1026 2338 int start = 0;
Chris@1026 2339 int finish = w;
Chris@1026 2340 int step = 1;
Chris@1026 2341
Chris@1026 2342 if (rightToLeft) {
Chris@1026 2343 start = w-1;
Chris@1026 2344 finish = -1;
Chris@1026 2345 step = -1;
Chris@1026 2346 }
Chris@1027 2347
Chris@1027 2348 int columnCount = 0;
Chris@1026 2349
Chris@1026 2350 for (int x = start; x != finish; x += step) {
Chris@1027 2351
Chris@1027 2352 ++columnCount;
Chris@480 2353
Chris@482 2354 if (binforx[x] < 0) continue;
Chris@482 2355
Chris@488 2356 // float columnGain = m_gain;
Chris@487 2357 float columnMax = 0.f;
Chris@487 2358
Chris@484 2359 int sx0 = binforx[x] / divisor;
Chris@483 2360 int sx1 = sx0;
Chris@484 2361 if (x+1 < w) sx1 = binforx[x+1] / divisor;
Chris@483 2362 if (sx0 < 0) sx0 = sx1 - 1;
Chris@483 2363 if (sx0 < 0) continue;
Chris@483 2364 if (sx1 <= sx0) sx1 = sx0 + 1;
Chris@483 2365
Chris@483 2366 for (int y = 0; y < h; ++y) peaks[y] = 0.f;
Chris@480 2367
Chris@483 2368 for (int sx = sx0; sx < sx1; ++sx) {
Chris@483 2369
Chris@518 2370 #ifdef DEBUG_SPECTROGRAM_REPAINT
Chris@682 2371 // cerr << "sx = " << sx << endl;
Chris@518 2372 #endif
Chris@518 2373
Chris@484 2374 if (sx < 0 || sx >= int(sourceModel->getWidth())) continue;
Chris@483 2375
Chris@488 2376 MagnitudeRange mag;
Chris@488 2377
Chris@483 2378 if (sx != psx) {
Chris@484 2379 if (fft) {
Chris@485 2380 #ifdef DEBUG_SPECTROGRAM_REPAINT
Chris@1026 2381 // cerr << "Retrieving column " << sx << " from fft directly" << endl;
Chris@485 2382 #endif
Chris@487 2383 if (m_colourScale == PhaseColourScale) {
Chris@490 2384 fft->getPhasesAt(sx, autoarray, minbin, maxbin - minbin + 1);
Chris@862 2385 } else if (m_normalization == NormalizeColumns) {
Chris@490 2386 fft->getNormalizedMagnitudesAt(sx, autoarray, minbin, maxbin - minbin + 1);
Chris@862 2387 } else if (m_normalization == NormalizeHybrid) {
Chris@719 2388 fft->getNormalizedMagnitudesAt(sx, autoarray, minbin, maxbin - minbin + 1);
Chris@988 2389 float max = fft->getMaximumMagnitudeAt(sx);
Chris@988 2390 float scale = log10f(max + 1.f);
Chris@998 2391 // cout << "sx = " << sx << ", max = " << max << ", log10(max) = " << log10(max) << ", scale = " << scale << endl;
Chris@719 2392 for (int i = minbin; i <= maxbin; ++i) {
Chris@862 2393 autoarray[i - minbin] *= scale;
Chris@719 2394 }
Chris@487 2395 } else {
Chris@490 2396 fft->getMagnitudesAt(sx, autoarray, minbin, maxbin - minbin + 1);
Chris@487 2397 }
Chris@484 2398 } else {
Chris@485 2399 #ifdef DEBUG_SPECTROGRAM_REPAINT
Chris@1026 2400 // cerr << "Retrieving column " << sx << " from peaks cache" << endl;
Chris@485 2401 #endif
Chris@484 2402 c = sourceModel->getColumn(sx);
Chris@862 2403 if (m_normalization == NormalizeColumns ||
Chris@862 2404 m_normalization == NormalizeHybrid) {
Chris@487 2405 for (int y = 0; y < h; ++y) {
Chris@487 2406 if (c[y] > columnMax) columnMax = c[y];
Chris@487 2407 }
Chris@487 2408 }
Chris@1019 2409 values = c.data() + minbin;
Chris@484 2410 }
Chris@483 2411 psx = sx;
Chris@483 2412 }
Chris@483 2413
Chris@483 2414 for (int y = 0; y < h; ++y) {
Chris@480 2415
Chris@905 2416 double sy0 = binfory[y];
Chris@905 2417 double sy1 = sy0 + 1;
Chris@481 2418 if (y+1 < h) sy1 = binfory[y+1];
Chris@490 2419
Chris@907 2420 double value = 0.0;
Chris@907 2421
Chris@907 2422 if (interpolate && fabs(sy1 - sy0) < 1.0) {
Chris@490 2423
Chris@905 2424 double centre = (sy0 + sy1) / 2;
Chris@907 2425 double dist = (centre - 0.5) - rint(centre - 0.5);
Chris@490 2426 int bin = int(centre);
Chris@490 2427 int other = (dist < 0 ? (bin-1) : (bin+1));
Chris@490 2428 if (bin < minbin) bin = minbin;
Chris@490 2429 if (bin > maxbin) bin = maxbin;
Chris@490 2430 if (other < minbin || other > maxbin) other = bin;
Chris@907 2431 double prop = 1.0 - fabs(dist);
Chris@905 2432
Chris@905 2433 double v0 = values[bin - minbin];
Chris@905 2434 double v1 = values[other - minbin];
Chris@490 2435 if (m_binDisplay == PeakBins) {
Chris@490 2436 if (bin == minbin || bin == maxbin ||
Chris@490 2437 v0 < values[bin-minbin-1] ||
Chris@907 2438 v0 < values[bin-minbin+1]) v0 = 0.0;
Chris@490 2439 if (other == minbin || other == maxbin ||
Chris@490 2440 v1 < values[other-minbin-1] ||
Chris@907 2441 v1 < values[other-minbin+1]) v1 = 0.0;
Chris@489 2442 }
Chris@907 2443 if (v0 == 0.0 && v1 == 0.0) continue;
Chris@907 2444 value = prop * v0 + (1.0 - prop) * v1;
Chris@484 2445
Chris@488 2446 if (m_colourScale != PhaseColourScale) {
Chris@862 2447 if (m_normalization != NormalizeColumns &&
Chris@862 2448 m_normalization != NormalizeHybrid) {
Chris@907 2449 value /= (m_fftSize/2.0);
Chris@488 2450 }
Chris@907 2451 mag.sample(float(value));
Chris@488 2452 value *= m_gain;
Chris@488 2453 }
Chris@488 2454
Chris@907 2455 peaks[y] = float(value);
Chris@490 2456
Chris@490 2457 } else {
Chris@490 2458
Chris@490 2459 int by0 = int(sy0 + 0.0001);
Chris@490 2460 int by1 = int(sy1 + 0.0001);
Chris@490 2461 if (by1 < by0 + 1) by1 = by0 + 1;
Chris@490 2462
Chris@490 2463 for (int bin = by0; bin < by1; ++bin) {
Chris@490 2464
Chris@490 2465 value = values[bin - minbin];
Chris@490 2466 if (m_binDisplay == PeakBins) {
Chris@490 2467 if (bin == minbin || bin == maxbin ||
Chris@490 2468 value < values[bin-minbin-1] ||
Chris@490 2469 value < values[bin-minbin+1]) continue;
Chris@480 2470 }
Chris@490 2471
Chris@490 2472 if (m_colourScale != PhaseColourScale) {
Chris@862 2473 if (m_normalization != NormalizeColumns &&
Chris@862 2474 m_normalization != NormalizeHybrid) {
Chris@907 2475 value /= (m_fftSize/2.0);
Chris@490 2476 }
Chris@907 2477 mag.sample(float(value));
Chris@490 2478 value *= m_gain;
Chris@490 2479 }
Chris@490 2480
Chris@907 2481 if (value > peaks[y]) {
Chris@907 2482 peaks[y] = float(value); //!!! not right for phase!
Chris@907 2483 }
Chris@480 2484 }
Chris@480 2485 }
Chris@483 2486 }
Chris@488 2487
Chris@488 2488 if (mag.isSet()) {
Chris@488 2489 if (sx >= int(m_columnMags.size())) {
Chris@540 2490 #ifdef DEBUG_SPECTROGRAM
Chris@682 2491 cerr << "INTERNAL ERROR: " << sx << " >= "
Chris@488 2492 << m_columnMags.size()
Chris@488 2493 << " at SpectrogramLayer.cpp::paintDrawBuffer"
Chris@682 2494 << endl;
Chris@540 2495 #endif
Chris@490 2496 } else {
Chris@490 2497 m_columnMags[sx].sample(mag);
Chris@491 2498 if (overallMag.sample(mag)) overallMagChanged = true;
Chris@488 2499 }
Chris@488 2500 }
Chris@483 2501 }
Chris@483 2502
Chris@483 2503 for (int y = 0; y < h; ++y) {
Chris@483 2504
Chris@905 2505 double peak = peaks[y];
Chris@483 2506
Chris@488 2507 if (m_colourScale != PhaseColourScale &&
Chris@862 2508 (m_normalization == NormalizeColumns ||
Chris@862 2509 m_normalization == NormalizeHybrid) &&
Chris@488 2510 columnMax > 0.f) {
Chris@488 2511 peak /= columnMax;
Chris@862 2512 if (m_normalization == NormalizeHybrid) {
Chris@862 2513 peak *= log10(columnMax + 1.f);
Chris@719 2514 }
Chris@480 2515 }
Chris@483 2516
Chris@483 2517 unsigned char peakpix = getDisplayValue(v, peak);
Chris@480 2518
Chris@480 2519 m_drawBuffer.setPixel(x, h-y-1, peakpix);
Chris@480 2520 }
Chris@1025 2521
Chris@1025 2522 if (!m_synchronous) {
Chris@1027 2523 if (columnCount >= minColumns) {
Chris@1025 2524 auto t = chrono::steady_clock::now();
Chris@1025 2525 double diff = chrono::duration<double>(t - startTime).count();
Chris@1025 2526 if (diff > maxTime) {
Chris@1025 2527 #ifdef DEBUG_SPECTROGRAM_REPAINT
Chris@1026 2528 cerr << "SpectrogramLayer::paintDrawBuffer: Max time " << maxTime << " sec exceeded after "
Chris@1031 2529 << columnCount << " columns with time " << diff << endl;
Chris@1025 2530 #endif
Chris@1027 2531 return columnCount;
Chris@1025 2532 }
Chris@1025 2533 }
Chris@1025 2534 }
Chris@480 2535 }
Chris@1024 2536
Chris@1027 2537 return columnCount;
Chris@480 2538 }
Chris@477 2539
Chris@121 2540 void
Chris@918 2541 SpectrogramLayer::illuminateLocalFeatures(LayerGeometryProvider *v, QPainter &paint) const
Chris@121 2542 {
Chris@382 2543 Profiler profiler("SpectrogramLayer::illuminateLocalFeatures");
Chris@382 2544
Chris@121 2545 QPoint localPos;
Chris@121 2546 if (!v->shouldIlluminateLocalFeatures(this, localPos) || !m_model) {
Chris@121 2547 return;
Chris@121 2548 }
Chris@121 2549
Chris@682 2550 // cerr << "SpectrogramLayer: illuminateLocalFeatures("
Chris@682 2551 // << localPos.x() << "," << localPos.y() << ")" << endl;
Chris@121 2552
Chris@905 2553 double s0, s1;
Chris@905 2554 double f0, f1;
Chris@121 2555
Chris@121 2556 if (getXBinRange(v, localPos.x(), s0, s1) &&
Chris@121 2557 getYBinSourceRange(v, localPos.y(), f0, f1)) {
Chris@121 2558
Chris@121 2559 int s0i = int(s0 + 0.001);
Chris@121 2560 int s1i = int(s1);
Chris@121 2561
Chris@121 2562 int x0 = v->getXForFrame(s0i * getWindowIncrement());
Chris@121 2563 int x1 = v->getXForFrame((s1i + 1) * getWindowIncrement());
Chris@121 2564
Chris@248 2565 int y1 = int(getYForFrequency(v, f1));
Chris@248 2566 int y0 = int(getYForFrequency(v, f0));
Chris@121 2567
Chris@682 2568 // cerr << "SpectrogramLayer: illuminate "
Chris@682 2569 // << x0 << "," << y1 << " -> " << x1 << "," << y0 << endl;
Chris@121 2570
Chris@287 2571 paint.setPen(v->getForeground());
Chris@133 2572
Chris@133 2573 //!!! should we be using paintCrosshairs for this?
Chris@133 2574
Chris@121 2575 paint.drawRect(x0, y1, x1 - x0 + 1, y0 - y1 + 1);
Chris@121 2576 }
Chris@121 2577 }
Chris@121 2578
Chris@905 2579 double
Chris@918 2580 SpectrogramLayer::getYForFrequency(const LayerGeometryProvider *v, double frequency) const
Chris@42 2581 {
Chris@44 2582 return v->getYForFrequency(frequency,
Chris@44 2583 getEffectiveMinFrequency(),
Chris@44 2584 getEffectiveMaxFrequency(),
Chris@44 2585 m_frequencyScale == LogFrequencyScale);
Chris@42 2586 }
Chris@42 2587
Chris@905 2588 double
Chris@918 2589 SpectrogramLayer::getFrequencyForY(const LayerGeometryProvider *v, int y) const
Chris@42 2590 {
Chris@44 2591 return v->getFrequencyForY(y,
Chris@44 2592 getEffectiveMinFrequency(),
Chris@44 2593 getEffectiveMaxFrequency(),
Chris@44 2594 m_frequencyScale == LogFrequencyScale);
Chris@42 2595 }
Chris@42 2596
Chris@0 2597 int
Chris@918 2598 SpectrogramLayer::getCompletion(LayerGeometryProvider *v) const
Chris@0 2599 {
Chris@920 2600 const View *view = v->getView();
Chris@920 2601
Chris@1030 2602 if (m_fftModels.find(view->getId()) == m_fftModels.end()) return 100;
Chris@1030 2603
Chris@1030 2604 int completion = m_fftModels[view->getId()]->getCompletion();
Chris@224 2605 #ifdef DEBUG_SPECTROGRAM_REPAINT
Chris@985 2606 cerr << "SpectrogramLayer::getCompletion: completion = " << completion << endl;
Chris@224 2607 #endif
Chris@0 2608 return completion;
Chris@0 2609 }
Chris@0 2610
Chris@583 2611 QString
Chris@918 2612 SpectrogramLayer::getError(LayerGeometryProvider *v) const
Chris@583 2613 {
Chris@920 2614 const View *view = v->getView();
Chris@1030 2615 if (m_fftModels.find(view->getId()) == m_fftModels.end()) return "";
Chris@1030 2616 return m_fftModels[view->getId()]->getError();
Chris@583 2617 }
Chris@583 2618
Chris@28 2619 bool
Chris@905 2620 SpectrogramLayer::getValueExtents(double &min, double &max,
Chris@101 2621 bool &logarithmic, QString &unit) const
Chris@79 2622 {
Chris@133 2623 if (!m_model) return false;
Chris@133 2624
Chris@907 2625 sv_samplerate_t sr = m_model->getSampleRate();
Chris@905 2626 min = double(sr) / m_fftSize;
Chris@905 2627 max = double(sr) / 2;
Chris@133 2628
Chris@101 2629 logarithmic = (m_frequencyScale == LogFrequencyScale);
Chris@79 2630 unit = "Hz";
Chris@79 2631 return true;
Chris@79 2632 }
Chris@79 2633
Chris@79 2634 bool
Chris@905 2635 SpectrogramLayer::getDisplayExtents(double &min, double &max) const
Chris@101 2636 {
Chris@101 2637 min = getEffectiveMinFrequency();
Chris@101 2638 max = getEffectiveMaxFrequency();
Chris@253 2639
Chris@587 2640 // SVDEBUG << "SpectrogramLayer::getDisplayExtents: " << min << "->" << max << endl;
Chris@101 2641 return true;
Chris@101 2642 }
Chris@101 2643
Chris@101 2644 bool
Chris@905 2645 SpectrogramLayer::setDisplayExtents(double min, double max)
Chris@120 2646 {
Chris@120 2647 if (!m_model) return false;
Chris@187 2648
Chris@587 2649 // SVDEBUG << "SpectrogramLayer::setDisplayExtents: " << min << "->" << max << endl;
Chris@187 2650
Chris@120 2651 if (min < 0) min = 0;
Chris@907 2652 if (max > m_model->getSampleRate()/2.0) max = m_model->getSampleRate()/2.0;
Chris@120 2653
Chris@907 2654 int minf = int(lrint(min));
Chris@907 2655 int maxf = int(lrint(max));
Chris@120 2656
Chris@120 2657 if (m_minFrequency == minf && m_maxFrequency == maxf) return true;
Chris@120 2658
Chris@478 2659 invalidateImageCaches();
Chris@120 2660 invalidateMagnitudes();
Chris@120 2661
Chris@120 2662 m_minFrequency = minf;
Chris@120 2663 m_maxFrequency = maxf;
Chris@120 2664
Chris@120 2665 emit layerParametersChanged();
Chris@120 2666
Chris@133 2667 int vs = getCurrentVerticalZoomStep();
Chris@133 2668 if (vs != m_lastEmittedZoomStep) {
Chris@133 2669 emit verticalZoomChanged();
Chris@133 2670 m_lastEmittedZoomStep = vs;
Chris@133 2671 }
Chris@133 2672
Chris@120 2673 return true;
Chris@120 2674 }
Chris@120 2675
Chris@120 2676 bool
Chris@918 2677 SpectrogramLayer::getYScaleValue(const LayerGeometryProvider *v, int y,
Chris@905 2678 double &value, QString &unit) const
Chris@261 2679 {
Chris@261 2680 value = getFrequencyForY(v, y);
Chris@261 2681 unit = "Hz";
Chris@261 2682 return true;
Chris@261 2683 }
Chris@261 2684
Chris@261 2685 bool
Chris@918 2686 SpectrogramLayer::snapToFeatureFrame(LayerGeometryProvider *,
Chris@907 2687 sv_frame_t &frame,
Chris@805 2688 int &resolution,
Chris@28 2689 SnapType snap) const
Chris@13 2690 {
Chris@13 2691 resolution = getWindowIncrement();
Chris@907 2692 sv_frame_t left = (frame / resolution) * resolution;
Chris@907 2693 sv_frame_t right = left + resolution;
Chris@28 2694
Chris@28 2695 switch (snap) {
Chris@28 2696 case SnapLeft: frame = left; break;
Chris@28 2697 case SnapRight: frame = right; break;
Chris@28 2698 case SnapNearest:
Chris@28 2699 case SnapNeighbouring:
Chris@28 2700 if (frame - left > right - frame) frame = right;
Chris@28 2701 else frame = left;
Chris@28 2702 break;
Chris@28 2703 }
Chris@28 2704
Chris@28 2705 return true;
Chris@28 2706 }
Chris@13 2707
Chris@283 2708 void
Chris@918 2709 SpectrogramLayer::measureDoubleClick(LayerGeometryProvider *v, QMouseEvent *e)
Chris@283 2710 {
Chris@920 2711 const View *view = v->getView();
Chris@1030 2712 ScrollableImageCache &cache = getImageCacheReference(view);
Chris@1030 2713
Chris@1030 2714 cerr << "cache width: " << cache.getSize().width() << ", height: "
Chris@1030 2715 << cache.getSize().height() << endl;
Chris@1030 2716
Chris@1030 2717 QImage image = cache.getImage();
Chris@283 2718
Chris@283 2719 ImageRegionFinder finder;
Chris@283 2720 QRect rect = finder.findRegionExtents(&image, e->pos());
Chris@283 2721 if (rect.isValid()) {
Chris@283 2722 MeasureRect mr;
Chris@283 2723 setMeasureRectFromPixrect(v, mr, rect);
Chris@283 2724 CommandHistory::getInstance()->addCommand
Chris@283 2725 (new AddMeasurementRectCommand(this, mr));
Chris@283 2726 }
Chris@283 2727 }
Chris@283 2728
Chris@77 2729 bool
Chris@918 2730 SpectrogramLayer::getCrosshairExtents(LayerGeometryProvider *v, QPainter &paint,
Chris@77 2731 QPoint cursorPos,
Chris@1025 2732 vector<QRect> &extents) const
Chris@77 2733 {
Chris@918 2734 QRect vertical(cursorPos.x() - 12, 0, 12, v->getPaintHeight());
Chris@77 2735 extents.push_back(vertical);
Chris@77 2736
Chris@77 2737 QRect horizontal(0, cursorPos.y(), cursorPos.x(), 1);
Chris@77 2738 extents.push_back(horizontal);
Chris@77 2739
Chris@608 2740 int sw = getVerticalScaleWidth(v, m_haveDetailedScale, paint);
Chris@264 2741
Chris@280 2742 QRect freq(sw, cursorPos.y() - paint.fontMetrics().ascent() - 2,
Chris@280 2743 paint.fontMetrics().width("123456 Hz") + 2,
Chris@280 2744 paint.fontMetrics().height());
Chris@280 2745 extents.push_back(freq);
Chris@264 2746
Chris@279 2747 QRect pitch(sw, cursorPos.y() + 2,
Chris@279 2748 paint.fontMetrics().width("C#10+50c") + 2,
Chris@279 2749 paint.fontMetrics().height());
Chris@279 2750 extents.push_back(pitch);
Chris@279 2751
Chris@280 2752 QRect rt(cursorPos.x(),
Chris@918 2753 v->getPaintHeight() - paint.fontMetrics().height() - 2,
Chris@280 2754 paint.fontMetrics().width("1234.567 s"),
Chris@280 2755 paint.fontMetrics().height());
Chris@280 2756 extents.push_back(rt);
Chris@280 2757
Chris@280 2758 int w(paint.fontMetrics().width("1234567890") + 2);
Chris@280 2759 QRect frame(cursorPos.x() - w - 2,
Chris@918 2760 v->getPaintHeight() - paint.fontMetrics().height() - 2,
Chris@280 2761 w,
Chris@280 2762 paint.fontMetrics().height());
Chris@280 2763 extents.push_back(frame);
Chris@280 2764
Chris@77 2765 return true;
Chris@77 2766 }
Chris@77 2767
Chris@77 2768 void
Chris@918 2769 SpectrogramLayer::paintCrosshairs(LayerGeometryProvider *v, QPainter &paint,
Chris@77 2770 QPoint cursorPos) const
Chris@77 2771 {
Chris@77 2772 paint.save();
Chris@283 2773
Chris@608 2774 int sw = getVerticalScaleWidth(v, m_haveDetailedScale, paint);
Chris@283 2775
Chris@282 2776 QFont fn = paint.font();
Chris@282 2777 if (fn.pointSize() > 8) {
Chris@282 2778 fn.setPointSize(fn.pointSize() - 1);
Chris@282 2779 paint.setFont(fn);
Chris@282 2780 }
Chris@77 2781 paint.setPen(m_crosshairColour);
Chris@77 2782
Chris@77 2783 paint.drawLine(0, cursorPos.y(), cursorPos.x() - 1, cursorPos.y());
Chris@918 2784 paint.drawLine(cursorPos.x(), 0, cursorPos.x(), v->getPaintHeight());
Chris@77 2785
Chris@905 2786 double fundamental = getFrequencyForY(v, cursorPos.y());
Chris@77 2787
Chris@278 2788 v->drawVisibleText(paint,
Chris@278 2789 sw + 2,
Chris@278 2790 cursorPos.y() - 2,
Chris@278 2791 QString("%1 Hz").arg(fundamental),
Chris@278 2792 View::OutlinedText);
Chris@278 2793
Chris@279 2794 if (Pitch::isFrequencyInMidiRange(fundamental)) {
Chris@279 2795 QString pitchLabel = Pitch::getPitchLabelForFrequency(fundamental);
Chris@279 2796 v->drawVisibleText(paint,
Chris@279 2797 sw + 2,
Chris@279 2798 cursorPos.y() + paint.fontMetrics().ascent() + 2,
Chris@279 2799 pitchLabel,
Chris@279 2800 View::OutlinedText);
Chris@279 2801 }
Chris@279 2802
Chris@907 2803 sv_frame_t frame = v->getFrameForX(cursorPos.x());
Chris@279 2804 RealTime rt = RealTime::frame2RealTime(frame, m_model->getSampleRate());
Chris@280 2805 QString rtLabel = QString("%1 s").arg(rt.toText(true).c_str());
Chris@280 2806 QString frameLabel = QString("%1").arg(frame);
Chris@280 2807 v->drawVisibleText(paint,
Chris@280 2808 cursorPos.x() - paint.fontMetrics().width(frameLabel) - 2,
Chris@918 2809 v->getPaintHeight() - 2,
Chris@280 2810 frameLabel,
Chris@280 2811 View::OutlinedText);
Chris@280 2812 v->drawVisibleText(paint,
Chris@280 2813 cursorPos.x() + 2,
Chris@918 2814 v->getPaintHeight() - 2,
Chris@280 2815 rtLabel,
Chris@280 2816 View::OutlinedText);
Chris@264 2817
Chris@77 2818 int harmonic = 2;
Chris@77 2819
Chris@77 2820 while (harmonic < 100) {
Chris@77 2821
Chris@907 2822 int hy = int(lrint(getYForFrequency(v, fundamental * harmonic)));
Chris@918 2823 if (hy < 0 || hy > v->getPaintHeight()) break;
Chris@77 2824
Chris@77 2825 int len = 7;
Chris@77 2826
Chris@77 2827 if (harmonic % 2 == 0) {
Chris@77 2828 if (harmonic % 4 == 0) {
Chris@77 2829 len = 12;
Chris@77 2830 } else {
Chris@77 2831 len = 10;
Chris@77 2832 }
Chris@77 2833 }
Chris@77 2834
Chris@77 2835 paint.drawLine(cursorPos.x() - len,
Chris@907 2836 hy,
Chris@77 2837 cursorPos.x(),
Chris@907 2838 hy);
Chris@77 2839
Chris@77 2840 ++harmonic;
Chris@77 2841 }
Chris@77 2842
Chris@77 2843 paint.restore();
Chris@77 2844 }
Chris@77 2845
Chris@25 2846 QString
Chris@918 2847 SpectrogramLayer::getFeatureDescription(LayerGeometryProvider *v, QPoint &pos) const
Chris@25 2848 {
Chris@25 2849 int x = pos.x();
Chris@25 2850 int y = pos.y();
Chris@0 2851
Chris@25 2852 if (!m_model || !m_model->isOK()) return "";
Chris@0 2853
Chris@905 2854 double magMin = 0, magMax = 0;
Chris@905 2855 double phaseMin = 0, phaseMax = 0;
Chris@905 2856 double freqMin = 0, freqMax = 0;
Chris@905 2857 double adjFreqMin = 0, adjFreqMax = 0;
Chris@25 2858 QString pitchMin, pitchMax;
Chris@0 2859 RealTime rtMin, rtMax;
Chris@0 2860
Chris@38 2861 bool haveValues = false;
Chris@0 2862
Chris@44 2863 if (!getXBinSourceRange(v, x, rtMin, rtMax)) {
Chris@38 2864 return "";
Chris@38 2865 }
Chris@44 2866 if (getXYBinSourceRange(v, x, y, magMin, magMax, phaseMin, phaseMax)) {
Chris@38 2867 haveValues = true;
Chris@38 2868 }
Chris@0 2869
Chris@35 2870 QString adjFreqText = "", adjPitchText = "";
Chris@35 2871
Chris@38 2872 if (m_binDisplay == PeakFrequencies) {
Chris@35 2873
Chris@44 2874 if (!getAdjustedYBinSourceRange(v, x, y, freqMin, freqMax,
Chris@38 2875 adjFreqMin, adjFreqMax)) {
Chris@38 2876 return "";
Chris@38 2877 }
Chris@35 2878
Chris@35 2879 if (adjFreqMin != adjFreqMax) {
Chris@65 2880 adjFreqText = tr("Peak Frequency:\t%1 - %2 Hz\n")
Chris@35 2881 .arg(adjFreqMin).arg(adjFreqMax);
Chris@35 2882 } else {
Chris@65 2883 adjFreqText = tr("Peak Frequency:\t%1 Hz\n")
Chris@35 2884 .arg(adjFreqMin);
Chris@38 2885 }
Chris@38 2886
Chris@38 2887 QString pmin = Pitch::getPitchLabelForFrequency(adjFreqMin);
Chris@38 2888 QString pmax = Pitch::getPitchLabelForFrequency(adjFreqMax);
Chris@38 2889
Chris@38 2890 if (pmin != pmax) {
Chris@65 2891 adjPitchText = tr("Peak Pitch:\t%3 - %4\n").arg(pmin).arg(pmax);
Chris@38 2892 } else {
Chris@65 2893 adjPitchText = tr("Peak Pitch:\t%2\n").arg(pmin);
Chris@35 2894 }
Chris@35 2895
Chris@35 2896 } else {
Chris@35 2897
Chris@44 2898 if (!getYBinSourceRange(v, y, freqMin, freqMax)) return "";
Chris@35 2899 }
Chris@35 2900
Chris@25 2901 QString text;
Chris@25 2902
Chris@25 2903 if (rtMin != rtMax) {
Chris@25 2904 text += tr("Time:\t%1 - %2\n")
Chris@25 2905 .arg(rtMin.toText(true).c_str())
Chris@25 2906 .arg(rtMax.toText(true).c_str());
Chris@25 2907 } else {
Chris@25 2908 text += tr("Time:\t%1\n")
Chris@25 2909 .arg(rtMin.toText(true).c_str());
Chris@0 2910 }
Chris@0 2911
Chris@25 2912 if (freqMin != freqMax) {
Chris@65 2913 text += tr("%1Bin Frequency:\t%2 - %3 Hz\n%4Bin Pitch:\t%5 - %6\n")
Chris@65 2914 .arg(adjFreqText)
Chris@25 2915 .arg(freqMin)
Chris@25 2916 .arg(freqMax)
Chris@65 2917 .arg(adjPitchText)
Chris@65 2918 .arg(Pitch::getPitchLabelForFrequency(freqMin))
Chris@65 2919 .arg(Pitch::getPitchLabelForFrequency(freqMax));
Chris@65 2920 } else {
Chris@65 2921 text += tr("%1Bin Frequency:\t%2 Hz\n%3Bin Pitch:\t%4\n")
Chris@35 2922 .arg(adjFreqText)
Chris@25 2923 .arg(freqMin)
Chris@65 2924 .arg(adjPitchText)
Chris@65 2925 .arg(Pitch::getPitchLabelForFrequency(freqMin));
Chris@25 2926 }
Chris@25 2927
Chris@38 2928 if (haveValues) {
Chris@905 2929 double dbMin = AudioLevel::multiplier_to_dB(magMin);
Chris@905 2930 double dbMax = AudioLevel::multiplier_to_dB(magMax);
Chris@43 2931 QString dbMinString;
Chris@43 2932 QString dbMaxString;
Chris@43 2933 if (dbMin == AudioLevel::DB_FLOOR) {
Chris@43 2934 dbMinString = tr("-Inf");
Chris@43 2935 } else {
Chris@907 2936 dbMinString = QString("%1").arg(lrint(dbMin));
Chris@43 2937 }
Chris@43 2938 if (dbMax == AudioLevel::DB_FLOOR) {
Chris@43 2939 dbMaxString = tr("-Inf");
Chris@43 2940 } else {
Chris@907 2941 dbMaxString = QString("%1").arg(lrint(dbMax));
Chris@43 2942 }
Chris@907 2943 if (lrint(dbMin) != lrint(dbMax)) {
Chris@199 2944 text += tr("dB:\t%1 - %2").arg(dbMinString).arg(dbMaxString);
Chris@25 2945 } else {
Chris@199 2946 text += tr("dB:\t%1").arg(dbMinString);
Chris@25 2947 }
Chris@38 2948 if (phaseMin != phaseMax) {
Chris@38 2949 text += tr("\nPhase:\t%1 - %2").arg(phaseMin).arg(phaseMax);
Chris@38 2950 } else {
Chris@38 2951 text += tr("\nPhase:\t%1").arg(phaseMin);
Chris@38 2952 }
Chris@25 2953 }
Chris@25 2954
Chris@25 2955 return text;
Chris@0 2956 }
Chris@25 2957
Chris@0 2958 int
Chris@40 2959 SpectrogramLayer::getColourScaleWidth(QPainter &paint) const
Chris@40 2960 {
Chris@40 2961 int cw;
Chris@40 2962
Chris@119 2963 cw = paint.fontMetrics().width("-80dB");
Chris@119 2964
Chris@40 2965 return cw;
Chris@40 2966 }
Chris@40 2967
Chris@40 2968 int
Chris@918 2969 SpectrogramLayer::getVerticalScaleWidth(LayerGeometryProvider *, bool detailed, QPainter &paint) const
Chris@0 2970 {
Chris@0 2971 if (!m_model || !m_model->isOK()) return 0;
Chris@0 2972
Chris@607 2973 int cw = 0;
Chris@607 2974 if (detailed) cw = getColourScaleWidth(paint);
Chris@40 2975
Chris@0 2976 int tw = paint.fontMetrics().width(QString("%1")
Chris@0 2977 .arg(m_maxFrequency > 0 ?
Chris@0 2978 m_maxFrequency - 1 :
Chris@0 2979 m_model->getSampleRate() / 2));
Chris@0 2980
Chris@234 2981 int fw = paint.fontMetrics().width(tr("43Hz"));
Chris@0 2982 if (tw < fw) tw = fw;
Chris@40 2983
Chris@40 2984 int tickw = (m_frequencyScale == LogFrequencyScale ? 10 : 4);
Chris@0 2985
Chris@40 2986 return cw + tickw + tw + 13;
Chris@0 2987 }
Chris@0 2988
Chris@0 2989 void
Chris@918 2990 SpectrogramLayer::paintVerticalScale(LayerGeometryProvider *v, bool detailed, QPainter &paint, QRect rect) const
Chris@0 2991 {
Chris@0 2992 if (!m_model || !m_model->isOK()) {
Chris@0 2993 return;
Chris@0 2994 }
Chris@0 2995
Chris@382 2996 Profiler profiler("SpectrogramLayer::paintVerticalScale");
Chris@122 2997
Chris@120 2998 //!!! cache this?
Chris@120 2999
Chris@0 3000 int h = rect.height(), w = rect.width();
Chris@0 3001
Chris@40 3002 int tickw = (m_frequencyScale == LogFrequencyScale ? 10 : 4);
Chris@40 3003 int pkw = (m_frequencyScale == LogFrequencyScale ? 10 : 0);
Chris@40 3004
Chris@805 3005 int bins = m_fftSize / 2;
Chris@907 3006 sv_samplerate_t sr = m_model->getSampleRate();
Chris@0 3007
Chris@0 3008 if (m_maxFrequency > 0) {
Chris@107 3009 bins = int((double(m_maxFrequency) * m_fftSize) / sr + 0.1);
Chris@107 3010 if (bins > m_fftSize / 2) bins = m_fftSize / 2;
Chris@0 3011 }
Chris@0 3012
Chris@607 3013 int cw = 0;
Chris@607 3014
Chris@607 3015 if (detailed) cw = getColourScaleWidth(paint);
Chris@119 3016 int cbw = paint.fontMetrics().width("dB");
Chris@40 3017
Chris@0 3018 int py = -1;
Chris@0 3019 int textHeight = paint.fontMetrics().height();
Chris@0 3020 int toff = -textHeight + paint.fontMetrics().ascent() + 2;
Chris@0 3021
Chris@607 3022 if (detailed && (h > textHeight * 3 + 10)) {
Chris@119 3023
Chris@119 3024 int topLines = 2;
Chris@119 3025 if (m_colourScale == PhaseColourScale) topLines = 1;
Chris@119 3026
Chris@119 3027 int ch = h - textHeight * (topLines + 1) - 8;
Chris@119 3028 // paint.drawRect(4, textHeight + 4, cw - 1, ch + 1);
Chris@119 3029 paint.drawRect(4 + cw - cbw, textHeight * topLines + 4, cbw - 1, ch + 1);
Chris@40 3030
Chris@40 3031 QString top, bottom;
Chris@1030 3032 double min = m_viewMags[v->getId()].getMin();
Chris@1030 3033 double max = m_viewMags[v->getId()].getMax();
Chris@905 3034
Chris@905 3035 double dBmin = AudioLevel::multiplier_to_dB(min);
Chris@905 3036 double dBmax = AudioLevel::multiplier_to_dB(max);
Chris@119 3037
Chris@120 3038 if (dBmax < -60.f) dBmax = -60.f;
Chris@907 3039 else top = QString("%1").arg(lrint(dBmax));
Chris@120 3040
Chris@120 3041 if (dBmin < dBmax - 60.f) dBmin = dBmax - 60.f;
Chris@907 3042 bottom = QString("%1").arg(lrint(dBmin));
Chris@119 3043
Chris@119 3044 //!!! & phase etc
Chris@119 3045
Chris@119 3046 if (m_colourScale != PhaseColourScale) {
Chris@119 3047 paint.drawText((cw + 6 - paint.fontMetrics().width("dBFS")) / 2,
Chris@119 3048 2 + textHeight + toff, "dBFS");
Chris@119 3049 }
Chris@119 3050
Chris@119 3051 // paint.drawText((cw + 6 - paint.fontMetrics().width(top)) / 2,
Chris@119 3052 paint.drawText(3 + cw - cbw - paint.fontMetrics().width(top),
Chris@119 3053 2 + textHeight * topLines + toff + textHeight/2, top);
Chris@119 3054
Chris@119 3055 paint.drawText(3 + cw - cbw - paint.fontMetrics().width(bottom),
Chris@119 3056 h + toff - 3 - textHeight/2, bottom);
Chris@40 3057
Chris@40 3058 paint.save();
Chris@40 3059 paint.setBrush(Qt::NoBrush);
Chris@119 3060
Chris@119 3061 int lasty = 0;
Chris@119 3062 int lastdb = 0;
Chris@119 3063
Chris@40 3064 for (int i = 0; i < ch; ++i) {
Chris@119 3065
Chris@905 3066 double dBval = dBmin + (((dBmax - dBmin) * i) / (ch - 1));
Chris@119 3067 int idb = int(dBval);
Chris@119 3068
Chris@905 3069 double value = AudioLevel::dB_to_multiplier(dBval);
Chris@119 3070 int colour = getDisplayValue(v, value * m_gain);
Chris@210 3071
Chris@907 3072 paint.setPen(m_palette.getColour((unsigned char)colour));
Chris@119 3073
Chris@119 3074 int y = textHeight * topLines + 4 + ch - i;
Chris@119 3075
Chris@119 3076 paint.drawLine(5 + cw - cbw, y, cw + 2, y);
Chris@119 3077
Chris@119 3078 if (i == 0) {
Chris@119 3079 lasty = y;
Chris@119 3080 lastdb = idb;
Chris@119 3081 } else if (i < ch - paint.fontMetrics().ascent() &&
Chris@120 3082 idb != lastdb &&
Chris@119 3083 ((abs(y - lasty) > textHeight &&
Chris@119 3084 idb % 10 == 0) ||
Chris@119 3085 (abs(y - lasty) > paint.fontMetrics().ascent() &&
Chris@119 3086 idb % 5 == 0))) {
Chris@287 3087 paint.setPen(v->getBackground());
Chris@119 3088 QString text = QString("%1").arg(idb);
Chris@119 3089 paint.drawText(3 + cw - cbw - paint.fontMetrics().width(text),
Chris@119 3090 y + toff + textHeight/2, text);
Chris@287 3091 paint.setPen(v->getForeground());
Chris@119 3092 paint.drawLine(5 + cw - cbw, y, 8 + cw - cbw, y);
Chris@119 3093 lasty = y;
Chris@119 3094 lastdb = idb;
Chris@119 3095 }
Chris@40 3096 }
Chris@40 3097 paint.restore();
Chris@40 3098 }
Chris@40 3099
Chris@40 3100 paint.drawLine(cw + 7, 0, cw + 7, h);
Chris@40 3101
Chris@0 3102 int bin = -1;
Chris@0 3103
Chris@918 3104 for (int y = 0; y < v->getPaintHeight(); ++y) {
Chris@0 3105
Chris@905 3106 double q0, q1;
Chris@918 3107 if (!getYBinRange(v, v->getPaintHeight() - y, q0, q1)) continue;
Chris@0 3108
Chris@0 3109 int vy;
Chris@0 3110
Chris@0 3111 if (int(q0) > bin) {
Chris@0 3112 vy = y;
Chris@0 3113 bin = int(q0);
Chris@0 3114 } else {
Chris@0 3115 continue;
Chris@0 3116 }
Chris@0 3117
Chris@907 3118 int freq = int((sr * bin) / m_fftSize);
Chris@0 3119
Chris@0 3120 if (py >= 0 && (vy - py) < textHeight - 1) {
Chris@40 3121 if (m_frequencyScale == LinearFrequencyScale) {
Chris@40 3122 paint.drawLine(w - tickw, h - vy, w, h - vy);
Chris@40 3123 }
Chris@0 3124 continue;
Chris@0 3125 }
Chris@0 3126
Chris@0 3127 QString text = QString("%1").arg(freq);
Chris@234 3128 if (bin == 1) text = tr("%1Hz").arg(freq); // bin 0 is DC
Chris@40 3129 paint.drawLine(cw + 7, h - vy, w - pkw - 1, h - vy);
Chris@0 3130
Chris@0 3131 if (h - vy - textHeight >= -2) {
Chris@1025 3132 int tx = w - 3 - paint.fontMetrics().width(text) - max(tickw, pkw);
Chris@0 3133 paint.drawText(tx, h - vy + toff, text);
Chris@0 3134 }
Chris@0 3135
Chris@0 3136 py = vy;
Chris@0 3137 }
Chris@40 3138
Chris@40 3139 if (m_frequencyScale == LogFrequencyScale) {
Chris@40 3140
Chris@277 3141 // piano keyboard
Chris@277 3142
Chris@690 3143 PianoScale().paintPianoVertical
Chris@690 3144 (v, paint, QRect(w - pkw - 1, 0, pkw, h),
Chris@690 3145 getEffectiveMinFrequency(), getEffectiveMaxFrequency());
Chris@40 3146 }
Chris@608 3147
Chris@608 3148 m_haveDetailedScale = detailed;
Chris@0 3149 }
Chris@0 3150
Chris@187 3151 class SpectrogramRangeMapper : public RangeMapper
Chris@187 3152 {
Chris@187 3153 public:
Chris@901 3154 SpectrogramRangeMapper(sv_samplerate_t sr, int /* fftsize */) :
Chris@901 3155 m_dist(sr / 2),
Chris@901 3156 m_s2(sqrt(sqrt(2))) { }
Chris@187 3157 ~SpectrogramRangeMapper() { }
Chris@187 3158
Chris@901 3159 virtual int getPositionForValue(double value) const {
Chris@901 3160
Chris@901 3161 double dist = m_dist;
Chris@187 3162
Chris@187 3163 int n = 0;
Chris@187 3164
Chris@901 3165 while (dist > (value + 0.00001) && dist > 0.1) {
Chris@187 3166 dist /= m_s2;
Chris@187 3167 ++n;
Chris@187 3168 }
Chris@187 3169
Chris@187 3170 return n;
Chris@187 3171 }
Chris@724 3172
Chris@901 3173 virtual int getPositionForValueUnclamped(double value) const {
Chris@724 3174 // We don't really support this
Chris@724 3175 return getPositionForValue(value);
Chris@724 3176 }
Chris@187 3177
Chris@901 3178 virtual double getValueForPosition(int position) const {
Chris@187 3179
Chris@187 3180 // Vertical zoom step 0 shows the entire range from DC ->
Chris@187 3181 // Nyquist frequency. Step 1 shows 2^(1/4) of the range of
Chris@187 3182 // step 0, and so on until the visible range is smaller than
Chris@187 3183 // the frequency step between bins at the current fft size.
Chris@187 3184
Chris@901 3185 double dist = m_dist;
Chris@187 3186
Chris@187 3187 int n = 0;
Chris@187 3188 while (n < position) {
Chris@187 3189 dist /= m_s2;
Chris@187 3190 ++n;
Chris@187 3191 }
Chris@187 3192
Chris@187 3193 return dist;
Chris@187 3194 }
Chris@187 3195
Chris@901 3196 virtual double getValueForPositionUnclamped(int position) const {
Chris@724 3197 // We don't really support this
Chris@724 3198 return getValueForPosition(position);
Chris@724 3199 }
Chris@724 3200
Chris@187 3201 virtual QString getUnit() const { return "Hz"; }
Chris@187 3202
Chris@187 3203 protected:
Chris@901 3204 double m_dist;
Chris@901 3205 double m_s2;
Chris@187 3206 };
Chris@187 3207
Chris@133 3208 int
Chris@133 3209 SpectrogramLayer::getVerticalZoomSteps(int &defaultStep) const
Chris@133 3210 {
Chris@135 3211 if (!m_model) return 0;
Chris@187 3212
Chris@907 3213 sv_samplerate_t sr = m_model->getSampleRate();
Chris@187 3214
Chris@187 3215 SpectrogramRangeMapper mapper(sr, m_fftSize);
Chris@187 3216
Chris@905 3217 // int maxStep = mapper.getPositionForValue((double(sr) / m_fftSize) + 0.001);
Chris@187 3218 int maxStep = mapper.getPositionForValue(0);
Chris@905 3219 int minStep = mapper.getPositionForValue(double(sr) / 2);
Chris@250 3220
Chris@805 3221 int initialMax = m_initialMaxFrequency;
Chris@907 3222 if (initialMax == 0) initialMax = int(sr / 2);
Chris@250 3223
Chris@250 3224 defaultStep = mapper.getPositionForValue(initialMax) - minStep;
Chris@250 3225
Chris@587 3226 // SVDEBUG << "SpectrogramLayer::getVerticalZoomSteps: " << maxStep - minStep << " (" << maxStep <<"-" << minStep << "), default is " << defaultStep << " (from initial max freq " << initialMax << ")" << endl;
Chris@187 3227
Chris@187 3228 return maxStep - minStep;
Chris@133 3229 }
Chris@133 3230
Chris@133 3231 int
Chris@133 3232 SpectrogramLayer::getCurrentVerticalZoomStep() const
Chris@133 3233 {
Chris@133 3234 if (!m_model) return 0;
Chris@133 3235
Chris@905 3236 double dmin, dmax;
Chris@133 3237 getDisplayExtents(dmin, dmax);
Chris@133 3238
Chris@187 3239 SpectrogramRangeMapper mapper(m_model->getSampleRate(), m_fftSize);
Chris@187 3240 int n = mapper.getPositionForValue(dmax - dmin);
Chris@587 3241 // SVDEBUG << "SpectrogramLayer::getCurrentVerticalZoomStep: " << n << endl;
Chris@133 3242 return n;
Chris@133 3243 }
Chris@133 3244
Chris@133 3245 void
Chris@133 3246 SpectrogramLayer::setVerticalZoomStep(int step)
Chris@133 3247 {
Chris@187 3248 if (!m_model) return;
Chris@187 3249
Chris@905 3250 double dmin = m_minFrequency, dmax = m_maxFrequency;
Chris@253 3251 // getDisplayExtents(dmin, dmax);
Chris@253 3252
Chris@682 3253 // cerr << "current range " << dmin << " -> " << dmax << ", range " << dmax-dmin << ", mid " << (dmax + dmin)/2 << endl;
Chris@133 3254
Chris@907 3255 sv_samplerate_t sr = m_model->getSampleRate();
Chris@187 3256 SpectrogramRangeMapper mapper(sr, m_fftSize);
Chris@905 3257 double newdist = mapper.getValueForPosition(step);
Chris@905 3258
Chris@905 3259 double newmin, newmax;
Chris@253 3260
Chris@253 3261 if (m_frequencyScale == LogFrequencyScale) {
Chris@253 3262
Chris@253 3263 // need to pick newmin and newmax such that
Chris@253 3264 //
Chris@253 3265 // (log(newmin) + log(newmax)) / 2 == logmid
Chris@253 3266 // and
Chris@253 3267 // newmax - newmin = newdist
Chris@253 3268 //
Chris@253 3269 // so log(newmax - newdist) + log(newmax) == 2logmid
Chris@253 3270 // log(newmax(newmax - newdist)) == 2logmid
Chris@253 3271 // newmax.newmax - newmax.newdist == exp(2logmid)
Chris@253 3272 // newmax^2 + (-newdist)newmax + -exp(2logmid) == 0
Chris@253 3273 // quadratic with a = 1, b = -newdist, c = -exp(2logmid), all known
Chris@253 3274 //
Chris@253 3275 // positive root
Chris@253 3276 // newmax = (newdist + sqrt(newdist^2 + 4exp(2logmid))) / 2
Chris@253 3277 //
Chris@253 3278 // but logmid = (log(dmin) + log(dmax)) / 2
Chris@253 3279 // so exp(2logmid) = exp(log(dmin) + log(dmax))
Chris@253 3280 // = exp(log(dmin.dmax))
Chris@253 3281 // = dmin.dmax
Chris@253 3282 // so newmax = (newdist + sqrtf(newdist^2 + 4dmin.dmax)) / 2
Chris@253 3283
Chris@907 3284 newmax = (newdist + sqrt(newdist*newdist + 4*dmin*dmax)) / 2;
Chris@253 3285 newmin = newmax - newdist;
Chris@253 3286
Chris@682 3287 // cerr << "newmin = " << newmin << ", newmax = " << newmax << endl;
Chris@253 3288
Chris@253 3289 } else {
Chris@905 3290 double dmid = (dmax + dmin) / 2;
Chris@253 3291 newmin = dmid - newdist / 2;
Chris@253 3292 newmax = dmid + newdist / 2;
Chris@253 3293 }
Chris@187 3294
Chris@905 3295 double mmin, mmax;
Chris@187 3296 mmin = 0;
Chris@905 3297 mmax = double(sr) / 2;
Chris@133 3298
Chris@187 3299 if (newmin < mmin) {
Chris@187 3300 newmax += (mmin - newmin);
Chris@187 3301 newmin = mmin;
Chris@187 3302 }
Chris@187 3303 if (newmax > mmax) {
Chris@187 3304 newmax = mmax;
Chris@187 3305 }
Chris@133 3306
Chris@587 3307 // SVDEBUG << "SpectrogramLayer::setVerticalZoomStep: " << step << ": " << newmin << " -> " << newmax << " (range " << newdist << ")" << endl;
Chris@253 3308
Chris@907 3309 setMinFrequency(int(lrint(newmin)));
Chris@907 3310 setMaxFrequency(int(lrint(newmax)));
Chris@187 3311 }
Chris@187 3312
Chris@187 3313 RangeMapper *
Chris@187 3314 SpectrogramLayer::getNewVerticalZoomRangeMapper() const
Chris@187 3315 {
Chris@187 3316 if (!m_model) return 0;
Chris@187 3317 return new SpectrogramRangeMapper(m_model->getSampleRate(), m_fftSize);
Chris@133 3318 }
Chris@133 3319
Chris@273 3320 void
Chris@918 3321 SpectrogramLayer::updateMeasureRectYCoords(LayerGeometryProvider *v, const MeasureRect &r) const
Chris@273 3322 {
Chris@273 3323 int y0 = 0;
Chris@907 3324 if (r.startY > 0.0) y0 = int(getYForFrequency(v, r.startY));
Chris@273 3325
Chris@273 3326 int y1 = y0;
Chris@907 3327 if (r.endY > 0.0) y1 = int(getYForFrequency(v, r.endY));
Chris@273 3328
Chris@587 3329 // SVDEBUG << "SpectrogramLayer::updateMeasureRectYCoords: start " << r.startY << " -> " << y0 << ", end " << r.endY << " -> " << y1 << endl;
Chris@273 3330
Chris@273 3331 r.pixrect = QRect(r.pixrect.x(), y0, r.pixrect.width(), y1 - y0);
Chris@273 3332 }
Chris@273 3333
Chris@273 3334 void
Chris@918 3335 SpectrogramLayer::setMeasureRectYCoord(LayerGeometryProvider *v, MeasureRect &r, bool start, int y) const
Chris@273 3336 {
Chris@273 3337 if (start) {
Chris@273 3338 r.startY = getFrequencyForY(v, y);
Chris@273 3339 r.endY = r.startY;
Chris@273 3340 } else {
Chris@273 3341 r.endY = getFrequencyForY(v, y);
Chris@273 3342 }
Chris@587 3343 // SVDEBUG << "SpectrogramLayer::setMeasureRectYCoord: start " << r.startY << " <- " << y << ", end " << r.endY << " <- " << y << endl;
Chris@273 3344
Chris@273 3345 }
Chris@273 3346
Chris@316 3347 void
Chris@316 3348 SpectrogramLayer::toXml(QTextStream &stream,
Chris@316 3349 QString indent, QString extraAttributes) const
Chris@6 3350 {
Chris@6 3351 QString s;
Chris@6 3352
Chris@6 3353 s += QString("channel=\"%1\" "
Chris@6 3354 "windowSize=\"%2\" "
Chris@153 3355 "windowHopLevel=\"%3\" "
Chris@153 3356 "gain=\"%4\" "
Chris@153 3357 "threshold=\"%5\" ")
Chris@6 3358 .arg(m_channel)
Chris@6 3359 .arg(m_windowSize)
Chris@97 3360 .arg(m_windowHopLevel)
Chris@37 3361 .arg(m_gain)
Chris@37 3362 .arg(m_threshold);
Chris@37 3363
Chris@37 3364 s += QString("minFrequency=\"%1\" "
Chris@37 3365 "maxFrequency=\"%2\" "
Chris@37 3366 "colourScale=\"%3\" "
Chris@37 3367 "colourScheme=\"%4\" "
Chris@37 3368 "colourRotation=\"%5\" "
Chris@37 3369 "frequencyScale=\"%6\" "
Chris@761 3370 "binDisplay=\"%7\" ")
Chris@37 3371 .arg(m_minFrequency)
Chris@6 3372 .arg(m_maxFrequency)
Chris@6 3373 .arg(m_colourScale)
Chris@197 3374 .arg(m_colourMap)
Chris@37 3375 .arg(m_colourRotation)
Chris@35 3376 .arg(m_frequencyScale)
Chris@761 3377 .arg(m_binDisplay);
Chris@761 3378
Chris@761 3379 s += QString("normalizeColumns=\"%1\" "
Chris@761 3380 "normalizeVisibleArea=\"%2\" "
Chris@761 3381 "normalizeHybrid=\"%3\" ")
Chris@862 3382 .arg(m_normalization == NormalizeColumns ? "true" : "false")
Chris@862 3383 .arg(m_normalization == NormalizeVisibleArea ? "true" : "false")
Chris@862 3384 .arg(m_normalization == NormalizeHybrid ? "true" : "false");
Chris@6 3385
Chris@316 3386 Layer::toXml(stream, indent, extraAttributes + " " + s);
Chris@6 3387 }
Chris@6 3388
Chris@11 3389 void
Chris@11 3390 SpectrogramLayer::setProperties(const QXmlAttributes &attributes)
Chris@11 3391 {
Chris@11 3392 bool ok = false;
Chris@11 3393
Chris@11 3394 int channel = attributes.value("channel").toInt(&ok);
Chris@11 3395 if (ok) setChannel(channel);
Chris@11 3396
Chris@805 3397 int windowSize = attributes.value("windowSize").toUInt(&ok);
Chris@11 3398 if (ok) setWindowSize(windowSize);
Chris@11 3399
Chris@805 3400 int windowHopLevel = attributes.value("windowHopLevel").toUInt(&ok);
Chris@97 3401 if (ok) setWindowHopLevel(windowHopLevel);
Chris@97 3402 else {
Chris@805 3403 int windowOverlap = attributes.value("windowOverlap").toUInt(&ok);
Chris@97 3404 // a percentage value
Chris@97 3405 if (ok) {
Chris@97 3406 if (windowOverlap == 0) setWindowHopLevel(0);
Chris@97 3407 else if (windowOverlap == 25) setWindowHopLevel(1);
Chris@97 3408 else if (windowOverlap == 50) setWindowHopLevel(2);
Chris@97 3409 else if (windowOverlap == 75) setWindowHopLevel(3);
Chris@97 3410 else if (windowOverlap == 90) setWindowHopLevel(4);
Chris@97 3411 }
Chris@97 3412 }
Chris@11 3413
Chris@11 3414 float gain = attributes.value("gain").toFloat(&ok);
Chris@11 3415 if (ok) setGain(gain);
Chris@11 3416
Chris@37 3417 float threshold = attributes.value("threshold").toFloat(&ok);
Chris@37 3418 if (ok) setThreshold(threshold);
Chris@37 3419
Chris@805 3420 int minFrequency = attributes.value("minFrequency").toUInt(&ok);
Chris@187 3421 if (ok) {
Chris@587 3422 SVDEBUG << "SpectrogramLayer::setProperties: setting min freq to " << minFrequency << endl;
Chris@187 3423 setMinFrequency(minFrequency);
Chris@187 3424 }
Chris@37 3425
Chris@805 3426 int maxFrequency = attributes.value("maxFrequency").toUInt(&ok);
Chris@187 3427 if (ok) {
Chris@587 3428 SVDEBUG << "SpectrogramLayer::setProperties: setting max freq to " << maxFrequency << endl;
Chris@187 3429 setMaxFrequency(maxFrequency);
Chris@187 3430 }
Chris@11 3431
Chris@11 3432 ColourScale colourScale = (ColourScale)
Chris@11 3433 attributes.value("colourScale").toInt(&ok);
Chris@11 3434 if (ok) setColourScale(colourScale);
Chris@11 3435
Chris@197 3436 int colourMap = attributes.value("colourScheme").toInt(&ok);
Chris@197 3437 if (ok) setColourMap(colourMap);
Chris@11 3438
Chris@37 3439 int colourRotation = attributes.value("colourRotation").toInt(&ok);
Chris@37 3440 if (ok) setColourRotation(colourRotation);
Chris@37 3441
Chris@11 3442 FrequencyScale frequencyScale = (FrequencyScale)
Chris@11 3443 attributes.value("frequencyScale").toInt(&ok);
Chris@11 3444 if (ok) setFrequencyScale(frequencyScale);
Chris@35 3445
Chris@37 3446 BinDisplay binDisplay = (BinDisplay)
Chris@37 3447 attributes.value("binDisplay").toInt(&ok);
Chris@37 3448 if (ok) setBinDisplay(binDisplay);
Chris@36 3449
Chris@36 3450 bool normalizeColumns =
Chris@36 3451 (attributes.value("normalizeColumns").trimmed() == "true");
Chris@862 3452 if (normalizeColumns) {
Chris@862 3453 setNormalization(NormalizeColumns);
Chris@862 3454 }
Chris@153 3455
Chris@153 3456 bool normalizeVisibleArea =
Chris@153 3457 (attributes.value("normalizeVisibleArea").trimmed() == "true");
Chris@862 3458 if (normalizeVisibleArea) {
Chris@862 3459 setNormalization(NormalizeVisibleArea);
Chris@862 3460 }
Chris@761 3461
Chris@761 3462 bool normalizeHybrid =
Chris@761 3463 (attributes.value("normalizeHybrid").trimmed() == "true");
Chris@862 3464 if (normalizeHybrid) {
Chris@862 3465 setNormalization(NormalizeHybrid);
Chris@862 3466 }
Chris@11 3467 }
Chris@11 3468