paulmthompson / WhiskerToolbox / 18914877332

#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_Peak/analog_interval_peak.hpp"

#include "AnalogTimeSeries/Analog_Interval_Threshold/analog_interval_threshold.hpp"

#include "AnalogTimeSeries/Analog_Scaling/analog_scaling.hpp"

#include "DigitalIntervalSeries/Digital_Interval_Group/digital_interval_group.hpp"

#include "DigitalIntervalSeries/Digital_Interval_Boolean/digital_interval_boolean.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_Kalman_Grouping/line_kalman_grouping.hpp"

#include "Lines/Line_Min_Point_Dist/line_min_point_dist.hpp"

#include "Lines/Line_Point_Extraction/line_point_extraction.hpp"

#include "Lines/Line_Proximity_Grouping/line_proximity_grouping.hpp"

#include "Lines/Line_Resample/line_resample.hpp"

#include "Lines/Line_Subsegment/line_subsegment.hpp"

#include "Masks/Mask_Connected_Component/mask_connected_component.hpp"

#include "Masks/Mask_Median_Filter/mask_median_filter.hpp"

#include "Masks/Mask_Principal_Axis/mask_principal_axis.hpp"

#include "Masks/Mask_To_Line/mask_to_line.hpp"

#include "Media/whisker_tracing.hpp"

#include <iostream>

                                               std::string const & param_name,    // NOLINT(bugprone-easily-swappable-parameters)

                                               ParameterSetter setter) {

                                    TransformParametersBase * param_obj,

                                    std::string const & param_name,

                                    nlohmann::json const & json_value,

                                    DataManager * data_manager) {

    }

        std::cerr << "No setter registered for parameter '" << param_name

    }

}

}

    // ==================================================

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

    // ==================================================

    // =============== Filter ===============

    // Register filter_specification as a special nested JSON object

            try {

                // Parse the filter specification from JSON

        });

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

            "Threshold Event Detection", "threshold_value", &ThresholdParams::thresholdValue);

            "Threshold Event Detection", "direction", &ThresholdParams::direction, event_direction_map);

            "Threshold Event Detection", "lockout_time", &ThresholdParams::lockoutTime);

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

            "Threshold Interval Detection", "direction", &IntervalThresholdParams::direction, threshold_direction_map);

            "Threshold Interval Detection", "lockout_time", &IntervalThresholdParams::lockoutTime);

            "Threshold Interval Detection", "min_duration", &IntervalThresholdParams::minDuration);

            "Threshold Interval Detection", "threshold_value", &IntervalThresholdParams::thresholdValue);

            "Threshold Interval Detection", "missing_data_mode", &IntervalThresholdParams::missingDataMode, missing_data_mode_map);

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

            "Hilbert Phase", "discontinuity_threshold", &HilbertPhaseParams::discontinuityThreshold);

            "Hilbert Phase", "output_type", &HilbertPhaseParams::outputType, hilbert_output_type_map);

    // Windowed processing parameters for long signals

            "Hilbert Phase", "max_chunk_size", &HilbertPhaseParams::maxChunkSize);

            "Hilbert Phase", "overlap_fraction", &HilbertPhaseParams::overlapFraction);

            "Hilbert Phase", "use_windowing", &HilbertPhaseParams::useWindowing);

    // Bandpass filtering parameters

            "Hilbert Phase", "apply_bandpass_filter", &HilbertPhaseParams::applyBandpassFilter);

            "Hilbert Phase", "filter_low_freq", &HilbertPhaseParams::filterLowFreq);

            "Hilbert Phase", "filter_high_freq", &HilbertPhaseParams::filterHighFreq);

            "Hilbert Phase", "filter_order", &HilbertPhaseParams::filterOrder);

            "Hilbert Phase", "sampling_rate", &HilbertPhaseParams::samplingRate);

    // ================== Analog Scaling ==================

            "Scale and Normalize", "method", &AnalogScalingParams::method, scaling_method_map);

            "Scale and Normalize", "gain_factor", &AnalogScalingParams::gain_factor);

            "Scale and Normalize", "std_dev_target", &AnalogScalingParams::std_dev_target);

            "Scale and Normalize", "min_target", &AnalogScalingParams::min_target);

            "Scale and Normalize", "max_target", &AnalogScalingParams::max_target);

            "Scale and Normalize", "quantile_low", &AnalogScalingParams::quantile_low);

            "Scale and Normalize", "quantile_high", &AnalogScalingParams::quantile_high);

    // ================== Analog Interval Peak ==================

            "Interval Peak Detection", "peak_type", &IntervalPeakParams::peak_type, peak_type_map);

            "Interval Peak Detection", "search_mode", &IntervalPeakParams::search_mode, search_mode_map);

    // Register interval_series as a special nested object

           "Interval Peak Detection", "interval_series", &IntervalPeakParams::interval_series);

    // ====================================================

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

    // ====================================================

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

            "Group Intervals", "max_spacing", &GroupParams::maxSpacing);

    // ================= Digital Interval Boolean ===============

            "Boolean Operation", "operation", &BooleanParams::operation, boolean_operation_map);

            "Boolean Operation", "other_series", &BooleanParams::other_series);

    // ====================================================

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

    // ====================================================

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

            "Line Alignment to Bright Features", "media_data", &LineAlignmentParameters::media_data);

            "Line Alignment to Bright Features", "width", &LineAlignmentParameters::width);

            "Line Alignment to Bright Features", "perpendicular_range", &LineAlignmentParameters::perpendicular_range);

            "Line Alignment to Bright Features", "use_processed_data", &LineAlignmentParameters::use_processed_data);

            "Line Alignment to Bright Features", "approach", &LineAlignmentParameters::approach, fwhm_approach_map);

            "Line Alignment to Bright Features", "output_mode", &LineAlignmentParameters::output_mode, line_alignment_output_mode_map);

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

            "Calculate Line Angle", "position", &LineAngleParameters::position);

            "Calculate Line Angle", "method", &LineAngleParameters::method, angle_calculation_method_map);

            "Calculate Line Angle", "polynomial_order", &LineAngleParameters::polynomial_order);

            "Calculate Line Angle", "reference_x", &LineAngleParameters::reference_x);

            "Calculate Line Angle", "reference_y", &LineAngleParameters::reference_y);

    // ==================== Line Clip ===============

            "Clip Line by Reference Line", "clip_side", &LineClipParameters::clip_side, clip_side_map);

            "Clip Line by Reference Line", "reference_line_data", &LineClipParameters::reference_line_data);

            "Clip Line by Reference Line", "reference_frame", &LineClipParameters::reference_frame);

    // ==================== Line Curvature ===============

            "Calculate Line Curvature", "position", &LineCurvatureParameters::position);

            "Calculate Line Curvature", "method", &LineCurvatureParameters::method, curvature_calculation_method_map);

            "Calculate Line Curvature", "polynomial_order", &LineCurvatureParameters::polynomial_order);

            "Calculate Line Curvature", "fitting_window_percentage", &LineCurvatureParameters::fitting_window_percentage);

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

            "Calculate Line to Point Distance", "point_data", &LineMinPointDistParameters::point_data);

    // ==================== Line Point Extraction ===============

            "Extract Point from Line", "method", &LinePointExtractionParameters::method, point_extraction_method_map);

            "Extract Point from Line", "position", &LinePointExtractionParameters::position);

            "Extract Point from Line", "polynomial_order", &LinePointExtractionParameters::polynomial_order);

            "Extract Point from Line", "use_interpolation", &LinePointExtractionParameters::use_interpolation);

    // ==================== Line Resample ===============

            "Resample Line", "algorithm", &LineResampleParameters::algorithm, line_simplification_map);

            "Resample Line", "target_spacing", &LineResampleParameters::target_spacing);

            "Resample Line", "epsilon", &LineResampleParameters::epsilon);

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

            "Extract Line Subsegment", "method", &LineSubsegmentParameters::method, subsegment_extraction_method_map);

            "Extract Line Subsegment", "start_position", &LineSubsegmentParameters::start_position);

            "Extract Line Subsegment", "end_position", &LineSubsegmentParameters::end_position);

            "Extract Line Subsegment", "polynomial_order", &LineSubsegmentParameters::polynomial_order);

            "Extract Line Subsegment", "output_points", &LineSubsegmentParameters::output_points);

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

            "Remove Small Connected Components", "threshold", &MaskConnectedComponentParameters::threshold);

    // ==================== Mask Hole Filling ===============

    // No parameters needed for mask hole filling calculation

    // ==================== Mask Median Filter ===============

            "Apply Median Filter", "window_size", &MaskMedianFilterParameters::window_size);

    // ==================== Mask Principal Axis ===============

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

            "Convert Mask To Line", "method", &MaskToLineParameters::method, line_point_selection_method_map);

            "Convert Mask To Line", "reference_x", &MaskToLineParameters::reference_x);

            "Convert Mask To Line", "reference_y", &MaskToLineParameters::reference_y);

            "Convert Mask To Line", "polynomial_order", &MaskToLineParameters::polynomial_order);

            "Convert Mask To Line", "error_threshold", &MaskToLineParameters::error_threshold);

            "Convert Mask To Line", "remove_outliers", &MaskToLineParameters::remove_outliers);

            "Convert Mask To Line", "input_point_subsample_factor", &MaskToLineParameters::input_point_subsample_factor);

            "Convert Mask To Line", "should_smooth_line", &MaskToLineParameters::should_smooth_line);

            "Convert Mask To Line", "output_resolution", &MaskToLineParameters::output_resolution);

    // ====================================================

    // ============== Media Series ==================

    // ====================================================

    // ==================== Whisker Tracing ===============

            "Whisker Tracing", "use_processed_data", &WhiskerTracingParameters::use_processed_data);

            "Whisker Tracing", "clip_length", &WhiskerTracingParameters::clip_length);

            "Whisker Tracing", "whisker_length_threshold", &WhiskerTracingParameters::whisker_length_threshold);

            "Whisker Tracing", "batch_size", &WhiskerTracingParameters::batch_size);

            "Whisker Tracing", "use_parallel_processing", &WhiskerTracingParameters::use_parallel_processing);

            "Whisker Tracing", "use_mask_data", &WhiskerTracingParameters::use_mask_data);

            "Whisker Tracing", "mask_data", &WhiskerTracingParameters::mask_data);

    // ====================================================

    // ============== Grouping Operations =================

    // ====================================================

    // ==================== Line Proximity Grouping ===============

            "Group Lines by Proximity", "distance_threshold", &LineProximityGroupingParameters::distance_threshold);

            "Group Lines by Proximity", "position_along_line", &LineProximityGroupingParameters::position_along_line);

            "Group Lines by Proximity", "create_new_group_for_outliers", &LineProximityGroupingParameters::create_new_group_for_outliers);

            "Group Lines by Proximity", "new_group_name", &LineProximityGroupingParameters::new_group_name);

    // ==================== Line Kalman Grouping ===============

            "Group Lines using Kalman Filtering", "dt", &LineKalmanGroupingParameters::dt);

            "Group Lines using Kalman Filtering", "process_noise_position", &LineKalmanGroupingParameters::process_noise_position);

            "Group Lines using Kalman Filtering", "process_noise_velocity", &LineKalmanGroupingParameters::process_noise_velocity);

            "Group Lines using Kalman Filtering", "static_feature_process_noise_scale", &LineKalmanGroupingParameters::static_feature_process_noise_scale);

            "Group Lines using Kalman Filtering", "measurement_noise_position", &LineKalmanGroupingParameters::measurement_noise_position);

            "Group Lines using Kalman Filtering", "measurement_noise_length", &LineKalmanGroupingParameters::measurement_noise_length);

            "Group Lines using Kalman Filtering", "auto_estimate_static_noise", &LineKalmanGroupingParameters::auto_estimate_static_noise);

            "Group Lines using Kalman Filtering", "auto_estimate_measurement_noise", &LineKalmanGroupingParameters::auto_estimate_measurement_noise);

            "Group Lines using Kalman Filtering", "static_noise_percentile", &LineKalmanGroupingParameters::static_noise_percentile);

            "Group Lines using Kalman Filtering", "initial_position_uncertainty", &LineKalmanGroupingParameters::initial_position_uncertainty);

            "Group Lines using Kalman Filtering", "initial_velocity_uncertainty", &LineKalmanGroupingParameters::initial_velocity_uncertainty);

            "Group Lines using Kalman Filtering", "verbose_output", &LineKalmanGroupingParameters::verbose_output);

    // New: cheap linkage threshold exposed to UI

            "Group Lines using Kalman Filtering", "cheap_assignment_threshold", &LineKalmanGroupingParameters::cheap_assignment_threshold);

    // New: putative output control

            "Group Lines using Kalman Filtering", "write_to_putative_groups", &LineKalmanGroupingParameters::write_to_putative_groups);

            "Group Lines using Kalman Filtering", "putative_group_prefix", &LineKalmanGroupingParameters::putative_group_prefix);