16083587281

Committed 05 Jul 2025 02:22AM UTC coverage: 74.196% (-1.0%) from 75.191%

Build # 16083587281

Build Type

push

github

Committed by

paulmthompson

Commit Message

remove legacy filter stuff

Run Details

13106 of 17664 relevant lines covered (74.2%)

1065.58 hits per line

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

83.05

/src/WhiskerToolbox/DataManager/transforms/AnalogTimeSeries/analog_filter.cpp

#include "analog_filter.hpp"
#include "AnalogTimeSeries/Analog_Time_Series.hpp"
#include "utils/filter/FilterFactory.hpp"

#include <stdexcept>

std::shared_ptr<AnalogTimeSeries> filter_analog(
        AnalogTimeSeries const * analog_time_series,
        AnalogFilterParams const & filterParams) {
    return filter_analog(analog_time_series, filterParams, [](int) {});
}

std::shared_ptr<AnalogTimeSeries> filter_analog(
        AnalogTimeSeries const * analog_time_series,
        AnalogFilterParams const & filterParams,
        ProgressCallback progressCallback) {
    if (!analog_time_series) {
        throw std::invalid_argument("Input analog time series is null");
    }

    // Validate filter parameters
    if (!filterParams.isValid()) {
        throw std::invalid_argument("Invalid filter parameters");
    }

    // Report initial progress
    progressCallback(0);

    // Handle different parameter types
    if (filterParams.filter_instance) {
        // Use pre-created filter instance
        auto result = filterWithInstance(analog_time_series, filterParams.filter_instance);
        progressCallback(100);
        return result;
    } else if (filterParams.filter_factory) {
        // Create filter from factory
        auto filter = filterParams.filter_factory();
        auto result = filterWithInstance(analog_time_series, std::move(filter));
        progressCallback(100);
        return result;
    } else {
        throw std::invalid_argument("No valid filter configuration provided");
    }
}

// Helper function to filter with a direct filter instance
std::shared_ptr<AnalogTimeSeries> filterWithInstance(
        AnalogTimeSeries const * analog_time_series,
        std::shared_ptr<IFilter> filter) {
    if (!analog_time_series || !filter) {
        throw std::invalid_argument("Input analog time series or filter is null");
    }

    // Get all data from the time series
    auto & data_span = analog_time_series->getAnalogTimeSeries();
    auto time_series = analog_time_series->getTimeSeries();

    if (data_span.empty()) {
        throw std::invalid_argument("No data found in time series");
    }

    // Convert to mutable vector for processing
    std::vector<float> filtered_data(data_span.begin(), data_span.end());
    std::vector<TimeFrameIndex> filtered_times(time_series.begin(), time_series.end());

    // Apply filter
    std::span<float> data_span_mutable(filtered_data);
    filter->process(data_span_mutable);

    // Create new AnalogTimeSeries with filtered data
    return std::make_shared<AnalogTimeSeries>(
        std::move(filtered_data),
        std::move(filtered_times));
}

// Helper function to filter with a unique_ptr filter instance
std::shared_ptr<AnalogTimeSeries> filterWithInstance(
        AnalogTimeSeries const * analog_time_series,
        std::unique_ptr<IFilter> filter) {
    return filterWithInstance(analog_time_series, std::shared_ptr<IFilter>(std::move(filter)));
}

std::string AnalogFilterOperation::getName() const {
    return "Filter";
}

std::type_index AnalogFilterOperation::getTargetInputTypeIndex() const {
    return typeid(std::shared_ptr<AnalogTimeSeries>);
}

std::unique_ptr<TransformParametersBase> AnalogFilterOperation::getDefaultParameters() const {
    // Create default parameters with 4th order Butterworth lowpass filter
    auto params = std::make_unique<AnalogFilterParams>();
    // The default constructor automatically creates the default filter
    return params;
}

bool AnalogFilterOperation::canApply(DataTypeVariant const & dataVariant) const {
    return std::holds_alternative<std::shared_ptr<AnalogTimeSeries>>(dataVariant);
}

DataTypeVariant AnalogFilterOperation::execute(
        DataTypeVariant const & dataVariant,
        TransformParametersBase const * params) {
    return execute(dataVariant, params, [](int) {});
}

DataTypeVariant AnalogFilterOperation::execute(
        DataTypeVariant const & dataVariant,
        TransformParametersBase const * params,
        ProgressCallback progressCallback) {
    if (!params) {
        throw std::invalid_argument("Filter parameters are null");
    }

    auto const * filterParams = dynamic_cast<AnalogFilterParams const *>(params);
    if (!filterParams) {
        throw std::invalid_argument("Invalid parameter type for filter operation");
    }

    auto const * analog_time_series = std::get_if<std::shared_ptr<AnalogTimeSeries>>(&dataVariant);
    if (!analog_time_series || !*analog_time_series) {
        throw std::invalid_argument("Invalid input data type or null pointer");
    }

    auto filtered_data = filter_analog(analog_time_series->get(), *filterParams, progressCallback);
    return DataTypeVariant(filtered_data);
} 

1	#include "analog_filter.hpp"
2	#include "AnalogTimeSeries/Analog_Time_Series.hpp"
3	#include "utils/filter/FilterFactory.hpp"
4
5	#include <stdexcept>
6
7	std::shared_ptr<AnalogTimeSeries> filter_analog(	12✔
8	AnalogTimeSeries const * analog_time_series,
9	AnalogFilterParams const & filterParams) {
10	return filter_analog(analog_time_series, filterParams, [](int) {});	12✔
11	}
12
13	std::shared_ptr<AnalogTimeSeries> filter_analog(	13✔
14	AnalogTimeSeries const * analog_time_series,
15	AnalogFilterParams const & filterParams,
16	ProgressCallback progressCallback) {
17	if (!analog_time_series) {	13✔
18	throw std::invalid_argument("Input analog time series is null");	×
19	}
20
21	// Validate filter parameters
22	if (!filterParams.isValid()) {	13✔
23	throw std::invalid_argument("Invalid filter parameters");	×
24	}
25
26	// Report initial progress
27	progressCallback(0);	13✔
28
29	// Handle different parameter types
30	if (filterParams.filter_instance) {	13✔
31	// Use pre-created filter instance
32	auto result = filterWithInstance(analog_time_series, filterParams.filter_instance);	10✔
33	progressCallback(100);	10✔
34	return result;	10✔
35	} else if (filterParams.filter_factory) {	13✔
36	// Create filter from factory
37	auto filter = filterParams.filter_factory();	3✔
38	auto result = filterWithInstance(analog_time_series, std::move(filter));	3✔
39	progressCallback(100);	3✔
40	return result;	3✔
41	} else {	3✔
42	throw std::invalid_argument("No valid filter configuration provided");	×
43	}
44	}
45
46	// Helper function to filter with a direct filter instance
47	std::shared_ptr<AnalogTimeSeries> filterWithInstance(	13✔
48	AnalogTimeSeries const * analog_time_series,
49	std::shared_ptr<IFilter> filter) {
50	if (!analog_time_series \|\| !filter) {	13✔
51	throw std::invalid_argument("Input analog time series or filter is null");	×
52	}
53
54	// Get all data from the time series
55	auto & data_span = analog_time_series->getAnalogTimeSeries();	13✔
56	auto time_series = analog_time_series->getTimeSeries();	13✔
57
58	if (data_span.empty()) {	13✔
59	throw std::invalid_argument("No data found in time series");	×
60	}
61
62	// Convert to mutable vector for processing
63	std::vector<float> filtered_data(data_span.begin(), data_span.end());	39✔
64	std::vector<TimeFrameIndex> filtered_times(time_series.begin(), time_series.end());	39✔
65
66	// Apply filter
67	std::span<float> data_span_mutable(filtered_data);	13✔
68	filter->process(data_span_mutable);	13✔
69
70	// Create new AnalogTimeSeries with filtered data
71	return std::make_shared<AnalogTimeSeries>(
72	std::move(filtered_data),	13✔
73	std::move(filtered_times));	39✔
74	}	13✔
75
76	// Helper function to filter with a unique_ptr filter instance
77	std::shared_ptr<AnalogTimeSeries> filterWithInstance(	3✔
78	AnalogTimeSeries const * analog_time_series,
79	std::unique_ptr<IFilter> filter) {
80	return filterWithInstance(analog_time_series, std::shared_ptr<IFilter>(std::move(filter)));	6✔
81	}
82
83	std::string AnalogFilterOperation::getName() const {	1✔
84	return "Filter";	3✔
85	}
86
87	std::type_index AnalogFilterOperation::getTargetInputTypeIndex() const {	1✔
88	return typeid(std::shared_ptr<AnalogTimeSeries>);	1✔
89	}
90
91	std::unique_ptr<TransformParametersBase> AnalogFilterOperation::getDefaultParameters() const {	1✔
92	// Create default parameters with 4th order Butterworth lowpass filter
93	auto params = std::make_unique<AnalogFilterParams>();	1✔
94	// The default constructor automatically creates the default filter
95	return params;	2✔
96	}	1✔
97
98	bool AnalogFilterOperation::canApply(DataTypeVariant const & dataVariant) const {	1✔
99	return std::holds_alternative<std::shared_ptr<AnalogTimeSeries>>(dataVariant);	1✔
100	}
101
102	DataTypeVariant AnalogFilterOperation::execute(	×
103	DataTypeVariant const & dataVariant,
104	TransformParametersBase const * params) {
105	return execute(dataVariant, params, [](int) {});	×
106	}
107
108	DataTypeVariant AnalogFilterOperation::execute(	1✔
109	DataTypeVariant const & dataVariant,
110	TransformParametersBase const * params,
111	ProgressCallback progressCallback) {
112	if (!params) {	1✔
113	throw std::invalid_argument("Filter parameters are null");	×
114	}
115
116	auto const * filterParams = dynamic_cast<AnalogFilterParams const *>(params);	1✔
117	if (!filterParams) {	1✔
118	throw std::invalid_argument("Invalid parameter type for filter operation");	×
119	}
120
121	auto const * analog_time_series = std::get_if<std::shared_ptr<AnalogTimeSeries>>(&dataVariant);	1✔
122	if (!analog_time_series \|\| !*analog_time_series) {	1✔
123	throw std::invalid_argument("Invalid input data type or null pointer");	×
124	}
125
126	auto filtered_data = filter_analog(analog_time_series->get(), *filterParams, progressCallback);	1✔
127	return DataTypeVariant(filtered_data);	2✔
128	}	1✔

paulmthompson / WhiskerToolbox / 16083587281

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