ecvColorLevelsDlg.cpp

Go to the documentation of this file.

// ----------------------------------------------------------------------------
// -                        CloudViewer: www.cloudViewer.org                  -
// ----------------------------------------------------------------------------
// Copyright (c) 2018-2024 www.cloudViewer.org
// SPDX-License-Identifier: MIT
// ----------------------------------------------------------------------------
 
#include "ecvColorLevelsDlg.h"
 
// local
#include "ecvGenericPointCloud.h"
#include "ecvHistogramWindow.h"
 
// CV_DB_LIB
#include <ecvDisplayTools.h>
#include <ecvHObjectCaster.h>
#include <ecvPointCloud.h>
 
// Qt
#include <QPushButton>
 
// system
#include <assert.h>
#include <string.h>
 
// persistent parameters
static int s_inputLevels[2] = {0, 255};
static int s_outputLevels[2] = {0, 255};
static bool s_outputLevelsEnabled = false;
 
ccColorLevelsDlg::ccColorLevelsDlg(QWidget* parent,
                                   ccGenericPointCloud* pointCloud)
    : QDialog(parent, Qt::Tool),
      Ui::ColorLevelsDialog(),
      m_histogram(0),
      m_cloud(pointCloud) {
    setupUi(this);
 
    // connect GUI elements
    connect(channelComboBox,
            static_cast<void (QComboBox::*)(int)>(
                    &QComboBox::currentIndexChanged),
            this, &ccColorLevelsDlg::onChannelChanged);
    connect(buttonBox->button(QDialogButtonBox::Apply), &QPushButton::clicked,
            this, &ccColorLevelsDlg::onApply);
 
    // create histogram view
    m_histogram = new ccHistogramWindow(this);
    {
        m_histogram->setColorScheme(ccHistogramWindow::USE_SOLID_COLOR);
        m_histogram->setSolidColor(Qt::black);
        // add view
        histoFrame->setLayout(new QHBoxLayout());
        histoFrame->layout()->addWidget(m_histogram);
    }
 
    // restore previous parameters
    minInputSpinBox->setValue(s_inputLevels[0]);
    maxInputSpinBox->setValue(s_inputLevels[1]);
    minOutputSpinBox->setValue(s_outputLevels[0]);
    maxOutputSpinBox->setValue(s_outputLevels[1]);
    outputLevelsCheckBox->setChecked(s_outputLevelsEnabled);
 
    updateHistogram();
}
 
void ccColorLevelsDlg::updateHistogram() {
    if (m_histogram) {
        unsigned pointCount = (m_cloud ? m_cloud->size() : 0);
        if (pointCount == 0) {
            // nothing to do
            m_histogram->clear();
            return;
        }
 
        std::vector<unsigned> histoValues[3];
        try {
            for (int i = 0; i < 3; ++i) {
                if (channelComboBox->currentIndex() == RGB ||
                    channelComboBox->currentIndex() == i + 1) {
                    histoValues[i].resize(1 << (sizeof(ColorCompType) * 8), 0);
                }
            }
        } catch (const std::bad_alloc&) {
            // not enough memory
            m_histogram->clear();
            return;
        }
 
        std::vector<unsigned>* histoValuesR =
                (histoValues[0].empty() ? 0 : histoValues);
        std::vector<unsigned>* histoValuesG =
                (histoValues[1].empty() ? 0 : histoValues + 1);
        std::vector<unsigned>* histoValuesB =
                (histoValues[2].empty() ? 0 : histoValues + 2);
 
        switch (channelComboBox->currentIndex()) {
            case RGB:
                m_histogram->setSolidColor(Qt::black);
                m_histogram->setAxisLabels("R,G,B", "");
                // test: for now we send all data into the same histogram!
                histoValuesG = histoValuesR;
                histoValuesB = histoValuesR;
                break;
            case RED:
                m_histogram->setSolidColor(Qt::red);
                m_histogram->setAxisLabels("Red", "");
                break;
            case GREEN:
                m_histogram->setSolidColor(Qt::green);
                m_histogram->setAxisLabels("Green", "");
                break;
            case BLUE:
                m_histogram->setSolidColor(Qt::blue);
                m_histogram->setAxisLabels("Blue", "");
                break;
        }
 
        // project points
        {
            for (unsigned i = 0; i < pointCount; ++i) {
                const ecvColor::Rgb& rgb = m_cloud->getPointColor(i);
                if (histoValuesR) histoValuesR->at(rgb.r)++;
                if (histoValuesG) histoValuesG->at(rgb.g)++;
                if (histoValuesB) histoValuesB->at(rgb.b)++;
            }
        }
 
        for (int i = 0; i < 3; ++i) {
            if (channelComboBox->currentIndex() == RGB ||
                channelComboBox->currentIndex() == i + 1) {
                m_histogram->fromBinArray(histoValues[i], 0.0, 256.0);
                break;
            }
        }
        m_histogram->refresh();
    }
}
 
void ccColorLevelsDlg::onChannelChanged(int channel) { updateHistogram(); }
 
void ccColorLevelsDlg::onApply() {
    // save parameters
    s_inputLevels[0] = minInputSpinBox->value();
    s_inputLevels[1] = maxInputSpinBox->value();
    s_outputLevels[0] = minOutputSpinBox->value();
    s_outputLevels[1] = maxOutputSpinBox->value();
    s_outputLevelsEnabled = outputLevelsCheckBox->isChecked();
 
    if (m_cloud &&
        (minInputSpinBox->value() != 0 || maxInputSpinBox->value() != 255 ||
         minOutputSpinBox->value() != 0 || maxOutputSpinBox->value() != 255)) {
        bool applyRGB[3] = {channelComboBox->currentIndex() == RGB ||
                                    channelComboBox->currentIndex() == RED,
                            channelComboBox->currentIndex() == RGB ||
                                    channelComboBox->currentIndex() == GREEN,
                            channelComboBox->currentIndex() == RGB ||
                                    channelComboBox->currentIndex() == BLUE};
 
        // update display
        ccPointCloud* pc = ccHObjectCaster::ToPointCloud(m_cloud);
 
        unsigned pointCount = m_cloud->size();
        int qIn = s_inputLevels[1] - s_inputLevels[0];
        int pOut = s_outputLevels[1] - s_outputLevels[0];
        for (unsigned i = 0; i < pointCount; ++i) {
            const ecvColor::Rgb& rgb = m_cloud->getPointColor(i);
            ecvColor::Rgb newRgb;
            for (unsigned c = 0; c < 3; ++c) {
                if (applyRGB[c]) {
                    double newC = s_outputLevels[0];
                    if (qIn) {
                        double u = (static_cast<double>(rgb.rgb[c]) -
                                    s_inputLevels[0]) /
                                   qIn;
                        newC = s_outputLevels[0] + u * pOut;
                    }
                    newRgb.rgb[c] = static_cast<ColorCompType>(std::max<double>(
                            std::min<double>(newC, ecvColor::MAX), 0.0));
                } else {
                    newRgb.rgb[c] = rgb.rgb[c];
                }
            }
 
            // set the new color
            if (pc) {
                pc->setPointColor(i, newRgb);
            } else {
                // DGM FIXME: dirty!
                const_cast<ecvColor::Rgb&>(rgb) = newRgb;
            }
        }
 
        // update display
        ecvDisplayTools::RedrawDisplay();
 
        // update histogram
        onChannelChanged(channelComboBox->currentIndex());
    }
 
    // after applying the filter we reset the boundaries to (0,255)
    // in case the user clicks multiple times on the "Apply" button!
    minInputSpinBox->setValue(0);
    maxInputSpinBox->setValue(255);
    minOutputSpinBox->setValue(0);
    maxOutputSpinBox->setValue(255);
}