MayaFlux::Kakshya::RegionOrganizationProcessor Class Reference

Data-driven processor for organizing and processing non-linear audio regions. More...

#include <RegionProcessors.hpp>

Inheritance diagram for MayaFlux::Kakshya::RegionOrganizationProcessor:

Collaboration diagram for MayaFlux::Kakshya::RegionOrganizationProcessor:

Public Member Functions
	RegionOrganizationProcessor (std::shared_ptr< SignalSourceContainer > container)
	Construct a region organization processor for a given container.
void	organize_container_data (std::shared_ptr< SignalSourceContainer > container) override
	Organize the container's data into regions and segments.
void	process (std::shared_ptr< SignalSourceContainer > container) override
	Processes audio data according to the current region organization.
void	add_region_group (const std::string &group_name)
	Creates a new region group for organizing related regions.
void	add_segment_to_region (const std::string &group_name, size_t region_index, const std::vector< uint64_t > &start_coords, const std::vector< uint64_t > &end_coords, const std::unordered_map< std::string, std::any > &attributes)
	Adds a segment to an existing region.
void	set_region_transition (const std::string &group_name, size_t region_index, RegionTransition type, double duration_ms=0.0)
	Configures the transition between regions.
void	set_region_looping (const std::string &group_name, size_t region_index, bool enabled, const std::vector< uint64_t > &loop_start={}, const std::vector< uint64_t > &loop_end={})
	Enable or disable looping for a region.
void	jump_to_region (const std::string &group_name, size_t region_index)
	Jump to a specific region for processing or playback.
void	jump_to_position (const std::vector< uint64_t > &position)
	Jump to a specific position in the data.
void	set_selection_pattern (const std::string &group_name, size_t region_index, RegionSelectionPattern pattern)
	Set the selection pattern for a region (e.g., sequential, random).
Public Member Functions inherited from MayaFlux::Kakshya::RegionProcessorBase
virtual	~RegionProcessorBase ()=default
void	on_attach (std::shared_ptr< SignalSourceContainer > container) override
	Attach this processor to a signal source container.
void	on_detach (std::shared_ptr< SignalSourceContainer > container) override
	Detach this processor from its container.
bool	is_processing () const override
	Query if the processor is currently performing processing.
void	set_cache_limit (size_t max_cached_elements)
	Set the maximum cache size for regions (in elements).
void	set_auto_caching (bool enabled)
	Enable or disable automatic region caching.
const std::vector< uint64_t > &	get_current_position () const
	Get the current processing position (N-dimensional coordinates).
void	set_current_position (const std::vector< uint64_t > &position)
	Set the current processing position (N-dimensional coordinates).
Public Member Functions inherited from MayaFlux::Kakshya::DataProcessor
virtual	~DataProcessor ()=default
	Virtual destructor for proper cleanup.

Protected Member Functions
virtual void	process_organized_regions (const std::shared_ptr< SignalSourceContainer > &container, std::vector< DataVariant > &output_data)
	Process regions according to their selection pattern.
virtual void	process_region_segment (const OrganizedRegion &region, const RegionSegment &segment, const std::shared_ptr< SignalSourceContainer > &container, std::vector< DataVariant > &output_data)
	Process a single region segment.
virtual void	apply_region_transition (const OrganizedRegion &current_region, const OrganizedRegion &next_region, const std::shared_ptr< SignalSourceContainer > &container, std::vector< DataVariant > &output_data)
	Apply a transition between two regions.
virtual size_t	select_next_segment (const OrganizedRegion &region) const
	Select the next segment to process according to the region's pattern.
std::optional< size_t >	find_region_for_position (const std::vector< uint64_t > &position, const std::vector< OrganizedRegion > &regions) const
Protected Member Functions inherited from MayaFlux::Kakshya::RegionProcessorBase
virtual void	cache_region_if_needed (const RegionSegment &segment, const std::shared_ptr< SignalSourceContainer > &container)
	Cache a region's data if beneficial and not already cached.
virtual bool	advance_position (std::vector< uint64_t > &position, uint64_t steps=1, const OrganizedRegion *region=nullptr)
	Advance position according to memory layout and looping.
virtual void	ensure_output_dimensioning (std::vector< DataVariant > &output_data, const std::vector< uint64_t > &required_shape)
	Ensure output data is properly dimensioned for region extraction.

Private Member Functions
void	organize_group (const std::shared_ptr< SignalSourceContainer > &container, const RegionGroup &group)
	Organize a group of regions within the container.
void	refresh_organized_data ()
	Refresh the internal organization of regions.

Private Attributes
std::mt19937	m_random_engine { std::random_device {}() }
std::vector< double >	m_segment_weights

Additional Inherited Members
Protected Attributes inherited from MayaFlux::Kakshya::RegionProcessorBase
std::weak_ptr< SignalSourceContainer >	m_container_weak
std::atomic< bool >	m_is_processing { false }
std::vector< OrganizedRegion >	m_organized_regions
size_t	m_current_region_index = 0
std::vector< uint64_t >	m_current_position
std::unique_ptr< RegionCacheManager >	m_cache_manager
size_t	m_max_cache_size { static_cast<size_t>(1024 * 1024) }
bool	m_auto_caching = true
ContainerDataStructure	m_structure

Detailed Description

Data-driven processor for organizing and processing non-linear audio regions.

RegionOrganizationProcessor enables advanced workflows by treating audio as structured, navigable regions rather than linear streams. It supports:

• Dynamic grouping of audio into regions and segments with arbitrary metadata.
• Non-linear playback, editing, and analysis based on region structure.
• Region-level transitions, looping, and selection patterns (sequential, random, etc.).
• Efficient caching and navigation for interactive or content-driven applications.

This processor is foundational for workflows such as:

• Interactive audio editing and arrangement
• Adaptive playback and generative audio
• Feature-driven or content-aware region processing
• Seamless integration with digital-first nodes, routines, and buffer systems

Regions are organized using the OrganizedRegion abstraction, which supports metadata, transitions, and flexible segment definitions. All processing is data-driven and unconstrained by analog metaphors.

Definition at line 32 of file RegionProcessors.hpp.

---

The documentation for this class was generated from the following files:

• RegionProcessors.hpp
• RegionProcessors.cpp