17347044715

Committed 30 Aug 2025 06:08PM UTC coverage: 70.094% (+1.6%) from 68.446%

Build # 17347044715

Build Type

push

github

Committed by

paulmthompson

Commit Message

line clip testing added

Run Details

370 of 373 new or added lines in 3 files covered. (99.2%)

2 existing lines in 1 file now uncovered.

29972 of 42760 relevant lines covered (70.09%)

1439.55 hits per line

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

96.36

/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_Clip/line_clip.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 "Masks/Mask_To_Line/mask_to_line.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 Clip ===============

    std::unordered_map<std::string, ClipSide> clip_side_map = {
        {"KeepBase", ClipSide::KeepBase},    // Keep the portion from line start to intersection
        {"KeepDistal", ClipSide::KeepDistal}   // Keep the portion from intersection to line end
    };
    registerEnumParameter<LineClipParameters, ClipSide>(
            "Clip Line by Reference Line", "clip_side", &LineClipParameters::clip_side, clip_side_map);
    
    registerDataParameter<LineClipParameters, LineData>(
            "Clip Line by Reference Line", "reference_line_data", &LineClipParameters::reference_line_data);
    
    registerBasicParameter<LineClipParameters, int>(
            "Clip Line by Reference Line", "reference_frame", &LineClipParameters::reference_frame);

    // ==================== 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

    // ==================== Mask To Line ===============

    std::unordered_map<std::string, LinePointSelectionMethod> line_point_selection_method_map = {
        {"NearestToReference", LinePointSelectionMethod::NearestToReference},
        {"Skeletonize", LinePointSelectionMethod::Skeletonize}
    };
    registerEnumParameter<MaskToLineParameters, LinePointSelectionMethod>(
            "Convert Mask To Line", "method", &MaskToLineParameters::method, line_point_selection_method_map);
    
    registerBasicParameter<MaskToLineParameters, float>(
            "Convert Mask To Line", "reference_x", &MaskToLineParameters::reference_x);
    
    registerBasicParameter<MaskToLineParameters, float>(
            "Convert Mask To Line", "reference_y", &MaskToLineParameters::reference_y);
    
    registerBasicParameter<MaskToLineParameters, int>(
            "Convert Mask To Line", "polynomial_order", &MaskToLineParameters::polynomial_order);
    
    registerBasicParameter<MaskToLineParameters, float>(
            "Convert Mask To Line", "error_threshold", &MaskToLineParameters::error_threshold);
    
    registerBasicParameter<MaskToLineParameters, bool>(
            "Convert Mask To Line", "remove_outliers", &MaskToLineParameters::remove_outliers);
    
    registerBasicParameter<MaskToLineParameters, int>(
            "Convert Mask To Line", "input_point_subsample_factor", &MaskToLineParameters::input_point_subsample_factor);
    
    registerBasicParameter<MaskToLineParameters, bool>(
            "Convert Mask To Line", "should_smooth_line", &MaskToLineParameters::should_smooth_line);
    
    registerBasicParameter<MaskToLineParameters, float>(
            "Convert Mask To Line", "output_resolution", &MaskToLineParameters::output_resolution);
    
}

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

paulmthompson / WhiskerToolbox / 17347044715

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