18046302584

Committed 26 Sep 2025 06:22PM UTC coverage: 69.725% (-0.06%) from 69.782%

Build # 18046302584

Build Type

push

github

Committed by

paulmthompson

Commit Message

median filter shouldn't have kernel size > 5 if bit depth is > 8

Coverage Stats

2 of 55 new or added lines in 3 files covered. (3.64%)

42954 of 61605 relevant lines covered (69.72%)

1127.82 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

17.11

/src/WhiskerToolbox/Media_Widget/MediaProcessing_Widget/ProcessingOptions/MedianWidget.cpp

#include "MedianWidget.hpp"
#include "ui_MedianWidget.h"

#include <QCheckBox>
#include <QSpinBox>

MedianWidget::MedianWidget(QWidget* parent)
    : QWidget(parent),
      ui(new Ui::MedianWidget) {
    ui->setupUi(this);

    // Connect UI controls to slots
    connect(ui->active_checkbox, &QCheckBox::toggled,
            this, &MedianWidget::_onActiveChanged);
    connect(ui->kernel_size_spinbox, QOverload<int>::of(&QSpinBox::valueChanged),
            this, &MedianWidget::_onKernelSizeChanged);

    // Ensure odd-only stepping and minimum of 3
    ui->kernel_size_spinbox->setSingleStep(2);
    if (ui->kernel_size_spinbox->value() % 2 == 0)
        ui->kernel_size_spinbox->setValue(ui->kernel_size_spinbox->value() + 1);
}

MedianWidget::~MedianWidget() {
    delete ui;
}

MedianOptions MedianWidget::getOptions() const {
    MedianOptions options;
    options.active = ui->active_checkbox->isChecked();
    options.kernel_size = ui->kernel_size_spinbox->value();
    return options;
}

void MedianWidget::setOptions(MedianOptions const& options) {
    _blockSignalsAndSetValues(options);
}

void MedianWidget::setKernelConstraints(bool is_8bit_grayscale) {
    if (_is_8bit_grayscale == is_8bit_grayscale) {
        // Still enforce odd/clamp to current limits
        _enforceOddAndClamp();
        return;
    }

    _is_8bit_grayscale = is_8bit_grayscale;

    // Update tooltip to reflect constraint
    QString tip = "Size of the median filter kernel. Must be odd and >= 3.";
    if (!_is_8bit_grayscale) {
        tip += " For non-8-bit grayscale images, the maximum allowed size is 5 (OpenCV).";
    } else {
        tip += " Larger values produce stronger smoothing.";
    }
    ui->kernel_size_spinbox->setToolTip(tip);

    // Adjust max according to constraint
    // Allow up to 21 for 8-bit grayscale as per current UI defaults
    int max_allowed = _is_8bit_grayscale ? 21 : 5;

    // Block signals during range and value adjustment
    ui->kernel_size_spinbox->blockSignals(true);
    ui->kernel_size_spinbox->setRange(3, max_allowed);
    // Ensure current value respects the new limits and odd requirement
    _enforceOddAndClamp();
    ui->kernel_size_spinbox->blockSignals(false);

    // Emit updated options after constraints changed
    emit optionsChanged(getOptions());
}

void MedianWidget::_onActiveChanged() {
    _updateOptions();
}

void MedianWidget::_onKernelSizeChanged() {
    // Enforce odd and clamped value when user edits
    _enforceOddAndClamp();

    // Auto-enable when user changes values
    if (!ui->active_checkbox->isChecked()) {
        ui->active_checkbox->blockSignals(true);
        ui->active_checkbox->setChecked(true);
        ui->active_checkbox->blockSignals(false);
    }
    _updateOptions();
}

void MedianWidget::_updateOptions() {
    emit optionsChanged(getOptions());
}

void MedianWidget::_blockSignalsAndSetValues(MedianOptions const& options) {
    // Block signals to prevent triggering optionsChanged during programmatic updates
    ui->active_checkbox->blockSignals(true);
    ui->kernel_size_spinbox->blockSignals(true);

    // Set values
    ui->active_checkbox->setChecked(options.active);
    ui->kernel_size_spinbox->setValue(options.kernel_size);

    // Enforce constraints after setting programmatically
    _enforceOddAndClamp();

    // Unblock signals
    ui->active_checkbox->blockSignals(false);
    ui->kernel_size_spinbox->blockSignals(false);

    // Emit signal after all values are set
    emit optionsChanged(getOptions());
}

void MedianWidget::_enforceOddAndClamp() {
    int v = ui->kernel_size_spinbox->value();
    if (v < 3) v = 3;
    if ((v % 2) == 0) v += 1; // bump to next odd

    int maxv = ui->kernel_size_spinbox->maximum();
    if (v > maxv) {
        // Ensure we pick an odd value <= max
        v = (maxv % 2) ? maxv : (maxv - 1);
        if (v < 3) v = 3; // final guard
    }

    if (v != ui->kernel_size_spinbox->value()) {
        bool blocked = ui->kernel_size_spinbox->blockSignals(true);
        ui->kernel_size_spinbox->setValue(v);
        ui->kernel_size_spinbox->blockSignals(blocked);
    }
}

1	#include "MedianWidget.hpp"
2	#include "ui_MedianWidget.h"
3
4	#include <QCheckBox>
5	#include <QSpinBox>
6
7	MedianWidget::MedianWidget(QWidget* parent)	3✔
8	: QWidget(parent),
9	ui(new Ui::MedianWidget) {	3✔
10	ui->setupUi(this);	3✔
11
12	// Connect UI controls to slots
13	connect(ui->active_checkbox, &QCheckBox::toggled,	9✔
14	this, &MedianWidget::_onActiveChanged);	6✔
15	connect(ui->kernel_size_spinbox, QOverload<int>::of(&QSpinBox::valueChanged),	9✔
16	this, &MedianWidget::_onKernelSizeChanged);	6✔
17
18	// Ensure odd-only stepping and minimum of 3
19	ui->kernel_size_spinbox->setSingleStep(2);	3✔
20	if (ui->kernel_size_spinbox->value() % 2 == 0)	3✔
NEW 21	ui->kernel_size_spinbox->setValue(ui->kernel_size_spinbox->value() + 1);	×
22	}	3✔
23
24	MedianWidget::~MedianWidget() {	6✔
25	delete ui;	3✔
26	}	6✔
27
28	MedianOptions MedianWidget::getOptions() const {	×
29	MedianOptions options;	×
30	options.active = ui->active_checkbox->isChecked();	×
31	options.kernel_size = ui->kernel_size_spinbox->value();	×
32	return options;	×
33	}
34
35	void MedianWidget::setOptions(MedianOptions const& options) {	×
36	_blockSignalsAndSetValues(options);	×
37	}	×
38
NEW 39	void MedianWidget::setKernelConstraints(bool is_8bit_grayscale) {	×
NEW 40	if (_is_8bit_grayscale == is_8bit_grayscale) {	×
41	// Still enforce odd/clamp to current limits
NEW 42	_enforceOddAndClamp();	×
NEW 43	return;	×
44	}
45
NEW 46	_is_8bit_grayscale = is_8bit_grayscale;	×
47
48	// Update tooltip to reflect constraint
NEW 49	QString tip = "Size of the median filter kernel. Must be odd and >= 3.";	×
NEW 50	if (!_is_8bit_grayscale) {	×
NEW 51	tip += " For non-8-bit grayscale images, the maximum allowed size is 5 (OpenCV).";	×
52	} else {
NEW 53	tip += " Larger values produce stronger smoothing.";	×
54	}
NEW 55	ui->kernel_size_spinbox->setToolTip(tip);	×
56
57	// Adjust max according to constraint
58	// Allow up to 21 for 8-bit grayscale as per current UI defaults
NEW 59	int max_allowed = _is_8bit_grayscale ? 21 : 5;	×
60
61	// Block signals during range and value adjustment
NEW 62	ui->kernel_size_spinbox->blockSignals(true);	×
NEW 63	ui->kernel_size_spinbox->setRange(3, max_allowed);	×
64	// Ensure current value respects the new limits and odd requirement
NEW 65	_enforceOddAndClamp();	×
NEW 66	ui->kernel_size_spinbox->blockSignals(false);	×
67
68	// Emit updated options after constraints changed
NEW 69	emit optionsChanged(getOptions());	×
NEW 70	}	×
71
72	void MedianWidget::_onActiveChanged() {	×
73	_updateOptions();	×
74	}	×
75
76	void MedianWidget::_onKernelSizeChanged() {	×
77	// Enforce odd and clamped value when user edits
NEW 78	_enforceOddAndClamp();	×
79
80	// Auto-enable when user changes values
81	if (!ui->active_checkbox->isChecked()) {	×
82	ui->active_checkbox->blockSignals(true);	×
83	ui->active_checkbox->setChecked(true);	×
84	ui->active_checkbox->blockSignals(false);	×
85	}
86	_updateOptions();	×
87	}	×
88
89	void MedianWidget::_updateOptions() {	×
90	emit optionsChanged(getOptions());	×
91	}	×
92
93	void MedianWidget::_blockSignalsAndSetValues(MedianOptions const& options) {	×
94	// Block signals to prevent triggering optionsChanged during programmatic updates
95	ui->active_checkbox->blockSignals(true);	×
96	ui->kernel_size_spinbox->blockSignals(true);	×
97
98	// Set values
99	ui->active_checkbox->setChecked(options.active);	×
100	ui->kernel_size_spinbox->setValue(options.kernel_size);	×
101
102	// Enforce constraints after setting programmatically
NEW 103	_enforceOddAndClamp();	×
104
105	// Unblock signals
106	ui->active_checkbox->blockSignals(false);	×
107	ui->kernel_size_spinbox->blockSignals(false);	×
108
109	// Emit signal after all values are set
110	emit optionsChanged(getOptions());	×
111	}	×
112
NEW 113	void MedianWidget::_enforceOddAndClamp() {	×
NEW 114	int v = ui->kernel_size_spinbox->value();	×
NEW 115	if (v < 3) v = 3;	×
NEW 116	if ((v % 2) == 0) v += 1; // bump to next odd	×
117
NEW 118	int maxv = ui->kernel_size_spinbox->maximum();	×
NEW 119	if (v > maxv) {	×
120	// Ensure we pick an odd value <= max
NEW 121	v = (maxv % 2) ? maxv : (maxv - 1);	×
NEW 122	if (v < 3) v = 3; // final guard	×
123	}
124
NEW 125	if (v != ui->kernel_size_spinbox->value()) {	×
NEW 126	bool blocked = ui->kernel_size_spinbox->blockSignals(true);	×
NEW 127	ui->kernel_size_spinbox->setValue(v);	×
NEW 128	ui->kernel_size_spinbox->blockSignals(blocked);	×
129	}
NEW 130	}	×

paulmthompson / WhiskerToolbox / 18046302584

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous