Base class for N-dimensional region processors. More...

#include <RegionProcessorBase.hpp>

Inheritance diagram for MayaFlux::Kakshya::RegionProcessorBase:

Collaboration diagram for MayaFlux::Kakshya::RegionProcessorBase:

Public Member Functions
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.

virtual void	process (std::shared_ptr< SignalSourceContainer > container)=0
	Processes the data in the container.

Protected Member Functions
virtual void	organize_container_data (std::shared_ptr< SignalSourceContainer > container)=0
	Organize container data into structured regions.

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.

Protected Attributes
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

Base class for N-dimensional region processors.

RegionProcessorBase provides a foundation for advanced, data-driven region processing in Maya Flux. It abstracts common functionality for working with N-dimensional regions, including:

Region organization and management (non-linear, content-driven, or semantic regions)
Region-level caching for efficient repeated/random access
State and position tracking for non-linear or interactive workflows
Dimension role metadata for semantic-aware processing (e.g., TIME, CHANNEL, SPATIAL_X)
Coordinate transformations (scaling, translation, rotation) for flexible data access

This class is designed for digital-first, data-driven workflows, enabling:

Non-linear playback, editing, and analysis of audio or multi-dimensional data
Dynamic region-based processing (e.g., slicing, rearrangement, feature extraction)
Efficient streaming and caching of large or remote datasets
Integration with higher-level processors such as RegionOrganizationProcessor

Derived classes should implement region organization logic and may override caching, extraction, and transformation methods for specialized behavior.

See also: RegionOrganizationProcessor, DynamicRegionProcessor

Definition at line 34 of file RegionProcessorBase.hpp.

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

Public Member Functions

Protected Member Functions

Protected Attributes

Detailed Description