ACloudViewer  3.9.4
A Modern Library for 3D Data Processing
ecvColorFromScalarDlg.cpp
Go to the documentation of this file.
1 // ----------------------------------------------------------------------------
2 // - CloudViewer: www.cloudViewer.org -
3 // ----------------------------------------------------------------------------
4 // Copyright (c) 2018-2024 www.cloudViewer.org
5 // SPDX-License-Identifier: MIT
6 // ----------------------------------------------------------------------------
7 
8 #include "ecvColorFromScalarDlg.h"
9 
10 // local
11 #include "ecvConsole.h"
12 #include "ecvHistogramWindow.h"
13 
14 // CV_DB_LIB
15 #include <ecvColorScale.h>
16 #include <ecvHObjectCaster.h>
17 #include <ecvPointCloud.h>
18 
19 // Qt
20 #include <QPushButton>
21 
22 // ui
23 #include <ui_colorFromScalarDlg.h>
24 
25 // system
26 #include <cassert>
27 #include <cstring>
28 
29 ccColorFromScalarDlg::ccColorFromScalarDlg(QWidget* parent,
30  ccPointCloud* pointCloud)
31  : QDialog(parent, Qt::Tool),
32  m_cloud(pointCloud),
33  m_systemInvalid(false),
34  m_ui(new Ui::ColorFromScalarDialog) {
35  m_ui->setupUi(this);
36 
37  // populate boxes
38  m_boxes_min[0] = m_ui->minInputSpinBoxR;
39  m_boxes_max[0] = m_ui->maxInputSpinBoxR;
40  m_boxes_min[1] = m_ui->minInputSpinBoxG;
41  m_boxes_max[1] = m_ui->maxInputSpinBoxG;
42  m_boxes_min[2] = m_ui->minInputSpinBoxB;
43  m_boxes_max[2] = m_ui->maxInputSpinBoxB;
44  m_boxes_min[3] = m_ui->minInputSpinBoxA;
45  m_boxes_max[3] = m_ui->maxInputSpinBoxA;
46 
47  // populate combo boxes
48  m_combos[0] = m_ui->channelComboR;
49  m_combos[1] = m_ui->channelComboG;
50  m_combos[2] = m_ui->channelComboB;
51  m_combos[3] = m_ui->channelComboA;
52 
53  // populate labels
54  m_labels_min[0] = m_ui->MinLabelR;
55  m_labels_min[1] = m_ui->MinLabelG;
56  m_labels_min[2] = m_ui->MinLabelB;
57  m_labels_min[3] = m_ui->MinLabelA;
58  m_labels_max[0] = m_ui->MaxLabelR;
59  m_labels_max[1] = m_ui->MaxLabelG;
60  m_labels_max[2] = m_ui->MaxLabelB;
61  m_labels_max[3] = m_ui->MaxLabelA;
62  m_reverse[0] = m_ui->reverseR;
63  m_reverse[1] = m_ui->reverseG;
64  m_reverse[2] = m_ui->reverseB;
65  m_reverse[3] = m_ui->reverseA;
66 
67  m_ui->fixA->setChecked(true); // set alpha fixed to checked
68 
69  // create histograms
70  QFrame* histoFrame[c_channelCount] = {m_ui->histoFrameR, m_ui->histoFrameG,
71  m_ui->histoFrameB, m_ui->histoFrameA};
72  for (unsigned i = 0; i < c_channelCount; i++) {
73  m_histograms[i] = new ccHistogramWindow(this);
74  m_histograms[i]->setRefreshAfterResize(false);
75  auto layout = new QHBoxLayout;
76 
77  layout->setContentsMargins(0, 0, 0, 0);
78  layout->addWidget(m_histograms[i]);
79 
80  histoFrame[i]->setLayout(layout);
81  }
82 
83  // initialise colour scales
84  for (unsigned i = 0; i < c_channelCount; i++) {
85  m_colors[i] = ccColorScale::Shared(
86  new ccColorScale(QString::asprintf("%d", i)));
87  }
88  if (m_cloud->getNumberOfScalarFields() > 0) {
89  if (m_cloud->getCurrentDisplayedScalarFieldIndex() == -1) {
90  m_cloud->setCurrentDisplayedScalarField(0);
91  }
92  ccScalarField* sf = static_cast<ccScalarField*>(
93  m_cloud->getCurrentDisplayedScalarField());
94  if (!sf) // I had this happen 1 time during testing but could never
95  // replicate
96  {
97  assert(false);
98  CVLog::Error(
99  "[ccColorFromScalarDlg] Get current scalar field failed!");
100  m_systemInvalid = true;
101  disableAllButCancel();
102  } else {
103  m_storedOrigColorScale = sf->getColorScale();
104  m_storedOrigSatRange = sf->saturationRange();
105  m_storedOrigDisplayRange = sf->displayRange();
106 
107  for (unsigned i = 0; i < c_channelCount; i++) {
108  m_scalars[i] = nullptr;
109  m_prevFixed[i] = true;
110  m_combos[i]->clear();
111  for (unsigned int s = 0; s < m_cloud->getNumberOfScalarFields();
112  s++) {
113  m_combos[i]->addItem(m_cloud->getScalarFieldName(s));
114  }
115  m_combos[i]->setCurrentIndex(
116  m_cloud->getCurrentDisplayedScalarFieldIndex());
117  }
118 
119  updateColormaps();
120 
121  // initialise histograms
122  m_prevFixed[c_channelCount - 1] = false;
123  updateChannel(0); // init first histogram
124  for (unsigned i = 1; i < c_channelCount;
125  i++) // copy data from this histogram into the next ones
126  {
127  m_scalars[i] = sf;
128  setDefaultSatValuePerChannel(i);
129  m_histograms[i]->fromBinArray(m_histograms[0]->histoValues(),
130  m_histograms[0]->minVal(),
131  m_histograms[0]->maxVal());
132  updateHistogram(i);
133  }
134 
135  sf->setColorScale(
136  m_colors[c_channelCount -
137  1]); // set grey colour ramp to start with
138  m_cloud->redrawDisplay();
139  }
140  } else {
141  CVLog::Error(
142  "[ccColorFromScalarDlg] Current cloud has no scalar fields!");
143  m_systemInvalid = true;
144  disableAllButCancel();
145  }
146 
147  // connect GUI elements
148  connect(m_ui->channelComboR,
149  static_cast<void (QComboBox::*)(int)>(
150  &QComboBox::currentIndexChanged),
151  this, &ccColorFromScalarDlg::onChannelChangedR);
152  connect(m_ui->channelComboG,
153  static_cast<void (QComboBox::*)(int)>(
154  &QComboBox::currentIndexChanged),
155  this, &ccColorFromScalarDlg::onChannelChangedG);
156  connect(m_ui->channelComboB,
157  static_cast<void (QComboBox::*)(int)>(
158  &QComboBox::currentIndexChanged),
159  this, &ccColorFromScalarDlg::onChannelChangedB);
160  connect(m_ui->channelComboA,
161  static_cast<void (QComboBox::*)(int)>(
162  &QComboBox::currentIndexChanged),
163  this, &ccColorFromScalarDlg::onChannelChangedA);
164 
165  connect(m_ui->buttonBox->button(QDialogButtonBox::Apply),
166  &QPushButton::clicked, this, &ccColorFromScalarDlg::onApply);
167  connect(m_ui->minInputSpinBoxR,
168  static_cast<void (QDoubleSpinBox::*)(double)>(
169  &QDoubleSpinBox::valueChanged),
170  this, &ccColorFromScalarDlg::minSpinChangedR);
171  connect(m_ui->maxInputSpinBoxR,
172  static_cast<void (QDoubleSpinBox::*)(double)>(
173  &QDoubleSpinBox::valueChanged),
174  this, &ccColorFromScalarDlg::maxSpinChangedR);
175  connect(m_ui->minInputSpinBoxG,
176  static_cast<void (QDoubleSpinBox::*)(double)>(
177  &QDoubleSpinBox::valueChanged),
178  this, &ccColorFromScalarDlg::minSpinChangedG);
179  connect(m_ui->maxInputSpinBoxG,
180  static_cast<void (QDoubleSpinBox::*)(double)>(
181  &QDoubleSpinBox::valueChanged),
182  this, &ccColorFromScalarDlg::maxSpinChangedG);
183  connect(m_ui->minInputSpinBoxB,
184  static_cast<void (QDoubleSpinBox::*)(double)>(
185  &QDoubleSpinBox::valueChanged),
186  this, &ccColorFromScalarDlg::minSpinChangedB);
187  connect(m_ui->maxInputSpinBoxB,
188  static_cast<void (QDoubleSpinBox::*)(double)>(
189  &QDoubleSpinBox::valueChanged),
190  this, &ccColorFromScalarDlg::maxSpinChangedB);
191  connect(m_ui->minInputSpinBoxA,
192  static_cast<void (QDoubleSpinBox::*)(double)>(
193  &QDoubleSpinBox::valueChanged),
194  this, &ccColorFromScalarDlg::minSpinChangedA);
195  connect(m_ui->maxInputSpinBoxA,
196  static_cast<void (QDoubleSpinBox::*)(double)>(
197  &QDoubleSpinBox::valueChanged),
198  this, &ccColorFromScalarDlg::maxSpinChangedA);
199 
200  connect(m_ui->reverseR, &QCheckBox::stateChanged, this,
201  &ccColorFromScalarDlg::toggleColors);
202  connect(m_ui->reverseG, &QCheckBox::stateChanged, this,
203  &ccColorFromScalarDlg::toggleColors);
204  connect(m_ui->reverseB, &QCheckBox::stateChanged, this,
205  &ccColorFromScalarDlg::toggleColors);
206  connect(m_ui->reverseA, &QCheckBox::stateChanged, this,
207  &ccColorFromScalarDlg::toggleColors);
208  connect(m_ui->toggleHSV, &QRadioButton::toggled, this,
209  &ccColorFromScalarDlg::toggleColorMode);
210  connect(m_ui->toggleRGB, &QRadioButton::toggled, this,
211  &ccColorFromScalarDlg::toggleColorMode);
212 
213  connect(m_ui->fixR, &QCheckBox::stateChanged, this,
214  &ccColorFromScalarDlg::toggleFixedR);
215  connect(m_ui->fixG, &QCheckBox::stateChanged, this,
216  &ccColorFromScalarDlg::toggleFixedG);
217  connect(m_ui->fixB, &QCheckBox::stateChanged, this,
218  &ccColorFromScalarDlg::toggleFixedB);
219  connect(m_ui->fixA, &QCheckBox::stateChanged, this,
220  &ccColorFromScalarDlg::toggleFixedA);
221 
222  // connect histogram events
223  connect(m_histograms[0], &ccHistogramWindow::sfMinSatValChanged, this,
224  &ccColorFromScalarDlg::minChangedR);
225  connect(m_histograms[0], &ccHistogramWindow::sfMaxSatValChanged, this,
226  &ccColorFromScalarDlg::maxChangedR);
227  connect(m_histograms[1], &ccHistogramWindow::sfMinSatValChanged, this,
228  &ccColorFromScalarDlg::minChangedG);
229  connect(m_histograms[1], &ccHistogramWindow::sfMaxSatValChanged, this,
230  &ccColorFromScalarDlg::maxChangedG);
231  connect(m_histograms[2], &ccHistogramWindow::sfMinSatValChanged, this,
232  &ccColorFromScalarDlg::minChangedB);
233  connect(m_histograms[2], &ccHistogramWindow::sfMaxSatValChanged, this,
234  &ccColorFromScalarDlg::maxChangedB);
235  connect(m_histograms[3], &ccHistogramWindow::sfMinSatValChanged, this,
236  &ccColorFromScalarDlg::minChangedA);
237  connect(m_histograms[3], &ccHistogramWindow::sfMaxSatValChanged, this,
238  &ccColorFromScalarDlg::maxChangedA);
239 
240  for (int i = 1; i < c_channelCount; ++i) {
241  updateChannel(i);
242  }
243 }
244 
245 ccColorFromScalarDlg::~ccColorFromScalarDlg() {
246  if (!m_systemInvalid) {
247  ccScalarField* sf = static_cast<ccScalarField*>(
248  m_cloud->getCurrentDisplayedScalarField());
249  sf->setColorScale(m_storedOrigColorScale);
250  sf->setSaturationStart(m_storedOrigSatRange.min());
251  sf->setSaturationStop(m_storedOrigSatRange.max());
252  sf->setMinDisplayed(m_storedOrigDisplayRange.min());
253  sf->setMaxDisplayed(m_storedOrigDisplayRange.max());
254  m_cloud->redrawDisplay();
255  }
256  delete m_ui;
257 }
258 
259 void ccColorFromScalarDlg::updateColormaps() {
260  if (!m_systemInvalid) {
261  // check for reversed
262  bool reversed[c_channelCount] = {
263  m_ui->reverseR->isChecked(), m_ui->reverseG->isChecked(),
264  m_ui->reverseB->isChecked(), m_ui->reverseA->isChecked()};
265 
266  // create colourmaps for RGB
267  if (m_ui->toggleRGB->isChecked()) {
268  // update labels
269  m_ui->mRedLabel->setText(QStringLiteral("Red"));
270  m_ui->mGreenLabel->setText(QStringLiteral("Green"));
271  m_ui->mBlueLabel->setText(QStringLiteral("Blue"));
272  m_ui->mAlphaLabel->setText(QStringLiteral("Alpha"));
273 
274  // populate colour ramps
275  Qt::GlobalColor start_colors[c_channelCount] = {
276  Qt::black, Qt::black, Qt::black, Qt::black};
277  Qt::GlobalColor end_colors[c_channelCount] = {Qt::red, Qt::green,
278  Qt::blue, Qt::white};
279 
280  for (unsigned i = 0; i < c_channelCount; i++) {
281  m_colors[i]->clear();
282  if (reversed[i]) // flip
283  {
284  m_colors[i]->insert(
285  ccColorScaleElement(0.0, end_colors[i]));
286  m_colors[i]->insert(
287  ccColorScaleElement(1.0, start_colors[i]));
288  } else {
289  m_colors[i]->insert(
290  ccColorScaleElement(0.0, start_colors[i]));
291  m_colors[i]->insert(
292  ccColorScaleElement(1.0, end_colors[i]));
293  }
294 
295  m_colors[i]->update();
296  }
297  } else // create colourmaps for HSV
298  {
299  // update labels
300  m_ui->mRedLabel->setText(QStringLiteral("Hue"));
301  m_ui->mGreenLabel->setText(QStringLiteral("Sat"));
302  m_ui->mBlueLabel->setText(QStringLiteral("Value"));
303  m_ui->mAlphaLabel->setText(QStringLiteral("Alpha"));
304 
305  // populate colour ramps
306  Qt::GlobalColor start_colors[c_channelCount] = {
307  Qt::black, Qt::gray, Qt::black, Qt::black};
308  Qt::GlobalColor end_colors[c_channelCount] = {Qt::red, Qt::green,
309  Qt::white, Qt::white};
310 
311  for (unsigned i = 0; i < c_channelCount; i++) {
312  m_colors[i]->clear();
313  if (reversed[i]) // flip
314  {
315  m_colors[i]->insert(
316  ccColorScaleElement(0.0, end_colors[i]));
317  m_colors[i]->insert(
318  ccColorScaleElement(1.0, start_colors[i]));
319  } else {
320  m_colors[i]->insert(
321  ccColorScaleElement(0.0, start_colors[i]));
322  m_colors[i]->insert(
323  ccColorScaleElement(1.0, end_colors[i]));
324  }
325 
326  m_colors[i]->update();
327  }
328 
329  // overwrite first colourmap with hue rainbow
330  int hue;
331  m_colors[0]->clear();
332 
333  ecvColor::Rgb col = ecvColor::Convert::hsv2rgb(360.0f, 1.0f, 1.0f);
334  m_colors[0]->insert(
335  ccColorScaleElement(1.0, QColor(col.r, col.g, col.b, 255)));
336  for (unsigned i = 0; i < 360; i += 2) {
337  // calculate hue value
338  if (reversed[0]) {
339  hue = 360 - i;
340  } else {
341  hue = i;
342  }
343 
344  // calculate colour
345  col = ecvColor::Convert::hsv2rgb(hue, 1.0f, 1.0f);
346 
347  // add stop
348  m_colors[0]->insert(
349  ccColorScaleElement(static_cast<double>(i) / 360.0,
350  QColor(col.r, col.g, col.b, 255)));
351  }
352  m_colors[0]->update();
353  }
354  }
355 }
356 
357 void ccColorFromScalarDlg::toggleColors(int state) {
358  if (!m_systemInvalid) {
359  // update colourmaps
360  updateColormaps();
361 
362  // refresh histograms
363  refreshDisplay();
364  }
365 }
366 
367 void ccColorFromScalarDlg::toggleColorMode(bool state) {
368  if (!m_systemInvalid) {
369  // update colourmaps
370  updateColormaps();
371  refreshDisplay();
372  }
373 }
374 
375 // update/redraw histograms but don't reset postion of UI elements/sliders etc.
376 void ccColorFromScalarDlg::refreshDisplay() {
377  if (!m_systemInvalid) {
378  // refresh histograms
379  for (int i = 0; i < c_channelCount; i++) {
380  updateHistogram(i);
381  }
382  }
383 }
384 
385 void ccColorFromScalarDlg::updateHistogram(int n) {
386  if (!m_systemInvalid) {
387  if (n >= c_channelCount || n < 0) {
388  CVLog::Error(
389  "[ccColorFromScalarDlg] updateHistogram called with an "
390  "invalid channel index");
391  return;
392  }
393  // first check if fixed or not and enable disable ui features based on
394  // this
395  bool fixed[c_channelCount] = {
396  m_ui->fixR->isChecked(), m_ui->fixG->isChecked(),
397  m_ui->fixB->isChecked(), m_ui->fixA->isChecked()};
398  m_histograms[n]->setEnabled(!fixed[n]);
399  m_combos[n]->setEnabled(!fixed[n]);
400  m_boxes_max[n]->setEnabled(!fixed[n]);
401  m_labels_max[n]->setEnabled(!fixed[n]);
402  m_reverse[n]->setEnabled(!fixed[n]);
403  if (fixed[n]) // this channel is/has been fixed
404  {
405  if (fixed[n] != m_prevFixed[n]) {
406  m_labels_min[n]->setText(" Value:");
407  m_boxes_min[n]->setMaximum(255.0);
408  m_boxes_min[n]->setMinimum(0.0);
409  m_boxes_max[n]->setMaximum(255.0);
410  m_boxes_max[n]->setMinimum(0.0);
411  m_boxes_max[n]->setValue(200.0);
412  m_boxes_min[n]->setValue(200.0);
413  m_boxes_min[n]->setSingleStep(1.0);
414  m_boxes_max[n]->setSingleStep(1.0);
415 
416  // edge case for HSV values (0 - 360)
417  if (n == 0 && m_ui->toggleHSV->isChecked()) {
418  m_boxes_min[n]->setMaximum(360);
419  }
420  }
421 
422  // and make histogram grey
423  m_histograms[n]->clear();
424  m_histograms[n]->setSFInteractionMode(
425  ccHistogramWindow::SFInteractionMode::
426  None); // disable interactivity
427  m_histograms[n]->setAxisLabels("", "");
428  m_histograms[n]->setAxisDisplayOption(
429  ccHistogramWindow::AxisDisplayOption::
430  None); // only display XAxis
431  m_histograms[n]->refresh();
432  m_histograms[n]->replot();
433  } else {
434  if (fixed[n] != m_prevFixed[n]) {
435  setDefaultSatValuePerChannel(n); // update slider positions
436  m_labels_min[n]->setText(
437  "Minimum:"); // ensure label text is correct
438  }
439 
440  // set scalar field
441  m_scalars[n]->setColorScale(m_colors[n]);
442  m_scalars[n]->setSaturationStart(m_boxes_min[n]->value());
443  m_scalars[n]->setSaturationStop(m_boxes_max[n]->value());
444  m_histograms[n]->setSFInteractionMode(
445  ccHistogramWindow::SFInteractionMode::
446  SaturationRange); // disable interactivity
447  m_histograms[n]->setAxisLabels("", "");
448  m_histograms[n]->setAxisDisplayOption(
449  ccHistogramWindow::AxisDisplayOption::
450  XAxis); // only display XAxis
451  m_histograms[n]->refresh();
452  }
453  m_prevFixed[n] = fixed[n];
454  }
455 }
456 
457 void ccColorFromScalarDlg::updateSpinBoxLimits(int n) {
458  if (!m_systemInvalid) {
459  if (n >= c_channelCount || n < 0) {
460  CVLog::Error(
461  "[ccColorFromScalarDlg] updateSpinBoxLimits called with an "
462  "invalid channel index");
463  return;
464  }
465  bool fixed[c_channelCount] = {
466  m_ui->fixR->isChecked(), m_ui->fixG->isChecked(),
467  m_ui->fixB->isChecked(), m_ui->fixA->isChecked()};
468  if (fixed[n]) {
469  return;
470  }
471  ccScalarField* sf = static_cast<ccScalarField*>(
472  m_cloud->getScalarField(m_combos[n]->currentIndex()));
473  if (sf) {
474  m_minSat[n] = sf->getMin();
475  m_maxSat[n] = sf->getMax();
476  double singleStepSize = (m_maxSat[n] - m_minSat[n]) / 100.0;
477  if (singleStepSize < 0.01) {
478  singleStepSize = 0.01;
479  }
480  m_boxes_min[n]->setMinimum(m_minSat[n]);
481  m_boxes_min[n]->setMaximum(m_maxSat[n]);
482  m_boxes_min[n]->setSingleStep(singleStepSize);
483  m_boxes_max[n]->setMinimum(m_minSat[n]);
484  m_boxes_max[n]->setMaximum(m_maxSat[n]);
485  m_boxes_max[n]->setSingleStep(singleStepSize);
486  m_boxes_max[n]->setCorrectionMode(
487  QAbstractSpinBox::CorrectionMode::CorrectToNearestValue);
488  }
489  }
490 }
491 
492 void ccColorFromScalarDlg::updateChannel(int n) {
493  if (!m_systemInvalid) {
494  if (n >= c_channelCount || n < 0) {
495  CVLog::Error(
496  "[ccColorFromScalarDlg] updateChannel called with an "
497  "invalid channel index");
498  return;
499  }
500 
501  ccScalarField* sf = static_cast<ccScalarField*>(
502  m_cloud->getScalarField(m_combos[n]->currentIndex()));
503  if (sf) {
504  m_scalars[n] = sf;
505  setDefaultSatValuePerChannel(n);
506  m_histograms[n]->clear(); // clear last histogram
507  m_histograms[n]->fromSF(m_scalars[n], 255, false,
508  true); // generate new one
509  updateHistogram(n); // update plotting etc.
510  }
511  }
512 }
513 
514 void ccColorFromScalarDlg::setDefaultSatValuePerChannel(int n) {
515  if (!m_systemInvalid) {
516  if (n >= c_channelCount || n < 0) {
517  CVLog::Error(
518  "[ccColorFromScalarDlg] setDefaultSatValuePerChannel "
519  "called with an invalid channel index");
520  return;
521  }
522  // set default stretch (n.b. this is a cheap hack to avoid calculating
523  // percentiles [by assuming uniform data distribution])
524  m_scalars[n]->setColorScale(m_colors[n]);
525  m_minSat[n] = m_scalars[n]->getMin();
526  m_maxSat[n] = m_scalars[n]->getMax();
527  updateSpinBoxLimits(n);
528  ScalarType range = m_maxSat[n] - m_minSat[n];
529  m_histograms[n]->setMinSatValue(m_minSat[n] + 0.1 * range);
530  m_boxes_min[n]->setValue(m_minSat[n] + 0.1 * range);
531  m_histograms[n]->setMaxSatValue(m_maxSat[n] - 0.1 * range);
532  m_boxes_max[n]->setValue(m_maxSat[n] - 0.1 * range);
533  }
534 }
535 
536 void ccColorFromScalarDlg::resizeEvent(QResizeEvent* event) {
537  refreshDisplay();
538 }
539 
540 // mapping ranges changed
541 void ccColorFromScalarDlg::minChanged(int n, double val, bool slider) {
542  if (n >= c_channelCount || n < 0) {
543  CVLog::Error(
544  "[ccColorFromScalarDlg] minChanged called with an invalid "
545  "channel index");
546  return;
547  }
548  if (val <= m_maxSat[n]) // valid value?
549  {
550  m_scalars[n]->setColorScale(m_colors[n]);
551  m_minSat[n] = val;
552  if (slider) // change was made with the slider
553  {
554  m_boxes_min[n]->setValue(val);
555  } else // change was made with text box
556  {
557  m_histograms[n]->setMinSatValue(val);
558  }
559  } else {
560  // CVLog::Warning(QString("minChanged Channel %1 failed New min > max,
561  // val = %2, maxval = %3").arg(n).arg(val).arg(m_maxSat[n]));
562  }
563 }
564 
565 void ccColorFromScalarDlg::maxChanged(int n, double val, bool slider) {
566  if (n >= c_channelCount || n < 0) {
567  CVLog::Error(
568  "[ccColorFromScalarDlg] maxChanged called with an invalid "
569  "channel index");
570  return;
571  }
572  if (val >= m_minSat[n]) // valid value?
573  {
574  m_scalars[n]->setColorScale(m_colors[n]);
575  m_maxSat[n] = val;
576  if (slider) // change was made with the slider
577  {
578  m_boxes_max[n]->setValue(val);
579  } else // change was made with text box
580  {
581  m_histograms[n]->setMaxSatValue(val);
582  }
583  } else {
584  // CVLog::Warning(QString("maxChanged Channel %1 failed New max < min,
585  // val = %2, minval = %3").arg(n).arg(val).arg(m_minSat[n]));
586  }
587 }
588 
589 void ccColorFromScalarDlg::onApply() {
590  if (!m_systemInvalid) {
591  if (!m_cloud->hasColors()) {
592  m_cloud->resizeTheRGBTable(false);
593  }
594 
595  // which maps to flip?
596  bool reversed[c_channelCount] = {
597  m_ui->reverseR->isChecked(), m_ui->reverseG->isChecked(),
598  m_ui->reverseB->isChecked(), m_ui->reverseA->isChecked()};
599 
600  // and which are fixed?
601  bool fixed[c_channelCount] = {
602  m_ui->fixR->isChecked(), m_ui->fixG->isChecked(),
603  m_ui->fixB->isChecked(), m_ui->fixA->isChecked()};
604 
605  // map scalar values to RGB
606  if (m_ui->toggleRGB->isChecked()) {
607  int col[c_channelCount];
608  for (unsigned p = 0; p < m_cloud->size(); p++) {
609  // get col
610  for (unsigned i = 0; i < c_channelCount; i++) {
611  if (fixed[i]) // fixed value
612  {
613  col[i] = static_cast<int>(m_boxes_min[i]->value());
614  } else // map from scalar
615  {
616  col[i] = static_cast<int>(
617  255.0 *
618  (m_scalars[i]->getValue(p) - m_minSat[i]) /
619  (m_maxSat[i] - m_minSat[i]));
620  }
621 
622  // trim to range 0 - 255
623  col[i] = std::max(col[i], 0);
624  col[i] = std::min(col[i], 255);
625 
626  // flip?
627  if (reversed[i] && !fixed[i]) {
628  col[i] = 255 - col[i];
629  }
630  }
631  m_cloud->setPointColor(
632  p, ecvColor::FromQColora(
633  QColor(col[0], col[1], col[2], col[3])));
634  }
635  } else // map scalar values to HSV (and then to RGB)
636  {
637  float col[c_channelCount];
638  for (unsigned p = 0; p < m_cloud->size(); p++) {
639  // get col
640  for (unsigned i = 0; i < c_channelCount; i++) {
641  if (fixed[i]) // fixed value
642  {
643  col[i] =
644  m_boxes_min[i]->value() /
645  m_boxes_min[i]
646  ->maximum(); // n.b. most 'fixed' boxes
647  // between 0 - 255, but
648  // hue between 0 and 360.
649  } else // map from scalar
650  {
651  col[i] = (m_scalars[i]->getValue(p) - m_minSat[i]) /
652  (m_maxSat[i] - m_minSat[i]);
653  }
654 
655  // trim to range 0 - 1
656  col[i] = std::max(col[i], 0.0f);
657  col[i] = std::min(col[i], 1.0f);
658 
659  // flip?
660  if (reversed[i] && !fixed[i]) {
661  col[i] = 1.0f - col[i];
662  }
663  }
664 
665  // calculate and set colour
666  ecvColor::Rgb rgb = ecvColor::Convert::hsv2rgb(col[0] * 360.0f,
667  col[1], col[2]);
668  m_cloud->setPointColor(
669  p,
670  ecvColor::Rgba(
671  rgb, static_cast<int>(col[3] * ecvColor::MAX)));
672  }
673  }
674  m_cloud->colorsHaveChanged();
675  m_cloud->showSF(false);
676  m_cloud->showColors(true);
677  m_cloud->redrawDisplay();
678  }
679 }
680 
681 void ccColorFromScalarDlg::disableAllButCancel() {
682  for (unsigned n = 0; n < c_channelCount; n++) {
683  m_histograms[n]->setEnabled(false);
684  m_combos[n]->setEnabled(false);
685  m_boxes_min[n]->setEnabled(false);
686  m_boxes_max[n]->setEnabled(false);
687  m_labels_min[n]->setEnabled(false);
688  m_labels_max[n]->setEnabled(false);
689  m_reverse[n]->setEnabled(false);
690  }
691  m_ui->toggleHSV->setEnabled(false);
692  m_ui->toggleRGB->setEnabled(false);
693  m_ui->fixR->setEnabled(false);
694  m_ui->fixG->setEnabled(false);
695  m_ui->fixB->setEnabled(false);
696  m_ui->fixA->setEnabled(false);
697  m_ui->buttonBox->button(QDialogButtonBox::Apply)->setEnabled(false);
698 }
event
MouseEvent event
Definition: BitmapWindowSystem.cpp:61
CVLog::Error
static bool Error(const char *format,...)
Display an error dialog with formatted message.
Definition: CVLog.cpp:143
ccColorFromScalarDlg::m_boxes_min
QDoubleSpinBox * m_boxes_min[c_channelCount]
Definition: ecvColorFromScalarDlg.h:89
ccColorFromScalarDlg::m_storedOrigColorScale
ccColorScale::Shared m_storedOrigColorScale
Associated point cloud scalar field original scale (to restore on exit)
Definition: ecvColorFromScalarDlg.h:102
ccColorFromScalarDlg::m_labels_max
QLabel * m_labels_max[c_channelCount]
Definition: ecvColorFromScalarDlg.h:92
ccColorFromScalarDlg::minSpinChangedG
void minSpinChangedG(double val)
Definition: ecvColorFromScalarDlg.h:60
ccColorFromScalarDlg::minChanged
void minChanged(int n, double val, bool slider)
Definition: ecvColorFromScalarDlg.cpp:541
ccColorFromScalarDlg::maxSpinChangedA
void maxSpinChangedA(double val)
Definition: ecvColorFromScalarDlg.h:65
ccColorFromScalarDlg::minChangedR
void minChangedR(double val)
Definition: ecvColorFromScalarDlg.h:50
ccColorFromScalarDlg::minSpinChangedA
void minSpinChangedA(double val)
Definition: ecvColorFromScalarDlg.h:64
ccColorFromScalarDlg::maxSpinChangedG
void maxSpinChangedG(double val)
Definition: ecvColorFromScalarDlg.h:61
ccColorFromScalarDlg::maxChangedB
void maxChangedB(double val)
Definition: ecvColorFromScalarDlg.h:55
ccColorFromScalarDlg::minChangedB
void minChangedB(double val)
Definition: ecvColorFromScalarDlg.h:54
ccColorFromScalarDlg::toggleColorMode
void toggleColorMode(bool state)
Definition: ecvColorFromScalarDlg.cpp:367
ccColorFromScalarDlg::maxChangedG
void maxChangedG(double val)
Definition: ecvColorFromScalarDlg.h:53
ccColorFromScalarDlg::maxChanged
void maxChanged(int n, double val, bool slider)
Definition: ecvColorFromScalarDlg.cpp:565
ccColorFromScalarDlg::maxSpinChangedB
void maxSpinChangedB(double val)
Definition: ecvColorFromScalarDlg.h:63
ccColorFromScalarDlg::m_histograms
ccHistogramWindow * m_histograms[c_channelCount]
Associated histogram view.
Definition: ecvColorFromScalarDlg.h:82
ccColorFromScalarDlg::m_maxSat
double m_maxSat[c_channelCount]
Definition: ecvColorFromScalarDlg.h:96
ccColorFromScalarDlg::minSpinChangedR
void minSpinChangedR(double val)
Definition: ecvColorFromScalarDlg.h:58
ccColorFromScalarDlg::m_colors
ccColorScale::Shared m_colors[c_channelCount]
Associated colour scales.
Definition: ecvColorFromScalarDlg.h:98
ccColorFromScalarDlg::m_reverse
QCheckBox * m_reverse[c_channelCount]
Definition: ecvColorFromScalarDlg.h:93
ccColorFromScalarDlg::m_labels_min
QLabel * m_labels_min[c_channelCount]
Definition: ecvColorFromScalarDlg.h:91
ccColorFromScalarDlg::maxChangedR
void maxChangedR(double val)
Definition: ecvColorFromScalarDlg.h:51
ccColorFromScalarDlg::m_scalars
ccScalarField * m_scalars[c_channelCount]
Definition: ecvColorFromScalarDlg.h:85
ccColorFromScalarDlg::c_channelCount
static constexpr int c_channelCount
Definition: ecvColorFromScalarDlg.h:34
ccColorFromScalarDlg::m_storedOrigSatRange
ccScalarField::Range m_storedOrigSatRange
Definition: ecvColorFromScalarDlg.h:103
ccColorFromScalarDlg::minSpinChangedB
void minSpinChangedB(double val)
Definition: ecvColorFromScalarDlg.h:62
ccColorFromScalarDlg::maxChangedA
void maxChangedA(double val)
Definition: ecvColorFromScalarDlg.h:57
ccColorFromScalarDlg::minChangedG
void minChangedG(double val)
Definition: ecvColorFromScalarDlg.h:52
ccColorFromScalarDlg::minChangedA
void minChangedA(double val)
Definition: ecvColorFromScalarDlg.h:56
ccColorFromScalarDlg::m_prevFixed
bool m_prevFixed[c_channelCount]
Definition: ecvColorFromScalarDlg.h:80
ccColorFromScalarDlg::m_boxes_max
QDoubleSpinBox * m_boxes_max[c_channelCount]
Definition: ecvColorFromScalarDlg.h:90
ccColorFromScalarDlg::m_combos
QComboBox * m_combos[c_channelCount]
Definition: ecvColorFromScalarDlg.h:88
ccColorFromScalarDlg::m_storedOrigDisplayRange
ccScalarField::Range m_storedOrigDisplayRange
Definition: ecvColorFromScalarDlg.h:104
ccColorFromScalarDlg::resizeEvent
void resizeEvent(QResizeEvent *event)
Definition: ecvColorFromScalarDlg.cpp:536
ccColorFromScalarDlg::ccColorFromScalarDlg
ccColorFromScalarDlg(QWidget *parent, ccPointCloud *pointCloud)
Default constructor.
Definition: ecvColorFromScalarDlg.cpp:29
ccColorFromScalarDlg::m_cloud
ccPointCloud * m_cloud
Associated point cloud (color source)
Definition: ecvColorFromScalarDlg.h:100
ccColorFromScalarDlg::m_minSat
double m_minSat[c_channelCount]
Definition: ecvColorFromScalarDlg.h:95
ccColorFromScalarDlg::maxSpinChangedR
void maxSpinChangedR(double val)
Definition: ecvColorFromScalarDlg.h:59
ccColorScaleElement
Color scale element: one value + one color.
Definition: ecvColorScale.h:22
ccColorScale
Color scale.
Definition: ecvColorScale.h:71
ccColorScale::Shared
QSharedPointer< ccColorScale > Shared
Shared pointer type.
Definition: ecvColorScale.h:74
ccDrawableObject::showColors
virtual void showColors(bool state)
Sets colors visibility.
Definition: ecvDrawableObject.h:84
ccDrawableObject::showSF
virtual void showSF(bool state)
Sets active scalarfield visibility.
Definition: ecvDrawableObject.h:108
ccHObject::redrawDisplay
virtual void redrawDisplay(bool forceRedraw=true, bool only2D=false)
Redraws associated display.
ccHistogramWindow
Histogram widget.
Definition: ecvHistogramWindow.h:28
ccHistogramWindow::sfMaxSatValChanged
void sfMaxSatValChanged(double)
ccHistogramWindow::sfMinSatValChanged
void sfMinSatValChanged(double)
ccHistogramWindow::refresh
void refresh()
Updates the display.
Definition: ecvHistogramWindow.cpp:323
ccHistogramWindow::fromSF
void fromSF(ccScalarField *sf, unsigned initialNumberOfClasses=0, bool numberOfClassesCanBeChanged=true, bool showNaNValuesInGrey=true)
Computes histogram from a scalar field.
Definition: ecvHistogramWindow.cpp:127
ccHistogramWindow::fromBinArray
void fromBinArray(const std::vector< unsigned > &histoValues, double minVal, double maxVal)
Definition: ecvHistogramWindow.cpp:153
ccHistogramWindow::setAxisDisplayOption
void setAxisDisplayOption(AxisDisplayOptions axisOptions)
Definition: ecvHistogramWindow.cpp:315
ccHistogramWindow::setRefreshAfterResize
void setRefreshAfterResize(bool refreshAfterResize)
Definition: ecvHistogramWindow.cpp:319
ccHistogramWindow::setSFInteractionMode
void setSFInteractionMode(SFInteractionModes modes)
Enables SF interaction mode.
Definition: ecvHistogramWindow.cpp:311
ccHistogramWindow::clear
void clear()
Clears the display.
Definition: ecvHistogramWindow.cpp:87
ccHistogramWindow::setAxisLabels
void setAxisLabels(const QString &xLabel, const QString &yLabel)
Sets axis labels.
Definition: ecvHistogramWindow.cpp:108
ccPointCloud
A 3D cloud and its associated features (color, normals, scalar fields, etc.)
Definition: ecvPointCloud.h:147
ccPointCloud::setCurrentDisplayedScalarField
void setCurrentDisplayedScalarField(int index)
Sets the currently displayed scalar field.
ccPointCloud::resizeTheRGBTable
bool resizeTheRGBTable(bool fillWithWhite=false)
Resizes the RGB colors array.
ccPointCloud::getCurrentDisplayedScalarFieldIndex
int getCurrentDisplayedScalarFieldIndex() const
Returns the currently displayed scalar field index (or -1 if none)
ccPointCloud::hasColors
bool hasColors() const override
Returns whether colors are enabled or not.
ccPointCloud::setPointColor
void setPointColor(size_t pointIndex, const ecvColor::Rgb &col)
Sets a particular point color.
ccPointCloud::getCurrentDisplayedScalarField
ccScalarField * getCurrentDisplayedScalarField() const
Returns the currently displayed scalar (or 0 if none)
ccPointCloud::colorsHaveChanged
void colorsHaveChanged()
Definition: ecvPointCloud.h:276
ccScalarField::Range::min
ScalarType min() const
Definition: ecvScalarField.h:42
ccScalarField::Range::max
ScalarType max() const
Definition: ecvScalarField.h:45
ccScalarField
A scalar field associated to display-related parameters.
Definition: ecvScalarField.h:20
ccScalarField::getColorScale
const ccColorScale::Shared & getColorScale() const
Returns associated color scale.
Definition: ecvScalarField.h:186
ccScalarField::setSaturationStop
void setSaturationStop(ScalarType val)
Sets the value at which to stop color gradient.
ccScalarField::setMinDisplayed
void setMinDisplayed(ScalarType val)
Sets the minimum displayed value.
ccScalarField::setColorScale
void setColorScale(ccColorScale::Shared scale)
Sets associated color scale.
ccScalarField::saturationRange
const Range & saturationRange() const
Access to the range of saturation values.
Definition: ecvScalarField.h:114
ccScalarField::displayRange
const Range & displayRange() const
Access to the range of displayed values.
Definition: ecvScalarField.h:108
ccScalarField::setSaturationStart
void setSaturationStart(ScalarType val)
Sets the value at which to start color gradient.
ccScalarField::setMaxDisplayed
void setMaxDisplayed(ScalarType val)
Sets the maximum displayed value.
cloudViewer::PointCloudTpl::getScalarField
ScalarField * getScalarField(int index) const
Returns a pointer to a specific scalar field.
Definition: PointCloudTpl.h:354
cloudViewer::PointCloudTpl::getNumberOfScalarFields
unsigned getNumberOfScalarFields() const
Returns the number of associated (and active) scalar fields.
Definition: PointCloudTpl.h:345
cloudViewer::PointCloudTpl::size
unsigned size() const override
Definition: PointCloudTpl.h:38
cloudViewer::PointCloudTpl::getScalarFieldName
const char * getScalarFieldName(int index) const
Returns the name of a specific scalar field.
Definition: PointCloudTpl.h:365
cloudViewer::ScalarField::getMin
ScalarType getMin() const
Returns the minimum value.
Definition: ScalarField.h:72
cloudViewer::ScalarField::getValue
ScalarType & getValue(std::size_t index)
Definition: ScalarField.h:92
cloudViewer::ScalarField::getMax
ScalarType getMax() const
Returns the maximum value.
Definition: ScalarField.h:74
ecvColor::Convert::hsv2rgb
static Rgb hsv2rgb(float H, float S, float V)
Converts a HSV color to RGB color space.
Definition: ecvColorTypes.h:286
ecvColor::RgbTpl
RGB color structure.
Definition: ecvColorTypes.h:49
ecvColor::RgbaTpl
RGBA color structure.
Definition: ecvColorTypes.h:145
min
int min(int a, int b)
Definition: cutil_math.h:53
max
int max(int a, int b)
Definition: cutil_math.h:48
cloudViewer::core::None
constexpr utility::nullopt_t None
Definition: TensorKey.h:20
ecvColor::black
constexpr Rgb black(0, 0, 0)
ecvColor::white
constexpr Rgb white(MAX, MAX, MAX)
ecvColor::MAX
constexpr ColorCompType MAX
Max value of a single color component (default type)
Definition: ecvColorTypes.h:34
ecvColor::FromQColora
Rgba FromQColora(QColor qColor)
Conversion from QColor'a'.
Definition: ecvColorTypes.h:433
ecvColor::red
constexpr Rgb red(MAX, 0, 0)
ecvColor::blue
constexpr Rgb blue(0, 0, MAX)
ecvColor::green
constexpr Rgb green(0, MAX, 0)