17346268452

Committed 30 Aug 2025 04:51PM UTC coverage: 68.446% (+0.6%) from 67.856%

Build # 17346268452

Build Type

push

github

Committed by

paulmthompson

Commit Message

mask skeletonization tests added including with json transformation

Run Details

188 of 194 new or added lines in 1 file covered. (96.91%)

169 existing lines in 4 files now uncovered.

28772 of 42036 relevant lines covered (68.45%)

1418.98 hits per line

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

95.56

/src/DataManager/transforms/ParameterFactory.cpp

#include "ParameterFactory.hpp"

#include "AnalogTimeSeries/AnalogFilter/analog_filter.hpp"
#include "AnalogTimeSeries/AnalogHilbertPhase/analog_hilbert_phase.hpp"
#include "AnalogTimeSeries/Analog_Event_Threshold/analog_event_threshold.hpp"
#include "AnalogTimeSeries/Analog_Interval_Threshold/analog_interval_threshold.hpp"
#include "DigitalIntervalSeries/Digital_Interval_Group/digital_interval_group.hpp"
#include "Lines/Line_Alignment/line_alignment.hpp"
#include "Lines/Line_Angle/line_angle.hpp"
#include "Lines/Line_Min_Point_Dist/line_min_point_dist.hpp"
#include "Lines/Line_Resample/line_resample.hpp"
#include "Masks/Mask_Median_Filter/mask_median_filter.hpp"
#include "Masks/Mask_Connected_Component/mask_connected_component.hpp"
#include "Masks/Mask_Principal_Axis/mask_principal_axis.hpp"

#include <iostream>

void ParameterFactory::registerParameterSetter(std::string const & transform_name,
                                               std::string const & param_name,
                                               ParameterSetter setter) {
    setters_[transform_name][param_name] = std::move(setter);
}

bool ParameterFactory::setParameter(std::string const & transform_name,
                                    TransformParametersBase * param_obj,
                                    std::string const & param_name,
                                    nlohmann::json const & json_value,
                                    DataManager * data_manager) {
    auto transform_it = setters_.find(transform_name);
    if (transform_it == setters_.end()) {
        std::cerr << "No parameter setters registered for transform: " << transform_name << std::endl;
        return false;
    }

    auto param_it = transform_it->second.find(param_name);
    if (param_it == transform_it->second.end()) {
        std::cerr << "No setter registered for parameter '" << param_name
                  << "' in transform '" << transform_name << "'" << std::endl;
        return false;
    }

    return param_it->second(param_obj, json_value, data_manager);
}

ParameterFactory & ParameterFactory::getInstance() {
    static ParameterFactory instance;
    return instance;
}

void ParameterFactory::initializeDefaultSetters() {

    // ==================================================
    // =============== Analog Time Series ===============
    // ==================================================

    // =============== Threshold Event Detection ===============

    registerBasicParameter<ThresholdParams, double>(
            "Threshold Event Detection", "threshold_value", &ThresholdParams::thresholdValue);

    std::unordered_map<std::string, ThresholdParams::ThresholdDirection> event_direction_map = {
            {"Positive (Rising)", ThresholdParams::ThresholdDirection::POSITIVE},
            {"Negative (Falling)", ThresholdParams::ThresholdDirection::NEGATIVE},
            {"Absolute (Magnitude)", ThresholdParams::ThresholdDirection::ABSOLUTE}};

    registerEnumParameter<ThresholdParams, ThresholdParams::ThresholdDirection>(
            "Threshold Event Detection", "direction", &ThresholdParams::direction, event_direction_map);

    registerBasicParameter<ThresholdParams, double>(
            "Threshold Event Detection", "lockout_time", &ThresholdParams::lockoutTime);

    // ============== Analog Interval Threshold ==============

    std::unordered_map<std::string, IntervalThresholdParams::ThresholdDirection> threshold_direction_map = {
            {"Positive (Rising)", IntervalThresholdParams::ThresholdDirection::POSITIVE},
            {"Negative (Falling)", IntervalThresholdParams::ThresholdDirection::NEGATIVE},
            {"Absolute (Magnitude)", IntervalThresholdParams::ThresholdDirection::ABSOLUTE}};

    registerEnumParameter<IntervalThresholdParams, IntervalThresholdParams::ThresholdDirection>(
            "Threshold Interval Detection", "direction", &IntervalThresholdParams::direction, threshold_direction_map);

    registerBasicParameter<IntervalThresholdParams, double>(
            "Threshold Interval Detection", "lockout_time", &IntervalThresholdParams::lockoutTime);

    registerBasicParameter<IntervalThresholdParams, double>(
            "Threshold Interval Detection", "min_duration", &IntervalThresholdParams::minDuration);

    registerBasicParameter<IntervalThresholdParams, double>(
            "Threshold Interval Detection", "threshold_value", &IntervalThresholdParams::thresholdValue);

    std::unordered_map<std::string, IntervalThresholdParams::MissingDataMode> missing_data_mode_map = {
            {"Zero", IntervalThresholdParams::MissingDataMode::TREAT_AS_ZERO},
            {"Ignore", IntervalThresholdParams::MissingDataMode::IGNORE}};
    registerEnumParameter<IntervalThresholdParams, IntervalThresholdParams::MissingDataMode>(
            "Threshold Interval Detection", "missing_data_mode", &IntervalThresholdParams::missingDataMode, missing_data_mode_map);


    // ================ Analog Filter ================

    // Register Analog Filter parameters
    std::unordered_map<std::string, AnalogFilterParams::FilterType> filter_type_map = {
            {"lowpass", AnalogFilterParams::FilterType::Lowpass},
            {"highpass", AnalogFilterParams::FilterType::Highpass},
            {"bandpass", AnalogFilterParams::FilterType::Bandpass},
            {"bandstop", AnalogFilterParams::FilterType::Bandstop}};
    registerEnumParameter<AnalogFilterParams, AnalogFilterParams::FilterType>(
            "Analog Filter", "filter_type", &AnalogFilterParams::filter_type, filter_type_map);

    registerBasicParameter<AnalogFilterParams, double>(
            "Analog Filter", "cutoff_frequency", &AnalogFilterParams::cutoff_frequency);

    registerBasicParameter<AnalogFilterParams, double>(
            "Analog Filter", "cutoff_frequency2", &AnalogFilterParams::cutoff_frequency2);

    registerBasicParameter<AnalogFilterParams, int>(
            "Analog Filter", "order", &AnalogFilterParams::order);

    registerBasicParameter<AnalogFilterParams, double>(
            "Analog Filter", "ripple", &AnalogFilterParams::ripple);

    registerBasicParameter<AnalogFilterParams, bool>(
            "Analog Filter", "zero_phase", &AnalogFilterParams::zero_phase);

    registerBasicParameter<AnalogFilterParams, double>(
            "Analog Filter", "sampling_rate", &AnalogFilterParams::sampling_rate);

    // ================== Analog Hilbert Phase ==================

    registerBasicParameter<HilbertPhaseParams, double>(
            "Hilbert Phase", "low_frequency", &HilbertPhaseParams::lowFrequency);
    registerBasicParameter<HilbertPhaseParams, double>(
            "Hilbert Phase", "high_frequency", &HilbertPhaseParams::highFrequency);
    registerBasicParameter<HilbertPhaseParams, size_t>(
            "Hilbert Phase", "discontinuity_threshold", &HilbertPhaseParams::discontinuityThreshold);

    // ====================================================
    // ============== Digital Interval Series =============
    // ====================================================

    // ================= Digital Interval Group ===============

    registerBasicParameter<GroupParams, double>(
            "Group Intervals", "max_spacing", &GroupParams::maxSpacing);

    // ====================================================
    // ============== Line Series ==================
    // ====================================================

    // ================= Line Alignment ===============

    registerDataParameter<LineAlignmentParameters, MediaData>(
            "Line Alignment to Bright Features", "media_data", &LineAlignmentParameters::media_data);

    registerBasicParameter<LineAlignmentParameters, int>(
            "Line Alignment to Bright Features", "width", &LineAlignmentParameters::width);

    registerBasicParameter<LineAlignmentParameters, int>(
            "Line Alignment to Bright Features", "perpendicular_range", &LineAlignmentParameters::perpendicular_range);

    registerBasicParameter<LineAlignmentParameters, bool>(
            "Line Alignment to Bright Features", "use_processed_data", &LineAlignmentParameters::use_processed_data);

    std::unordered_map<std::string, FWHMApproach> fwhm_approach_map = {
            {"PEAK_WIDTH_HALF_MAX", FWHMApproach::PEAK_WIDTH_HALF_MAX},
            {"GAUSSIAN_FIT", FWHMApproach::GAUSSIAN_FIT},
            {"THRESHOLD_BASED", FWHMApproach::THRESHOLD_BASED}};
    registerEnumParameter<LineAlignmentParameters, FWHMApproach>(
            "Line Alignment to Bright Features", "approach", &LineAlignmentParameters::approach, fwhm_approach_map);

    std::unordered_map<std::string, LineAlignmentOutputMode> line_alignment_output_mode_map = {
            {"ALIGNED_VERTICES", LineAlignmentOutputMode::ALIGNED_VERTICES},
            {"FWHM_PROFILE_EXTENTS", LineAlignmentOutputMode::FWHM_PROFILE_EXTENTS}};
    registerEnumParameter<LineAlignmentParameters, LineAlignmentOutputMode>(
            "Line Alignment to Bright Features", "output_mode", &LineAlignmentParameters::output_mode, line_alignment_output_mode_map);


    // ==================== Line Angle ===============

    registerBasicParameter<LineAngleParameters, float>(
            "Calculate Line Angle", "position", &LineAngleParameters::position);

    std::unordered_map<std::string, AngleCalculationMethod> angle_calculation_method_map = {
        {"Direct Points", AngleCalculationMethod::DirectPoints},
        {"Polynomial Fit", AngleCalculationMethod::PolynomialFit}
    };
    
    registerEnumParameter<LineAngleParameters, AngleCalculationMethod>(
            "Calculate Line Angle", "method", &LineAngleParameters::method, angle_calculation_method_map);

    registerBasicParameter<LineAngleParameters, int>(
            "Calculate Line Angle", "polynomial_order", &LineAngleParameters::polynomial_order);

    registerBasicParameter<LineAngleParameters, float>(
            "Calculate Line Angle", "reference_x", &LineAngleParameters::reference_x);

    registerBasicParameter<LineAngleParameters, float>(
            "Calculate Line Angle", "reference_y", &LineAngleParameters::reference_y);

    // ==================== Line Min Point Dist ===============

    registerDataParameter<LineMinPointDistParameters, PointData>(
            "Calculate Line to Point Distance", "point_data", &LineMinPointDistParameters::point_data);
    
    // ==================== Line Resample ===============

    std::unordered_map<std::string, LineSimplificationAlgorithm> line_simplification_map = {
            {"Fixed Spacing", LineSimplificationAlgorithm::FixedSpacing},
            {"Douglas-Peucker", LineSimplificationAlgorithm::DouglasPeucker}};
    registerEnumParameter<LineResampleParameters, LineSimplificationAlgorithm>(
            "Resample Line", "algorithm", &LineResampleParameters::algorithm, line_simplification_map);

    registerBasicParameter<LineResampleParameters, float>(
            "Resample Line", "target_spacing", &LineResampleParameters::target_spacing);

    registerBasicParameter<LineResampleParameters, float>(
            "Resample Line", "epsilon", &LineResampleParameters::epsilon);

    std::cout << "Parameter factory initialized with default setters" << std::endl;

    // ====================================================
    // ============== Mask Series ==================
    // ====================================================

    // ==================== Mask Area ===============
    // No parameters needed for mask area calculation

    // ==================== Mask Centroid ===============
    // No parameters needed for mask centroid calculation

    // ==================== Mask Connected Component ===============
    registerBasicParameter<MaskConnectedComponentParameters, int>(
            "Remove Small Connected Components", "threshold", &MaskConnectedComponentParameters::threshold);

    // ==================== Mask Hole Filling ===============
    // No parameters needed for mask hole filling calculation

    // ==================== Mask Median Filter ===============
    registerBasicParameter<MaskMedianFilterParameters, int>(
            "Apply Median Filter", "window_size", &MaskMedianFilterParameters::window_size);

    // ==================== Mask Principal Axis ===============
    std::unordered_map<std::string, PrincipalAxisType> principal_axis_type_map = {
        {"Major", PrincipalAxisType::Major},
        {"Minor", PrincipalAxisType::Minor}
    };
    
    registerEnumParameter<MaskPrincipalAxisParameters, PrincipalAxisType>(
            "Calculate Mask Principal Axis", "axis_type", &MaskPrincipalAxisParameters::axis_type, principal_axis_type_map);


    // ==================== Mask Skeletonize ===============
    // No parameters needed for mask skeletonize calculation
}

1	#include "ParameterFactory.hpp"
2
3	#include "AnalogTimeSeries/AnalogFilter/analog_filter.hpp"
4	#include "AnalogTimeSeries/AnalogHilbertPhase/analog_hilbert_phase.hpp"
5	#include "AnalogTimeSeries/Analog_Event_Threshold/analog_event_threshold.hpp"
6	#include "AnalogTimeSeries/Analog_Interval_Threshold/analog_interval_threshold.hpp"
7	#include "DigitalIntervalSeries/Digital_Interval_Group/digital_interval_group.hpp"
8	#include "Lines/Line_Alignment/line_alignment.hpp"
9	#include "Lines/Line_Angle/line_angle.hpp"
10	#include "Lines/Line_Min_Point_Dist/line_min_point_dist.hpp"
11	#include "Lines/Line_Resample/line_resample.hpp"
12	#include "Masks/Mask_Median_Filter/mask_median_filter.hpp"
13	#include "Masks/Mask_Connected_Component/mask_connected_component.hpp"
14	#include "Masks/Mask_Principal_Axis/mask_principal_axis.hpp"
15
16	#include <iostream>
17
18	void ParameterFactory::registerParameterSetter(std::string const & transform_name,	2,072✔
19	std::string const & param_name,
20	ParameterSetter setter) {
21	setters_[transform_name][param_name] = std::move(setter);	2,072✔
22	}	2,072✔
23
24	bool ParameterFactory::setParameter(std::string const & transform_name,	126✔
25	TransformParametersBase * param_obj,
26	std::string const & param_name,
27	nlohmann::json const & json_value,
28	DataManager * data_manager) {
29	auto transform_it = setters_.find(transform_name);	126✔
30	if (transform_it == setters_.end()) {	126✔
31	std::cerr << "No parameter setters registered for transform: " << transform_name << std::endl;	×
UNCOV 32	return false;	×
33	}
34
35	auto param_it = transform_it->second.find(param_name);	126✔
36	if (param_it == transform_it->second.end()) {	126✔
37	std::cerr << "No setter registered for parameter '" << param_name
38	<< "' in transform '" << transform_name << "'" << std::endl;	×
UNCOV 39	return false;	×
40	}
41
42	return param_it->second(param_obj, json_value, data_manager);	126✔
43	}
44
45	ParameterFactory & ParameterFactory::getInstance() {	163✔
46	static ParameterFactory instance;	163✔
47	return instance;	163✔
48	}
49
50	void ParameterFactory::initializeDefaultSetters() {	56✔
51
52	// ==================================================
53	// =============== Analog Time Series ===============
54	// ==================================================
55
56	// =============== Threshold Event Detection ===============
57
58	registerBasicParameter<ThresholdParams, double>(	280✔
59	"Threshold Event Detection", "threshold_value", &ThresholdParams::thresholdValue);
60
61	std::unordered_map<std::string, ThresholdParams::ThresholdDirection> event_direction_map = {	56✔
62	{"Positive (Rising)", ThresholdParams::ThresholdDirection::POSITIVE},	56✔
63	{"Negative (Falling)", ThresholdParams::ThresholdDirection::NEGATIVE},	56✔
64	{"Absolute (Magnitude)", ThresholdParams::ThresholdDirection::ABSOLUTE}};	448✔
65
66	registerEnumParameter<ThresholdParams, ThresholdParams::ThresholdDirection>(	280✔
67	"Threshold Event Detection", "direction", &ThresholdParams::direction, event_direction_map);
68
69	registerBasicParameter<ThresholdParams, double>(	280✔
70	"Threshold Event Detection", "lockout_time", &ThresholdParams::lockoutTime);
71
72	// ============== Analog Interval Threshold ==============
73
74	std::unordered_map<std::string, IntervalThresholdParams::ThresholdDirection> threshold_direction_map = {	56✔
75	{"Positive (Rising)", IntervalThresholdParams::ThresholdDirection::POSITIVE},	56✔
76	{"Negative (Falling)", IntervalThresholdParams::ThresholdDirection::NEGATIVE},	56✔
77	{"Absolute (Magnitude)", IntervalThresholdParams::ThresholdDirection::ABSOLUTE}};	448✔
78
79	registerEnumParameter<IntervalThresholdParams, IntervalThresholdParams::ThresholdDirection>(	280✔
80	"Threshold Interval Detection", "direction", &IntervalThresholdParams::direction, threshold_direction_map);
81
82	registerBasicParameter<IntervalThresholdParams, double>(	280✔
83	"Threshold Interval Detection", "lockout_time", &IntervalThresholdParams::lockoutTime);
84
85	registerBasicParameter<IntervalThresholdParams, double>(	280✔
86	"Threshold Interval Detection", "min_duration", &IntervalThresholdParams::minDuration);
87
88	registerBasicParameter<IntervalThresholdParams, double>(	280✔
89	"Threshold Interval Detection", "threshold_value", &IntervalThresholdParams::thresholdValue);
90
91	std::unordered_map<std::string, IntervalThresholdParams::MissingDataMode> missing_data_mode_map = {	56✔
92	{"Zero", IntervalThresholdParams::MissingDataMode::TREAT_AS_ZERO},	56✔
93	{"Ignore", IntervalThresholdParams::MissingDataMode::IGNORE}};	392✔
94	registerEnumParameter<IntervalThresholdParams, IntervalThresholdParams::MissingDataMode>(	280✔
95	"Threshold Interval Detection", "missing_data_mode", &IntervalThresholdParams::missingDataMode, missing_data_mode_map);
96
97
98	// ================ Analog Filter ================
99
100	// Register Analog Filter parameters
101	std::unordered_map<std::string, AnalogFilterParams::FilterType> filter_type_map = {	56✔
102	{"lowpass", AnalogFilterParams::FilterType::Lowpass},	56✔
103	{"highpass", AnalogFilterParams::FilterType::Highpass},	56✔
104	{"bandpass", AnalogFilterParams::FilterType::Bandpass},	56✔
105	{"bandstop", AnalogFilterParams::FilterType::Bandstop}};	504✔
106	registerEnumParameter<AnalogFilterParams, AnalogFilterParams::FilterType>(	280✔
107	"Analog Filter", "filter_type", &AnalogFilterParams::filter_type, filter_type_map);
108
109	registerBasicParameter<AnalogFilterParams, double>(	280✔
110	"Analog Filter", "cutoff_frequency", &AnalogFilterParams::cutoff_frequency);
111
112	registerBasicParameter<AnalogFilterParams, double>(	280✔
113	"Analog Filter", "cutoff_frequency2", &AnalogFilterParams::cutoff_frequency2);
114
115	registerBasicParameter<AnalogFilterParams, int>(	280✔
116	"Analog Filter", "order", &AnalogFilterParams::order);
117
118	registerBasicParameter<AnalogFilterParams, double>(	280✔
119	"Analog Filter", "ripple", &AnalogFilterParams::ripple);
120
121	registerBasicParameter<AnalogFilterParams, bool>(	280✔
122	"Analog Filter", "zero_phase", &AnalogFilterParams::zero_phase);
123
124	registerBasicParameter<AnalogFilterParams, double>(	280✔
125	"Analog Filter", "sampling_rate", &AnalogFilterParams::sampling_rate);
126
127	// ================== Analog Hilbert Phase ==================
128
129	registerBasicParameter<HilbertPhaseParams, double>(	280✔
130	"Hilbert Phase", "low_frequency", &HilbertPhaseParams::lowFrequency);
131	registerBasicParameter<HilbertPhaseParams, double>(	280✔
132	"Hilbert Phase", "high_frequency", &HilbertPhaseParams::highFrequency);
133	registerBasicParameter<HilbertPhaseParams, size_t>(	280✔
134	"Hilbert Phase", "discontinuity_threshold", &HilbertPhaseParams::discontinuityThreshold);
135
136	// ====================================================
137	// ============== Digital Interval Series =============
138	// ====================================================
139
140	// ================= Digital Interval Group ===============
141
142	registerBasicParameter<GroupParams, double>(	280✔
143	"Group Intervals", "max_spacing", &GroupParams::maxSpacing);
144
145	// ====================================================
146	// ============== Line Series ==================
147	// ====================================================
148
149	// ================= Line Alignment ===============
150
151	registerDataParameter<LineAlignmentParameters, MediaData>(	280✔
152	"Line Alignment to Bright Features", "media_data", &LineAlignmentParameters::media_data);
153
154	registerBasicParameter<LineAlignmentParameters, int>(	280✔
155	"Line Alignment to Bright Features", "width", &LineAlignmentParameters::width);
156
157	registerBasicParameter<LineAlignmentParameters, int>(	280✔
158	"Line Alignment to Bright Features", "perpendicular_range", &LineAlignmentParameters::perpendicular_range);
159
160	registerBasicParameter<LineAlignmentParameters, bool>(	280✔
161	"Line Alignment to Bright Features", "use_processed_data", &LineAlignmentParameters::use_processed_data);
162
163	std::unordered_map<std::string, FWHMApproach> fwhm_approach_map = {	56✔
164	{"PEAK_WIDTH_HALF_MAX", FWHMApproach::PEAK_WIDTH_HALF_MAX},	56✔
165	{"GAUSSIAN_FIT", FWHMApproach::GAUSSIAN_FIT},	56✔
166	{"THRESHOLD_BASED", FWHMApproach::THRESHOLD_BASED}};	448✔
167	registerEnumParameter<LineAlignmentParameters, FWHMApproach>(	280✔
168	"Line Alignment to Bright Features", "approach", &LineAlignmentParameters::approach, fwhm_approach_map);
169
170	std::unordered_map<std::string, LineAlignmentOutputMode> line_alignment_output_mode_map = {	56✔
171	{"ALIGNED_VERTICES", LineAlignmentOutputMode::ALIGNED_VERTICES},	56✔
172	{"FWHM_PROFILE_EXTENTS", LineAlignmentOutputMode::FWHM_PROFILE_EXTENTS}};	392✔
173	registerEnumParameter<LineAlignmentParameters, LineAlignmentOutputMode>(	280✔
174	"Line Alignment to Bright Features", "output_mode", &LineAlignmentParameters::output_mode, line_alignment_output_mode_map);
175
176
177	// ==================== Line Angle ===============
178
179	registerBasicParameter<LineAngleParameters, float>(	280✔
180	"Calculate Line Angle", "position", &LineAngleParameters::position);
181
182	std::unordered_map<std::string, AngleCalculationMethod> angle_calculation_method_map = {	56✔
183	{"Direct Points", AngleCalculationMethod::DirectPoints},	56✔
184	{"Polynomial Fit", AngleCalculationMethod::PolynomialFit}	56✔
185	};	392✔
186
187	registerEnumParameter<LineAngleParameters, AngleCalculationMethod>(	280✔
188	"Calculate Line Angle", "method", &LineAngleParameters::method, angle_calculation_method_map);
189
190	registerBasicParameter<LineAngleParameters, int>(	280✔
191	"Calculate Line Angle", "polynomial_order", &LineAngleParameters::polynomial_order);
192
193	registerBasicParameter<LineAngleParameters, float>(	280✔
194	"Calculate Line Angle", "reference_x", &LineAngleParameters::reference_x);
195
196	registerBasicParameter<LineAngleParameters, float>(	280✔
197	"Calculate Line Angle", "reference_y", &LineAngleParameters::reference_y);
198
199	// ==================== Line Min Point Dist ===============
200
201	registerDataParameter<LineMinPointDistParameters, PointData>(	280✔
202	"Calculate Line to Point Distance", "point_data", &LineMinPointDistParameters::point_data);
203
204	// ==================== Line Resample ===============
205
206	std::unordered_map<std::string, LineSimplificationAlgorithm> line_simplification_map = {	56✔
207	{"Fixed Spacing", LineSimplificationAlgorithm::FixedSpacing},	56✔
208	{"Douglas-Peucker", LineSimplificationAlgorithm::DouglasPeucker}};	392✔
209	registerEnumParameter<LineResampleParameters, LineSimplificationAlgorithm>(	280✔
210	"Resample Line", "algorithm", &LineResampleParameters::algorithm, line_simplification_map);
211
212	registerBasicParameter<LineResampleParameters, float>(	280✔
213	"Resample Line", "target_spacing", &LineResampleParameters::target_spacing);
214
215	registerBasicParameter<LineResampleParameters, float>(	280✔
216	"Resample Line", "epsilon", &LineResampleParameters::epsilon);
217
218	std::cout << "Parameter factory initialized with default setters" << std::endl;	56✔
219
220	// ====================================================
221	// ============== Mask Series ==================
222	// ====================================================
223
224	// ==================== Mask Area ===============
225	// No parameters needed for mask area calculation
226
227	// ==================== Mask Centroid ===============
228	// No parameters needed for mask centroid calculation
229
230	// ==================== Mask Connected Component ===============
231	registerBasicParameter<MaskConnectedComponentParameters, int>(	280✔
232	"Remove Small Connected Components", "threshold", &MaskConnectedComponentParameters::threshold);
233
234	// ==================== Mask Hole Filling ===============
235	// No parameters needed for mask hole filling calculation
236
237	// ==================== Mask Median Filter ===============
238	registerBasicParameter<MaskMedianFilterParameters, int>(	280✔
239	"Apply Median Filter", "window_size", &MaskMedianFilterParameters::window_size);
240
241	// ==================== Mask Principal Axis ===============
242	std::unordered_map<std::string, PrincipalAxisType> principal_axis_type_map = {	56✔
243	{"Major", PrincipalAxisType::Major},	56✔
244	{"Minor", PrincipalAxisType::Minor}	56✔
245	};	392✔
246
247	registerEnumParameter<MaskPrincipalAxisParameters, PrincipalAxisType>(	280✔
248	"Calculate Mask Principal Axis", "axis_type", &MaskPrincipalAxisParameters::axis_type, principal_axis_type_map);
249
250
251	// ==================== Mask Skeletonize ===============
252	// No parameters needed for mask skeletonize calculation
253	}	616✔

paulmthompson / WhiskerToolbox / 17346268452

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