18762825348

Committed 23 Oct 2025 09:42PM UTC coverage: 72.822% (+0.3%) from 72.522%

Build # 18762825348

Build Type

push

github

Committed by

paulmthompson

Commit Message

add boolean digital interval logic test

Run Details

693 of 711 new or added lines in 5 files covered. (97.47%)

718 existing lines in 10 files now uncovered.

54997 of 75522 relevant lines covered (72.82%)

45740.9 hits per line

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

83.05

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

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

paulmthompson / WhiskerToolbox / 18762825348

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