Loading...
Searching...
No Matches
MayaFlux::Kakshya::DynamicRegionProcessor Class Reference
Extends RegionOrganizationProcessor with dynamic, runtime reorganization capabilities. More...
#include <RegionProcessors.hpp>
Inheritance diagram for MayaFlux::Kakshya::DynamicRegionProcessor:
Collaboration diagram for MayaFlux::Kakshya::DynamicRegionProcessor:
Public Member Functions | |
| DynamicRegionProcessor (const std::shared_ptr< SignalSourceContainer > &container) | |
| Construct a dynamic region processor for a given container. | |
| void | set_reorganization_callback (RegionOrganizer callback) |
| Sets the callback for region reorganization. | |
| void | process (std::shared_ptr< SignalSourceContainer > container) override |
| Processes audio, performing reorganization if needed. | |
| void | trigger_reorganization () |
| Triggers a reorganization on the next processing cycle. | |
| void | set_auto_reorganization (std::function< bool(const std::vector< OrganizedRegion > &, std::shared_ptr< SignalSourceContainer >)> criteria) |
| Set automatic reorganization based on custom criteria. | |
| Public Member Functions inherited from MayaFlux::Kakshya::RegionOrganizationProcessor | |
| 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. | |
Private Member Functions | |
| bool | should_reorganize (const std::shared_ptr< SignalSourceContainer > &container) |
| Checks if reorganization should occur for the current container. | |
Private Attributes | |
| std::atomic< bool > | m_needs_reorganization { false } |
| Flag for pending reorganization. | |
| RegionOrganizer | m_reorganizer_callback |
| Callback for reorganization. | |
| std::function< bool(const std::vector< OrganizedRegion > &, std::shared_ptr< SignalSourceContainer >)> | m_auto_reorganization_criteria |
| Criteria function for automatic reorganization. | |
Additional Inherited Members | |
| Protected Member Functions inherited from MayaFlux::Kakshya::RegionOrganizationProcessor | |
| 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 ®ion, 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 ¤t_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 ®ion) 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 > ®ions) 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. | |
| 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
Extends RegionOrganizationProcessor with dynamic, runtime reorganization capabilities.
DynamicRegionProcessor enables adaptive, data-driven audio workflows by allowing regions to be reorganized at runtime based on content analysis, user interaction, or external signals. This supports:
- Real-time adaptation to audio features or events
- Interactive or generative region arrangement
- Automated reorganization based on custom criteria
The processor can trigger reorganization on demand or automatically based on user-defined criteria, making it ideal for advanced digital-first applications.
Definition at line 206 of file RegionProcessors.hpp.
The documentation for this class was generated from the following files:
