17347485457

Committed 30 Aug 2025 07:03PM UTC coverage: 71.575% (+1.5%) from 70.094%

Build # 17347485457

Build Type

push

github

Committed by

paulmthompson

Commit Message

line subsegment testing added

Run Details

389 of 392 new or added lines in 2 files covered. (99.23%)

4 existing lines in 1 file now uncovered.

31379 of 43841 relevant lines covered (71.57%)

1406.64 hits per line

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

97.01

/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_Curvature/line_curvature.hpp"
#include "Lines/Line_Min_Point_Dist/line_min_point_dist.hpp"
#include "Lines/Line_Point_Extraction/line_point_extraction.hpp"
#include "Lines/Line_Resample/line_resample.hpp"
#include "Lines/Line_Subsegment/line_subsegment.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 Curvature ===============

    registerBasicParameter<LineCurvatureParameters, float>(
            "Calculate Line Curvature", "position", &LineCurvatureParameters::position);
    
    std::unordered_map<std::string, CurvatureCalculationMethod> curvature_calculation_method_map = {
        {"PolynomialFit", CurvatureCalculationMethod::PolynomialFit}// Only method for now
    };
    registerEnumParameter<LineCurvatureParameters, CurvatureCalculationMethod>(
            "Calculate Line Curvature", "method", &LineCurvatureParameters::method, curvature_calculation_method_map);
    
    registerBasicParameter<LineCurvatureParameters, int>(
            "Calculate Line Curvature", "polynomial_order", &LineCurvatureParameters::polynomial_order);
    
    registerBasicParameter<LineCurvatureParameters, float>(
            "Calculate Line Curvature", "fitting_window_percentage", &LineCurvatureParameters::fitting_window_percentage);

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

    registerDataParameter<LineMinPointDistParameters, PointData>(
            "Calculate Line to Point Distance", "point_data", &LineMinPointDistParameters::point_data);
    
    // ==================== Line Point Extraction ===============
    
    std::unordered_map<std::string, PointExtractionMethod> point_extraction_method_map = {
        {"Direct", PointExtractionMethod::Direct},          // Direct point selection based on indices
        {"Parametric", PointExtractionMethod::Parametric}       // Use parametric polynomial interpolation
    };
    registerEnumParameter<LinePointExtractionParameters, PointExtractionMethod>(
            "Extract Point from Line", "method", &LinePointExtractionParameters::method, point_extraction_method_map);
    
    registerBasicParameter<LinePointExtractionParameters, float>(
            "Extract Point from Line", "position", &LinePointExtractionParameters::position);

    registerBasicParameter<LinePointExtractionParameters, int>(
            "Extract Point from Line", "polynomial_order", &LinePointExtractionParameters::polynomial_order);
    
    registerBasicParameter<LinePointExtractionParameters, bool>(
            "Extract Point from Line", "use_interpolation", &LinePointExtractionParameters::use_interpolation);
    
    // ==================== 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);

    // ==================== Line Subsegment ===============

    std::unordered_map<std::string, SubsegmentExtractionMethod> subsegment_extraction_method_map = {
        {"Direct", SubsegmentExtractionMethod::Direct},          // Direct point extraction based on indices
        {"Parametric", SubsegmentExtractionMethod::Parametric}       // Use parametric polynomial interpolation
    };
    registerEnumParameter<LineSubsegmentParameters, SubsegmentExtractionMethod>(
            "Extract Line Subsegment", "method", &LineSubsegmentParameters::method, subsegment_extraction_method_map);
    
    registerBasicParameter<LineSubsegmentParameters, float>(
            "Extract Line Subsegment", "start_position", &LineSubsegmentParameters::start_position);
    
    registerBasicParameter<LineSubsegmentParameters, float>(
            "Extract Line Subsegment", "end_position", &LineSubsegmentParameters::end_position);
    
    registerBasicParameter<LineSubsegmentParameters, int>(
            "Extract Line Subsegment", "polynomial_order", &LineSubsegmentParameters::polynomial_order);
    
    registerBasicParameter<LineSubsegmentParameters, int>(
            "Extract Line Subsegment", "output_points", &LineSubsegmentParameters::output_points);
    
    registerBasicParameter<LineSubsegmentParameters, bool>(
            "Extract Line Subsegment", "preserve_original_spacing", &LineSubsegmentParameters::preserve_original_spacing);

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

paulmthompson / WhiskerToolbox / 17347485457

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