extract_segments_data()

template<typename T >

std::vector< std::vector< T > > MayaFlux::Kakshya::extract_segments_data	(	const std::vector< RegionSegment > &	segments,
		const std::vector< std::span< const T > > &	source_spans,
		const std::vector< DataDimension > &	dimensions,
		OrganizationStrategy	organization
	)

Extract data for multiple segments from multi-channel source data.

Template Parameters

T	Data type.

Parameters

segments	Vector of region segments to extract.
source_spans	Vector of source data spans (one per channel).
dimensions	Dimension descriptors.
organization	Storage organization strategy.

Returns

Vector of vectors, each containing extracted data for one segment.

Definition at line 197 of file RegionUtils.hpp.

{
    if (source_spans.size() != 1) {
        throw std::invalid_argument("Source spans cannot be empty");
    }
 
    std::vector<std::vector<T>> result;
 
    for (const auto& segment : segments) {
        if (segment.is_cached && !segment.cache.data.empty()) {
            for (const auto& variant : segment.cache.data) {
                std::vector<T> converted;
                auto span = extract_from_variant<T>(variant, converted);
                std::vector<T> cached_data(span.begin(), span.end());
 
                if (organization == OrganizationStrategy::INTERLEAVED) {
                    if (result.empty())
                        result.resize(1);
                    std::ranges::copy(cached_data, std::back_inserter(result[0]));
                } else {
                    if (result.size() <= result.size())
                        result.resize(result.size() + 1);
                    result.back() = std::move(cached_data);
                }
            }
        } else {
            auto region_data = extract_region_data<T>(source_spans, segment.source_region, dimensions, organization);
 
            if (organization == OrganizationStrategy::INTERLEAVED) {
                if (result.empty())
                    result.resize(1);
                std::ranges::copy(region_data[0], std::back_inserter(result[0]));
            } else {
                if (result.empty())
                    result.resize(region_data.size());
                for (size_t i = 0; i < region_data.size(); ++i) {
                    std::ranges::copy(region_data[i], std::back_inserter(result[i]));
                }
            }
        }
    }
 
    return result;
}

References INTERLEAVED.