15885645409

Committed 25 Jun 2025 07:37PM UTC coverage: 71.644% (+2.2%) from 69.485%

Build # 15885645409

Build Type

push

github

Committed by

paulmthompson

Commit Message

add median filter for masks

Run Details

250 of 260 new or added lines in 3 files covered. (96.15%)

49 existing lines in 2 files now uncovered.

11170 of 15591 relevant lines covered (71.64%)

1148.54 hits per line

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

0.0

/src/WhiskerToolbox/DataManager/transforms/Masks/mask_skeletonize.cpp

#include "mask_skeletonize.hpp"

#include "Masks/Mask_Data.hpp"
#include "Masks/utils/mask_utils.hpp"
#include "Masks/utils/skeletonize.hpp"

#include <algorithm>
#include <cmath>        // std::round
#include <iostream>     // std::cout
#include <vector>

std::shared_ptr<MaskData> skeletonize_mask(
        MaskData const * mask_data,
        MaskSkeletonizeParameters const * params) {
    return skeletonize_mask(mask_data, params, [](int){});
}

std::shared_ptr<MaskData> skeletonize_mask(
        MaskData const * mask_data,
        MaskSkeletonizeParameters const * params,
        ProgressCallback progressCallback) {

    static_cast<void>(params);
    
    if (!mask_data) {
        progressCallback(100);
        return std::make_shared<MaskData>();
    }
    
    // Create binary processing function that uses the skeletonization algorithm
    auto binary_processor = [](Image const & input_image) -> Image {
        return fast_skeletonize(input_image);
    };
    
    // Use the utility function to apply the algorithm
    return apply_binary_image_algorithm(mask_data, binary_processor, progressCallback);
}

///////////////////////////////////////////////////////////////////////////////// MaskSkeletonizeOperation implementation

std::string MaskSkeletonizeOperation::getName() const {
    return "Skeletonize Mask";
}

std::type_index MaskSkeletonizeOperation::getTargetInputTypeIndex() const {
    return typeid(std::shared_ptr<MaskData>);
}

bool MaskSkeletonizeOperation::canApply(DataTypeVariant const & dataVariant) const {
    if (!std::holds_alternative<std::shared_ptr<MaskData>>(dataVariant)) {
        return false;
    }
    
    auto const * ptr_ptr = std::get_if<std::shared_ptr<MaskData>>(&dataVariant);
    return ptr_ptr && *ptr_ptr;
}

std::unique_ptr<TransformParametersBase> MaskSkeletonizeOperation::getDefaultParameters() const {
    return std::make_unique<MaskSkeletonizeParameters>();
}

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

DataTypeVariant MaskSkeletonizeOperation::execute(DataTypeVariant const & dataVariant,
                                                 TransformParametersBase const * transformParameters,
                                                 ProgressCallback progressCallback) {
    
    auto const * mask_data_ptr = std::get_if<std::shared_ptr<MaskData>>(&dataVariant);
    
    if (!mask_data_ptr || !(*mask_data_ptr)) {
        std::cerr << "MaskSkeletonizeOperation::execute called with incompatible variant type or null data." << std::endl;
        return {};
    }
    
    MaskData const * input_mask_data = (*mask_data_ptr).get();
    
    MaskSkeletonizeParameters const * params = nullptr;
    std::unique_ptr<TransformParametersBase> default_params_owner;
    
    if (transformParameters) {
        params = dynamic_cast<MaskSkeletonizeParameters const *>(transformParameters);
        if (!params) {
            std::cerr << "MaskSkeletonizeOperation::execute: Invalid parameter type. Using defaults." << std::endl;
            default_params_owner = getDefaultParameters();
            params = static_cast<MaskSkeletonizeParameters const *>(default_params_owner.get());
        }
    } else {
        default_params_owner = getDefaultParameters();
        params = static_cast<MaskSkeletonizeParameters const *>(default_params_owner.get());
    }
    
    if (!params) {
        std::cerr << "MaskSkeletonizeOperation::execute: Failed to get parameters." << std::endl;
        return {};
    }
    
    std::shared_ptr<MaskData> result = skeletonize_mask(input_mask_data, params, progressCallback);
    
    if (!result) {
        std::cerr << "MaskSkeletonizeOperation::execute: 'skeletonize_mask' failed to produce a result." << std::endl;
        return {};
    }
    
    std::cout << "MaskSkeletonizeOperation executed successfully." << std::endl;
    return result;
} 

1	#include "mask_skeletonize.hpp"
2
3	#include "Masks/Mask_Data.hpp"
4	#include "Masks/utils/mask_utils.hpp"
5	#include "Masks/utils/skeletonize.hpp"
6
7	#include <algorithm>
8	#include <cmath> // std::round
9	#include <iostream> // std::cout
10	#include <vector>
11
UNCOV 12	std::shared_ptr<MaskData> skeletonize_mask(	×
13	MaskData const * mask_data,
14	MaskSkeletonizeParameters const * params) {
UNCOV 15	return skeletonize_mask(mask_data, params, [](int){});	×
16	}
17
UNCOV 18	std::shared_ptr<MaskData> skeletonize_mask(	×
19	MaskData const * mask_data,
20	MaskSkeletonizeParameters const * params,
21	ProgressCallback progressCallback) {
22
23	static_cast<void>(params);
24
UNCOV 25	if (!mask_data) {	×
26	progressCallback(100);	×
27	return std::make_shared<MaskData>();	×
28	}
29
30	// Create binary processing function that uses the skeletonization algorithm
UNCOV 31	auto binary_processor = [](Image const & input_image) -> Image {	×
32	return fast_skeletonize(input_image);	×
33	};
34
35	// Use the utility function to apply the algorithm
36	return apply_binary_image_algorithm(mask_data, binary_processor, progressCallback);	×
37	}
38
39	///////////////////////////////////////////////////////////////////////////////// MaskSkeletonizeOperation implementation
40
UNCOV 41	std::string MaskSkeletonizeOperation::getName() const {	×
UNCOV 42	return "Skeletonize Mask";	×
43	}
44
45	std::type_index MaskSkeletonizeOperation::getTargetInputTypeIndex() const {	×
46	return typeid(std::shared_ptr<MaskData>);	×
47	}
48
UNCOV 49	bool MaskSkeletonizeOperation::canApply(DataTypeVariant const & dataVariant) const {	×
UNCOV 50	if (!std::holds_alternative<std::shared_ptr<MaskData>>(dataVariant)) {	×
51	return false;	×
52	}
53
UNCOV 54	auto const * ptr_ptr = std::get_if<std::shared_ptr<MaskData>>(&dataVariant);	×
UNCOV 55	return ptr_ptr && *ptr_ptr;	×
56	}
57
UNCOV 58	std::unique_ptr<TransformParametersBase> MaskSkeletonizeOperation::getDefaultParameters() const {	×
59	return std::make_unique<MaskSkeletonizeParameters>();	×
60	}
61
UNCOV 62	DataTypeVariant MaskSkeletonizeOperation::execute(DataTypeVariant const & dataVariant,	×
63	TransformParametersBase const * transformParameters) {
64	return execute(dataVariant, transformParameters, [](int){});	×
65	}
66
67	DataTypeVariant MaskSkeletonizeOperation::execute(DataTypeVariant const & dataVariant,	×
68	TransformParametersBase const * transformParameters,
69	ProgressCallback progressCallback) {
70
UNCOV 71	auto const * mask_data_ptr = std::get_if<std::shared_ptr<MaskData>>(&dataVariant);	×
72
UNCOV 73	if (!mask_data_ptr \|\| !(*mask_data_ptr)) {	×
74	std::cerr << "MaskSkeletonizeOperation::execute called with incompatible variant type or null data." << std::endl;	×
UNCOV 75	return {};	×
76	}
77
78	MaskData const * input_mask_data = (*mask_data_ptr).get();	×
79
UNCOV 80	MaskSkeletonizeParameters const * params = nullptr;	×
UNCOV 81	std::unique_ptr<TransformParametersBase> default_params_owner;	×
82
83	if (transformParameters) {	×
84	params = dynamic_cast<MaskSkeletonizeParameters const *>(transformParameters);	×
UNCOV 85	if (!params) {	×
UNCOV 86	std::cerr << "MaskSkeletonizeOperation::execute: Invalid parameter type. Using defaults." << std::endl;	×
UNCOV 87	default_params_owner = getDefaultParameters();	×
UNCOV 88	params = static_cast<MaskSkeletonizeParameters const *>(default_params_owner.get());	×
89	}
90	} else {
UNCOV 91	default_params_owner = getDefaultParameters();	×
92	params = static_cast<MaskSkeletonizeParameters const *>(default_params_owner.get());	×
93	}
94
95	if (!params) {	×
96	std::cerr << "MaskSkeletonizeOperation::execute: Failed to get parameters." << std::endl;	×
UNCOV 97	return {};	×
98	}
99
UNCOV 100	std::shared_ptr<MaskData> result = skeletonize_mask(input_mask_data, params, progressCallback);	×
101
102	if (!result) {	×
103	std::cerr << "MaskSkeletonizeOperation::execute: 'skeletonize_mask' failed to produce a result." << std::endl;	×
UNCOV 104	return {};	×
105	}
106
UNCOV 107	std::cout << "MaskSkeletonizeOperation executed successfully." << std::endl;	×
UNCOV 108	return result;	×
109	}	×

paulmthompson / WhiskerToolbox / 15885645409

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