transform_crossfade_regions() [1/2]

template<OperationReadyData DataType>

DataType MayaFlux::Yantra::transform_crossfade_regions	(	DataType &	input,
		const std::vector< std::pair< Kakshya::Region, Kakshya::Region > > &	fade_regions,
		uint32_t	fade_duration
	)

Cross-fade between regions with smooth transitions (IN-PLACE)

Template Parameters

DataType

OperationReadyData type

Parameters

input	Input data - WILL BE MODIFIED
fade_regions	Pairs of regions to crossfade
fade_duration	Duration of fade in samples

Returns

Crossfaded data

Definition at line 312 of file MatrixHelper.hpp.

{
    // OLD: auto [target_data, structure_info] = OperationHelper::extract_structured_double(input);
    auto extraction_result = OperationHelper::extract_structured_double(input);
    auto& target_data = std::get<0>(extraction_result);
    auto& structure_info = std::get<1>(extraction_result);
 
    std::ranges::for_each(fade_regions, [&target_data, fade_duration](const auto& fade_pair) {
        const auto& [region_a, region_b] = fade_pair;
 
        auto start_a = static_cast<uint64_t>(region_a.start_coordinates[0]);
        auto end_a = static_cast<uint64_t>(region_a.end_coordinates[0]);
        auto start_b = static_cast<uint64_t>(region_b.start_coordinates[0]);
 
        uint64_t fade_start = (end_a > fade_duration) ? end_a - fade_duration : 0;
        uint64_t fade_end = std::min(start_b + fade_duration, static_cast<uint64_t>(target_data[0].size()));
 
        for (auto& channel_span : target_data) {
            if (fade_start < fade_end && fade_start < channel_span.size()) {
                auto fade_span = channel_span.subspan(fade_start, fade_end - fade_start);
 
                auto fade_indices = std::views::iota(size_t { 0 }, fade_span.size());
                std::ranges::for_each(fade_indices, [&fade_span](size_t i) {
                    double ratio = static_cast<double>(i) / (fade_span.size() - 1);
                    double smooth_ratio = 0.5 * (1.0 - std::cos(ratio * M_PI));
                    fade_span[i] *= (1.0 - smooth_ratio);
                });
            }
        }
    });
 
    auto reconstructed_data = target_data
        | std::views::transform([](const auto& span) {
              return std::vector<double>(span.begin(), span.end());
          })
        | std::ranges::to<std::vector>();
 
    return OperationHelper::reconstruct_from_double<DataType>(reconstructed_data, structure_info);
}

References MayaFlux::Yantra::OperationHelper::extract_structured_double().

Here is the call graph for this function: