MayaFlux::Yantra Namespace Reference

Namespaces
namespace	detail
namespace	Granular
namespace	PipelineFactory
	Factory functions for common pipeline configurations.

Classes
struct	AutoRegisterOperation
	Automatic registration helper Operations can use this in their implementation files for auto-registration. More...
struct	ChainedIndirectParams
	Parameters for ExecutionMode::CHAINED_INDIRECT. More...
struct	ChainedParams
	Parameters for ExecutionMode::CHAINED. More...
struct	ChannelEnergy
struct	ChannelStatistics
	Statistical results for a single data channel. More...
class	ComputationGrammar
	Core grammar system for rule-based computation in Maya Flux. More...
class	ComputationPipeline
	Pipeline that uses grammar rules for operation composition. More...
class	ComputeMatrix
	Local execution orchestrator for computational operations. More...
class	ComputeOperation
	Base interface for all computational operations in the processing pipeline. More...
class	ConvolutionTransformer
	Concrete transformer for convolution-based operations. More...
struct	DataStructureInfo
	Metadata about data structure for reconstruction. More...
struct	Datum
	Input/Output container for computation pipeline data flow with structure preservation. More...
struct	DependencyParams
	Parameters for ExecutionMode::DEPENDENCY. More...
struct	DependencyStage
	One stage in a dispatch_core_dependency call. More...
struct	DetectionSummary
	Flattened structured outputs from one VisionResult. More...
struct	EnergyAnalysis
	Analysis result structure for energy analysis. More...
class	EnergyAnalyzer
	High-performance energy analyzer with zero-copy processing. More...
struct	ExecutionContext
	Context information controlling how a compute operation executes. More...
struct	extraction_traits
	Native-type aware extraction traits. More...
struct	extraction_traits< Kakshya::DataVariant >
struct	extraction_traits< std::shared_ptr< Kakshya::SignalSourceContainer > >
struct	extraction_traits< T >
struct	extraction_traits_d
	Compile-time traits describing how to extract double-precision data from a given ComputeData type for use by Kinesis algorithms. More...
struct	extraction_traits_d< Kakshya::DataVariant >
struct	extraction_traits_d< Kakshya::Region >
struct	extraction_traits_d< Kakshya::RegionGroup >
struct	extraction_traits_d< std::shared_ptr< Kakshya::SignalSourceContainer > >
struct	extraction_traits_d< std::vector< Kakshya::DataVariant > >
struct	extraction_traits_d< std::vector< Kakshya::RegionSegment > >
struct	extraction_traits_d< T >
	extraction_traits_d for any Eigen matrix type. More...
class	FeatureExtractor
	Analyzer-guided feature extractor with enum-based configuration. More...
class	FluentExecutor
	Fluent interface for chaining operations on any executor. More...
class	GpuAnalyzer
	Concrete UniversalAnalyzer that dispatches entirely via a GpuExecutionContext. More...
struct	GpuChannelResult
	Erased output of a GPU dispatch: reconstructed float data plus any raw auxiliary outputs keyed by binding index. More...
class	GpuDispatchCore
	Non-template base that owns all type-independent GPU dispatch logic. More...
class	GpuExecutionContext
	Type-parameterised shell over GpuDispatchCore. More...
class	GpuExtractor
	Concrete UniversalExtractor that dispatches entirely via a GpuExecutionContext. More...
class	GpuResourceManager
	Encapsulates all Vulkan resource lifecycle behind Portal facades. More...
struct	GpuResourceManagerImpl
class	GpuSorter
	Concrete UniversalSorter that dispatches entirely via a GpuExecutionContext. More...
class	GpuTransformer
	Concrete UniversalTransformer that dispatches entirely via a GpuExecutionContext. More...
class	GrammarAwareComputeMatrix
	ComputeMatrix extension that integrates grammar-based operation selection. More...
struct	is_eigen_matrix
struct	is_eigen_matrix< Eigen::Matrix< Scalar, Rows, Cols, Options, MaxRows, MaxCols > >
struct	is_IO
	Helper to detect if a type is an Datum. More...
struct	is_IO< Datum< T > >
	Specialization for Datum types. More...
class	MathematicalTransformer
	Concrete transformer for mathematical operations. More...
class	OperationHelper
	Universal data conversion helper for all Yantra operations. More...
class	OperationPool
	Thread-safe pool for managing named operation instances. More...
class	OperationRegistry
	Manages operation type registration, discovery, and factory creation. More...
class	OpUnit
	Abstract base class for operation units in recursive processing graphs. More...
struct	PooledOperationInfo
	Metadata about a pooled operation. More...
class	ShaderExecutionContext
	Concrete GpuExecutionContext for a single fixed shader with fixed bindings. More...
struct	SortKey
	Multi-dimensional sort key specification for complex sorting. More...
class	SpectralTransformer
	Concrete transformer for frequency-domain operations. More...
class	StandardSorter
	Concrete implementation for standard comparison-based sorting. More...
struct	StatisticalAnalysis
	Analysis result structure for statistical analysis. More...
class	StatisticalAnalyzer
	High-performance statistical analyzer with zero-copy processing. More...
class	TemporalTransformer
	Concrete transformer for time-domain operations. More...
class	TextureExecutionContext
	GpuExecutionContext specialisation for image compute shaders. More...
struct	TransformationKey
	Multi-dimensional transformation key specification for complex transformations. More...
class	UniversalAnalyzer
	Template-flexible analyzer base with instance-defined I/O types. More...
class	UniversalExtractor
	Template-flexible extractor base with instance-defined I/O types. More...
class	UniversalMatcher
	Type-agnostic pattern matching for computation rules. More...
class	UniversalSorter
	Template-flexible sorter base with instance-defined I/O types. More...
class	UniversalTransformer
	Template-flexible transformer base with instance-defined I/O types. More...
struct	VisionAnalysis
	Analysis result produced by VisionAnalyzer for one frame. More...
class	VisionAnalyzer
	UniversalAnalyzer that takes any pixel-bearing input, runs a VisionSequence via VisionExecutor, and surfaces structured results into the Yantra compute graph. More...
class	VisionExtractor
	Extracts a pixel sub-region guided by a VisionAnalysis in input metadata. More...
struct	VisionGpuContexts
	Fixed set of TextureExecutionContexts covering every GPU-implemented VisionOp shape. More...
class	VisionGpuExecutor
	Stateful GPU dispatch engine for VisionSequence execution. More...
class	VisionSorter
	Reorders detection results in a VisionAnalysis by a scalar key or callable. More...
struct	VulkanBufferSlot

Concepts
concept	OperationReadyData
	Concept to constrain types suitable for operation units.
concept	VariantVector
concept	ComputeData
	Universal concept for types that can flow through the computation pipeline.
concept	RegionLike
	Types that represent spatial or temporal markers requiring a container to resolve data.
concept	MultiVariant
	Types that yield multiple data channels on extraction.
concept	RequiresContainer
	Types that need an associated SignalSourceContainer to extract data.
concept	EigenMatrixLike
	Any Eigen matrix type, regardless of scalar type.
concept	SingleVariant
	Single data source: one DataVariant, a column Eigen vector of any scalar type, or any type constructible from DataVariant that is not multi-variant or region-like.

Typedefs
template<ComputeData OutputType = std::shared_ptr<Kakshya::SignalSourceContainer>>
using	ContainerAnalyzer = UniversalAnalyzer< std::shared_ptr< Kakshya::SignalSourceContainer >, OutputType >
	Analyzer for signal container processing.
using	ContainerEnergyAnalyzer = EnergyAnalyzer< std::shared_ptr< Kakshya::SignalSourceContainer >, Eigen::MatrixXd >
	Container energy analyzer: SignalContainer -> MatrixXd.
template<ComputeData OutputType = std::shared_ptr<Kakshya::SignalSourceContainer>>
using	ContainerExtractor = UniversalExtractor< std::shared_ptr< Kakshya::SignalSourceContainer >, OutputType >
	Extractor for signal container processing.
using	ContainerFeatureExtractor = FeatureExtractor< std::shared_ptr< Kakshya::SignalSourceContainer >, std::vector< std::vector< double > > >
	Container feature extractor: SignalContainer -> multi vector<double>
using	ContainerIO = Datum< std::shared_ptr< Kakshya::SignalSourceContainer > >
	IO for signal containers.
using	ContainerOperation = ComputeOperation< std::shared_ptr< Kakshya::SignalSourceContainer > >
template<ComputeData OutputType = std::shared_ptr<Kakshya::SignalSourceContainer>>
using	ContainerSorter = UniversalSorter< std::shared_ptr< Kakshya::SignalSourceContainer >, OutputType >
	Sorter for signal container processing.
using	ContainerStatisticalAnalyzer = StatisticalAnalyzer< std::shared_ptr< Kakshya::SignalSourceContainer >, Eigen::MatrixXd >
	Container statistical analyzer: SignalContainer -> MatrixXd.
using	ContainerVisionAnalyzer = VisionAnalyzer< std::shared_ptr< Kakshya::SignalSourceContainer >, std::vector< Kakshya::DataVariant > >
	Container: any SignalSourceContainer in, DataVariant pixel_image out.
template<ComputeData OutputType = std::vector<Kakshya::DataVariant>>
using	DataAnalyzer = UniversalAnalyzer< std::vector< Kakshya::DataVariant >, OutputType >
	Analyzer that takes DataVariant and produces DataVariant.
template<ComputeData OutputType = Kakshya::DataVariant>
using	DataExtractor = UniversalExtractor< std::vector< Kakshya::DataVariant >, OutputType >
	Extractor that takes DataVariant and produces any ComputeData type.
using	DataIO = Datum< std::vector< Kakshya::DataVariant > >
	IO for universal data variant.
using	DataOperation = ComputeOperation< Kakshya::DataVariant >
template<ComputeData OutputType = std::vector<Kakshya::DataVariant>>
using	DataSorter = UniversalSorter< std::vector< Kakshya::DataVariant >, OutputType >
	Sorter that takes DataVariant and produces DataVariant.
using	DataVisionExtractor = VisionExtractor< std::vector< Kakshya::DataVariant >, std::vector< Kakshya::DataVariant > >
	DataVariant pixels in, DataVariant pixels out.
using	DataVisionSorter = VisionSorter< std::vector< Kakshya::DataVariant >, std::vector< Kakshya::DataVariant > >
template<typename T >
using	enable_if_eigen_matrix_t = std::enable_if_t< is_eigen_matrix_v< T > >
template<typename T >
using	enable_if_multi_no_container_t = std::enable_if_t< extraction_traits_d< T >::is_multi_variant &&!extraction_traits_d< T >::requires_container >
template<typename T >
using	enable_if_multi_variant_t = std::enable_if_t< extraction_traits_d< T >::is_multi_variant >
template<typename T >
using	enable_if_multi_with_container_t = std::enable_if_t< extraction_traits_d< T >::is_multi_variant &&extraction_traits_d< T >::requires_container >
template<typename T >
using	enable_if_region_like_t = std::enable_if_t< extraction_traits_d< T >::is_region_like >
template<typename T >
using	enable_if_single_variant_t = std::enable_if_t< SingleVariant< T > >
using	ExecutionParams = std::variant< std::monostate, ChainedParams, ChainedIndirectParams, DependencyParams >
template<typename T >
using	extraction_result_t = typename extraction_traits_d< T >::result_type
	Algorithm (double) result type for T – for Kinesis callers.
using	GpuBufferBinding = Portal::Graphics::GpuBufferBinding
using	GpuComputeConfig = Portal::Graphics::GpuComputeConfig
template<ComputeData InputType = std::vector<Kakshya::DataVariant>>
using	IndexSorter = UniversalSorter< InputType, std::vector< std::vector< size_t > > >
	Sorter for indices generation.
template<ComputeData InputType = std::vector<Kakshya::DataVariant>>
using	MatrixAnalyzer = UniversalAnalyzer< InputType, Eigen::MatrixXd >
	Analyzer that produces Eigen matrices.
template<ComputeData InputType = std::vector<Kakshya::DataVariant>>
using	MatrixExtractor = UniversalExtractor< InputType, Eigen::MatrixXd >
	Extractor that produces Eigen matrices.
using	MatrixFeatureExtractor = FeatureExtractor< std::vector< Kakshya::DataVariant >, Eigen::MatrixXd >
	Eigen Matrix feature extractor: DataVariant -> Matrixxd.
template<ComputeData InputType = std::vector<Kakshya::DataVariant>>
using	MatrixSorter = UniversalSorter< InputType, Eigen::MatrixXd >
	Sorter that produces Eigen matrices.
template<typename T >
using	native_element_t = typename extraction_traits< T >::native_element_type
	Native element type for T.
template<typename T >
using	native_result_t = typename extraction_traits< T >::native_result_type
	Native result type for T – zero-copy in the source's own scalar type.
template<ComputeData InputType = std::vector<Kakshya::DataVariant>>
using	NumericExtractor = UniversalExtractor< InputType, std::vector< double > >
	Extractor that produces numeric vectors.
using	OperationHookCallback = std::function< void(std::any &)>
	Callback type for pre/post operation hooks.
template<ComputeData InputType = std::vector<Kakshya::DataVariant>>
using	RawEnergyAnalyzer = EnergyAnalyzer< InputType, std::vector< std::vector< double > > >
	Raw energy analyzer: produces double vectors.
template<ComputeData InputType = std::vector<Kakshya::DataVariant>>
using	RawStatisticalAnalyzer = StatisticalAnalyzer< InputType, std::vector< std::vector< double > > >
	Raw statistical analyzer: produces double vectors.
using	ReconstructionCallback = std::function< std::any(std::vector< std::vector< double > > &, std::any &)>
	Callback type for custom reconstruction logic.
template<ComputeData OutputType = Kakshya::Region>
using	RegionAnalyzer = UniversalAnalyzer< Kakshya::Region, OutputType >
	Analyzer for region-based analysis.
using	RegionEnergyAnalyzer = EnergyAnalyzer< Kakshya::Region, Eigen::MatrixXd >
	Region energy analyzer: Region -> MatrixXd.
template<ComputeData OutputType = Kakshya::Region>
using	RegionExtractor = UniversalExtractor< Kakshya::Region, OutputType >
	Extractor for region-based extraction.
using	RegionFeatureExtractor = FeatureExtractor< Kakshya::Region, std::vector< std::vector< double > > >
	Region feature extractor: Region -> multi vector<double>
template<ComputeData OutputType = Kakshya::RegionGroup>
using	RegionGroupAnalyzer = UniversalAnalyzer< Kakshya::RegionGroup, OutputType >
	Analyzer for region group processing.
template<ComputeData OutputType = Kakshya::RegionGroup>
using	RegionGroupExtractor = UniversalExtractor< Kakshya::RegionGroup, OutputType >
	Extractor for region group processing.
using	RegionGroupIO = Datum< Kakshya::RegionGroup >
	IO for region groups.
using	RegionGroupOperation = ComputeOperation< Kakshya::RegionGroup >
template<ComputeData OutputType = Kakshya::RegionGroup>
using	RegionGroupSorter = UniversalSorter< Kakshya::RegionGroup, OutputType >
	Sorter for region group processing.
using	RegionIO = Datum< Kakshya::Region >
	IO for single regions.
using	RegionOperation = ComputeOperation< Kakshya::Region >
template<ComputeData OutputType = Kakshya::Region>
using	RegionSorter = UniversalSorter< Kakshya::Region, OutputType >
	Sorter for region-based sorting.
using	RegionStatisticalAnalyzer = StatisticalAnalyzer< Kakshya::Region, Eigen::VectorXd >
	Region statistical analyzer: Region -> MatrixXd.
using	RegionVisionAnalyzer = VisionAnalyzer< Kakshya::Region, std::vector< Kakshya::DataVariant > >
	Region: pixel sub-region with container in, DataVariant pixel_image out.
template<ComputeData OutputType = std::vector<Kakshya::RegionSegment>>
using	SegmentAnalyzer = UniversalAnalyzer< std::vector< Kakshya::RegionSegment >, OutputType >
	Analyzer for segment processing.
template<ComputeData OutputType = std::vector<Kakshya::RegionSegment>>
using	SegmentExtractor = UniversalExtractor< std::vector< Kakshya::RegionSegment >, OutputType >
	Extractor for segment processing.
using	SegmentIO = Datum< std::vector< Kakshya::RegionSegment > >
	IO for region segments.
using	SegmentOperation = ComputeOperation< std::vector< Kakshya::RegionSegment > >
template<ComputeData OutputType = std::vector<Kakshya::RegionSegment>>
using	SegmentSorter = UniversalSorter< std::vector< Kakshya::RegionSegment >, OutputType >
	Sorter for segment processing.
using	SortingAlgorithm = Kinesis::Discrete::SortingAlgorithm
using	SortingDirection = Kinesis::Discrete::SortingDirection
using	StandardDataSorter = StandardSorter< std::vector< Kakshya::DataVariant > >
	Standard sorter for DataVariant.
using	StandardEnergyAnalyzer = EnergyAnalyzer< std::vector< Kakshya::DataVariant >, Eigen::MatrixXd >
	Standard energy analyzer: DataVariant -> MatrixXd.
using	StandardFeatureExtractor = FeatureExtractor< std::vector< Kakshya::DataVariant >, std::vector< std::vector< double > > >
	Standard feature extractor: vector of [DataVariant -> vector<double>].
template<ComputeData InputType = std::vector<Kakshya::DataVariant>>
using	StandardIndexSorter = StandardSorter< InputType, std::vector< std::vector< size_t > > >
	Standard sorter that generates indices.
using	StandardMatrixSorter = StandardSorter< Eigen::MatrixXd >
	Standard sorter for Eigen matrices.
using	StandardRegionGroupSorter = StandardSorter< Kakshya::RegionGroup >
	Standard sorter for region groups (proper way to handle multiple regions)
using	StandardSegmentSorter = StandardSorter< std::vector< Kakshya::RegionSegment > >
	Standard sorter for region segments.
using	StandardStatisticalAnalyzer = StatisticalAnalyzer< std::vector< Kakshya::DataVariant >, Eigen::MatrixXd >
	Standard statistical analyzer: DataVariant -> MatrixXd.
template<typename T >
using	StandardVectorSorter = StandardSorter< std::vector< std::vector< T > > >
	Standard sorter for numeric vectors (DataVariant contains these)
using	StandardVectorSorterEigen = StandardSorter< Eigen::VectorXd >
	Standard sorter for Eigen vectors.
using	StandardVisionAnalyzer = VisionAnalyzer< std::vector< Kakshya::DataVariant >, std::vector< Kakshya::DataVariant > >
	Standard: DataVariant pixels in, DataVariant pixel_image out.
using	StandardVisionExtractor = VisionExtractor< std::shared_ptr< Kakshya::SignalSourceContainer >, std::vector< Kakshya::DataVariant > >
	Default: container in, DataVariant pixels out.
using	StandardVisionSorter = VisionSorter< std::shared_ptr< Kakshya::SignalSourceContainer >, std::shared_ptr< Kakshya::SignalSourceContainer > >
template<typename T >
using	variant_result_t = typename extraction_traits_d< T >::variant_result_type
	Variant result type for T.
template<ComputeData InputType = std::vector<Kakshya::DataVariant>>
using	VariantEnergyAnalyzer = EnergyAnalyzer< InputType, std::vector< Kakshya::DataVariant > >
	Variant energy analyzer: produces DataVariant output.
using	VariantFeatureExtractor = FeatureExtractor< std::vector< Kakshya::DataVariant >, std::vector< Kakshya::DataVariant > >
	Variant feature extractor: DataVariant -> DataVariant.
template<ComputeData InputType = std::vector<Kakshya::DataVariant>>
using	VariantStatisticalAnalyzer = StatisticalAnalyzer< InputType, Kakshya::DataVariant >
	Variant statistical analyzer: produces DataVariant output.
template<ComputeData InputType = std::vector<Kakshya::DataVariant>>
using	VectorAnalyzer = UniversalAnalyzer< InputType, Eigen::VectorXd >
	Analyzer that produces Eigen vectors.
template<typename T , ComputeData OutputType = std::vector<std::vector<T>>>
using	VectorContainerSorter = UniversalSorter< std::vector< std::vector< T > >, OutputType >
	Sorter for vector containers.
template<ComputeData InputType = std::vector<Kakshya::DataVariant>>
using	VectorExtractor = UniversalExtractor< InputType, Eigen::VectorXd >
	Extractor that produces Eigen vectors.
template<ComputeData InputType = std::vector<Kakshya::DataVariant>>
using	VectorSorter = UniversalSorter< InputType, Eigen::VectorXd >
	Sorter that produces Eigen vectors.

Enumerations
enum class	AnalysisGranularity : uint8_t { RAW_VALUES , ATTRIBUTED_SEGMENTS , ORGANIZED_GROUPS , SUMMARY_STATISTICS }
	Output granularity control for analysis results. More...
enum class	AnalysisType : uint8_t {   STATISTICAL , SPECTRAL , TEMPORAL , SPATIAL ,   FEATURE , PATTERN , TRANSFORM , CUSTOM }
	Categories of analysis operations for discovery and organization. More...
enum class	ComputationContext : uint8_t {   TEMPORAL , SPECTRAL , SPATIAL , SEMANTIC ,   STRUCTURAL , LOGICAL , PARAMETRIC , REACTIVE ,   CONCURRENT , RECURSIVE , CONVOLUTION }
	Defines the computational contexts in which rules can be applied. More...
enum class	ConvolutionOperation : uint8_t {   DIRECT_CONVOLUTION , CROSS_CORRELATION , MATCHED_FILTER , DECONVOLUTION ,   AUTO_CORRELATION }
	Specific convolution operations supported. More...
enum class	EnergyLevel : uint8_t {   SILENT , QUIET , MODERATE , LOUD ,   PEAK }
	Qualitative classification of energy values. More...
enum class	EnergyMethod : uint8_t {   RMS , PEAK , SPECTRAL , ZERO_CROSSING ,   HARMONIC , POWER , DYNAMIC_RANGE }
	Supported energy computation methods. More...
enum class	ExecutionMode : uint8_t {   SYNC , ASYNC , PARALLEL , CHAINED ,   CHAINED_INDIRECT , DEPENDENCY }
	Execution paradigms for operations. More...
enum class	ExecutionPolicy : uint8_t { CONSERVATIVE , BALANCED , AGGRESSIVE }
	Policy for execution strategy selection. More...
enum class	ExtractionMethod : uint8_t {   HIGH_ENERGY_DATA , PEAK_DATA , OUTLIER_DATA , HIGH_SPECTRAL_DATA ,   ABOVE_MEAN_DATA , OVERLAPPING_WINDOWS , ZERO_CROSSING_DATA , SILENCE_DATA ,   ONSET_DATA }
	Supported extraction methods for FeatureExtractor. More...
enum class	ExtractionScope : uint8_t { FULL_DATA , TARGETED_REGIONS , FILTERED_CONTENT , SAMPLED_DATA }
	Scope control for extraction operations. More...
enum class	ExtractionType : uint8_t {   DIRECT , REGION_BASED , FEATURE_GUIDED , PATTERN_BASED ,   TRANSFORM , RECURSIVE , CUSTOM }
	Categories of extraction operations for discovery and organization. More...
enum class	MathematicalOperation : uint8_t {   GAIN , OFFSET , POWER , LOGARITHMIC ,   EXPONENTIAL , TRIGONOMETRIC , QUANTIZE , NORMALIZE ,   POLYNOMIAL }
	Specific mathematical operations supported. More...
enum class	OperationType : uint8_t {   ANALYZER , SORTER , EXTRACTOR , TRANSFORMER ,   CUSTOM }
	Operation categories for organization and discovery. More...
enum class	SortingGranularity : uint8_t { RAW_DATA , ATTRIBUTED_INDICES , ORGANIZED_GROUPS , DETAILED_ANALYSIS }
	Output granularity control for sorting results. More...
enum class	SortingStrategy : uint8_t {   IN_PLACE , COPY_SORT , INDEX_ONLY , PARTIAL_SORT ,   LAZY_SORT , CHUNKED_SORT , PARALLEL_SORT }
	Sorting execution strategies. More...
enum class	SortingType : uint8_t {   STANDARD , ALGORITHMIC , PATTERN_BASED , TEMPORAL ,   SPATIAL , PREDICTIVE , CROSS_MODAL , RECURSIVE ,   CUSTOM }
	Categories of sorting operations for discovery and organization. More...
enum class	SpectralOperation : uint8_t {   FREQUENCY_SHIFT , PITCH_SHIFT , SPECTRAL_FILTER , HARMONIC_ENHANCE ,   SPECTRAL_GATE }
	Spectral operations supported by SpectralTransformer. More...
enum class	StatisticalLevel : uint8_t {   EXTREME_LOW , LOW , NORMAL , HIGH ,   EXTREME_HIGH , OUTLIER }
	Qualitative classification of statistical values. More...
enum class	StatisticalMethod : uint8_t {   MEAN , VARIANCE , STD_DEV , SKEWNESS ,   KURTOSIS , MIN , MAX , MEDIAN ,   RANGE , PERCENTILE , MODE , MAD ,   CV , SUM , COUNT , RMS ,   ENTROPY , ZSCORE }
	Supported statistical computation methods. More...
enum class	TemporalOperation : uint8_t {   TIME_REVERSE , TIME_STRETCH , DELAY , FADE_IN_OUT ,   SLICE , INTERPOLATE }
	Specific temporal operations supported. More...
enum class	TransformationQuality : uint8_t {   DRAFT , STANDARD , HIGH_QUALITY , REFERENCE ,   ADAPTIVE }
	Quality vs performance trade-off control. More...
enum class	TransformationScope : uint8_t { FULL_DATA , TARGETED_REGIONS , SELECTIVE_BANDS , CONDITIONAL }
	Scope control for transformation operations. More...
enum class	TransformationStrategy : uint8_t {   IN_PLACE , BUFFERED , STREAMING , INCREMENTAL ,   LAZY , CHUNKED , PARALLEL , RECURSIVE }
	Transformation execution strategies. More...
enum class	TransformationType : uint8_t {   TEMPORAL , SPECTRAL , MATHEMATICAL , CROSS_MODAL ,   GENERATIVE , SPATIAL , PATTERN_BASED , RECURSIVE ,   GRANULAR , CONVOLUTION , CUSTOM }
	Categories of transformation operations for discovery and organization. More...
enum class	VisionExtractionMode : uint8_t { BBOX , CONTOUR_TIGHT , CONTOUR_MASKED }
	Selects the spatial mask used to crop pixels from a container. More...
enum class	VisionSortKey : uint8_t {   AREA , PERIMETER , CENTROID_X , CENTROID_Y ,   WIDTH , HEIGHT }
	Named scalar attributes on vision detection results used as sort keys. More...

Functions
template<typename OperationType >
void	apply_context_parameters (std::shared_ptr< OperationType > operation, const ExecutionContext &ctx)
	Applies context parameters to an operation.
template<ComputeData T>
std::vector< Datum< T > >	as_io_batch (const std::vector< T > &inputs)
	Convert a vector of raw values into a vector of Datum wrappers.
template<ComputeData T>
std::vector< Datum< T > >	as_io_batch (std::vector< T > &&inputs)
	Convert a vector of raw values into a vector of Datum wrappers via move.
std::vector< GpuBufferBinding >	bindings_from_spec (const Portal::Graphics::ShaderSpec &spec)
	Derive a GpuBufferBinding list from a ShaderSpec.
GpuComputeConfig	config_from_spec (const Portal::Graphics::ShaderSpec &spec)
	Derive a GpuComputeConfig from a ShaderSpec.
template<typename OperationType , typename... Args>
std::shared_ptr< OperationType >	create_configured_operation (const std::unordered_map< std::string, std::any > &parameters, Args &&... args)
	Creates an operation instance with parameters using safe_any_cast system.
template<typename T >
auto	create_multi_key_comparator (const std::vector< SortKey > &keys)
	Creates a multi-key comparator for complex sorting.
template<typename T >
SortKey	create_universal_sort_key (const std::string &name, SortingDirection direction=SortingDirection::ASCENDING)
	Create universal sort key extractor for common data types.
template<OperationReadyData DataType>
std::vector< Kakshya::Region >	detect_regions_by_energy (const DataType &input, double energy_threshold, uint32_t min_region_size, uint32_t window_size, uint32_t hop_size)
	Detect regions based on energy threshold using existing EnergyAnalyzer.
std::vector< std::vector< double > >	extract_above_mean (const std::vector< std::span< const double > > &channels, double mean_multiplier, uint32_t window_size, uint32_t hop_size)
std::vector< std::vector< double > >	extract_high_energy (const std::vector< std::span< const double > > &channels, double energy_threshold, uint32_t window_size, uint32_t hop_size)
std::vector< std::vector< double > >	extract_high_spectral (const std::vector< std::span< const double > > &channels, double spectral_threshold, uint32_t window_size, uint32_t hop_size)
std::vector< std::vector< double > >	extract_onsets (const std::vector< std::span< const double > > &channels, double threshold, uint32_t region_size, uint32_t fft_window_size, uint32_t hop_size)
std::vector< std::vector< double > >	extract_outliers (const std::vector< std::span< const double > > &channels, double std_dev_threshold, uint32_t window_size, uint32_t hop_size)
std::vector< std::vector< double > >	extract_overlapping_windows (const std::vector< std::span< const double > > &channels, uint32_t window_size, double overlap)
std::vector< std::vector< double > >	extract_peaks (const std::vector< std::span< const double > > &channels, double threshold, double min_distance, uint32_t region_size)
MAYAFLUX_API double	extract_scalar_energy (const EnergyAnalysis &analysis, const std::string &qualifier)
	Extract a named scalar from an EnergyAnalysis result.
MAYAFLUX_API double	extract_scalar_statistics (const StatisticalAnalysis &analysis, const std::string &qualifier)
	Extract a named scalar from a StatisticalAnalysis result.
double	extract_scalar_vision (const VisionAnalysis &analysis, const std::string &qualifier)
	Extract a named scalar from a VisionAnalysis result.
std::vector< std::vector< double > >	extract_silence (const std::vector< std::span< const double > > &channels, double silence_threshold, uint32_t min_duration, uint32_t window_size, uint32_t hop_size)
std::vector< std::vector< double > >	extract_zero_crossings (const std::vector< std::span< const double > > &channels, double threshold, double min_distance, uint32_t region_size)
template<ComputeData T>
std::vector< std::vector< size_t > >	generate_compute_data_indices (const Datum< T > &data, SortingDirection direction)
	Generate sort indices for any ComputeData type.
std::shared_ptr< OperationRegistry >	get_operation_registry ()
	Global operation registry accessor Similar to how Engine provides global access to core systems.
template<typename T >
double	get_temporal_position (const T &item)
	Helper function to get temporal position from various types Used by TemporalSortable concept.
std::pair< std::vector< Kakshya::DataDimension >, Kakshya::DataModality >	infer_from_container (const std::shared_ptr< Kakshya::SignalSourceContainer > &container)
	Infer structure from SignalSourceContainer.
std::pair< std::vector< Kakshya::DataDimension >, Kakshya::DataModality >	infer_from_data_variant (const Kakshya::DataVariant &data)
	Infer structure from DataVariant.
std::pair< std::vector< Kakshya::DataDimension >, Kakshya::DataModality >	infer_from_data_variant_vector (const std::vector< Kakshya::DataVariant > &data)
	Infer structure from vector of DataVariants (NEW)
template<typename EigenType >
static std::pair< std::vector< Kakshya::DataDimension >, Kakshya::DataModality >	infer_from_eigen (const EigenType &eigen_data)
	Infer structure from Eigen matrix/vector.
std::pair< std::vector< Kakshya::DataDimension >, Kakshya::DataModality >	infer_from_region (const Kakshya::Region &region, const std::shared_ptr< Kakshya::SignalSourceContainer > &container=nullptr)
	Infer structure from Region (placeholder since regions are markers)
std::pair< std::vector< Kakshya::DataDimension >, Kakshya::DataModality >	infer_from_region_group (const Kakshya::RegionGroup &group, const std::shared_ptr< Kakshya::SignalSourceContainer > &container=nullptr)
	Infer structure from RegionGroup.
std::pair< std::vector< Kakshya::DataDimension >, Kakshya::DataModality >	infer_from_segments (const std::vector< Kakshya::RegionSegment > &segments, const std::shared_ptr< Kakshya::SignalSourceContainer > &container=nullptr)
	Infer structure from RegionSegments.
template<typename T >
static std::pair< std::vector< Kakshya::DataDimension >, Kakshya::DataModality >	infer_generic_structure (const T &data)
	Generic structure inference for unknown types.
template<ComputeData T>
static std::pair< std::vector< Kakshya::DataDimension >, Kakshya::DataModality >	infer_structure (const T &data, const std::shared_ptr< Kakshya::SignalSourceContainer > &container=nullptr)
	Infer dimensions and modality from any ComputeData type.
template<typename Executor , ComputeData DataType>
auto	make_fluent (std::shared_ptr< Executor > executor, DataType &&data)
	Construct a FluentExecutor from raw data with type deduction (convenience entry point)
template<typename Executor , ComputeData DataType>
auto	make_fluent (std::shared_ptr< Executor > executor, Datum< DataType > &&datum)
	Construct a FluentExecutor from a Datum with type deduction.
template<ComputeData InputType = std::vector<Kakshya::DataVariant>, ComputeData OutputType = InputType>
std::shared_ptr< ShaderExecutionContext< InputType, OutputType > >	make_shader_executor (GpuComputeConfig config, std::vector< GpuBufferBinding > bindings, std::string name="ShaderExecutionContext")
	Convenience factory for ShaderExecutionContext.
template<ComputeData T>
T	sort_compute_data (const T &data, SortingDirection direction=SortingDirection::ASCENDING)
	Convenience function with default algorithm.
template<typename T >
T	sort_compute_data_extract (const Datum< T > &data, SortingDirection direction, SortingAlgorithm algorithm)
	Universal sort function - returns sorted copy.
template<ComputeData T>
T	sort_compute_data_extract (const T &data, SortingDirection direction, SortingAlgorithm algorithm)
	Universal sort function - returns sorted copy.
template<ComputeData T>
void	sort_compute_data_inplace (Datum< T > &data, SortingDirection direction, SortingAlgorithm algorithm)
	Universal sort function - handles extraction/conversion internally.
GpuBufferBinding::Direction	to_binding_direction (Portal::Graphics::BindingDirection d) noexcept
	Translate a BindingDirection to a GpuBufferBinding::Direction.
GpuBufferBinding::ElementType	to_element_type (Kakshya::DataModality m, Kakshya::GpuDataFormat fmt) noexcept
	Translate a BindingSlot modality to a GpuBufferBinding::ElementType.
template<OperationReadyData DataType, typename TransformFunc > requires std::invocable<TransformFunc, double>
DataType	transform_by_energy (DataType &input, double energy_threshold, TransformFunc transform_func, uint32_t window_size, uint32_t hop_size, std::vector< std::vector< double > > &working_buffer)
	Energy-based transformation using existing EnergyAnalyzer (OUT-OF-PLACE)
template<OperationReadyData DataType, typename TransformFunc > requires std::invocable<TransformFunc, double>
DataType	transform_by_energy (DataType &input, double energy_threshold, TransformFunc transform_func, uint32_t window_size=1024, uint32_t hop_size=512)
	Energy-based transformation using existing EnergyAnalyzer (IN-PLACE)
template<OperationReadyData DataType>
DataType	transform_channel_operation (DataType &input, uint32_t num_channels, bool interleave)
	Channel operations using C++20 ranges (IN-PLACE)
template<OperationReadyData DataType>
DataType	transform_channel_operation (DataType &input, uint32_t num_channels, bool interleave, std::vector< std::vector< double > > &working_buffer)
	Channel operations using C++20 ranges (OUT-OF-PLACE)
template<OperationReadyData DataType>
DataType	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<OperationReadyData DataType>
DataType	transform_crossfade_regions (DataType &input, const std::vector< std::pair< Kakshya::Region, Kakshya::Region > > &fade_regions, uint32_t fade_duration, std::vector< std::vector< double > > &working_buffer)
	Cross-fade between regions with smooth transitions (OUT-OF-PLACE)
template<OperationReadyData DataType>
DataType	transform_matrix (DataType &input, const Eigen::MatrixXd &transformation_matrix)
	Matrix transformation using existing infrastructure (IN-PLACE)
template<OperationReadyData DataType>
DataType	transform_matrix (DataType &input, const Eigen::MatrixXd &transformation_matrix, std::vector< std::vector< double > > &working_buffer)
	Matrix transformation using existing infrastructure (OUT-OF-PLACE)
template<OperationReadyData DataType>
DataType	transform_matrix_multichannel (DataType &input, const Eigen::MatrixXd &transformation_matrix, uint32_t num_channels)
	Multi-channel matrix transformation with error handling (IN-PLACE)
template<OperationReadyData DataType>
DataType	transform_matrix_multichannel (DataType &input, const Eigen::MatrixXd &transformation_matrix, uint32_t num_channels, std::vector< std::vector< double > > &working_buffer)
	Multi-channel matrix transformation with error handling (OUT-OF-PLACE)
template<OperationReadyData DataType, typename TransformFunc > requires std::invocable<TransformFunc, double>
DataType	transform_outliers (DataType &input, double std_dev_threshold, TransformFunc transform_func)
	Statistical outlier transformation using existing StatisticalAnalyzer (IN-PLACE)
template<OperationReadyData DataType, typename TransformFunc > requires std::invocable<TransformFunc, double>
DataType	transform_outliers (DataType &input, double std_dev_threshold, TransformFunc transform_func, std::vector< std::vector< double > > &working_buffer)
	Statistical outlier transformation using existing StatisticalAnalyzer (OUT-OF-PLACE)
template<OperationReadyData DataType, typename TransformFunc > requires std::invocable<TransformFunc, DataType>
DataType	transform_regions (DataType &input, const std::shared_ptr< Kakshya::SignalSourceContainer > &container, const std::vector< Kakshya::Region > &regions, TransformFunc transform_func)
	Region-selective transformation using container-based extraction (IN-PLACE)
template<OperationReadyData DataType, typename TransformFunc > requires std::invocable<TransformFunc, DataType>
DataType	transform_regions (DataType &input, const std::shared_ptr< Kakshya::SignalSourceContainer > &container, const std::vector< Kakshya::Region > &regions, TransformFunc transform_func, std::vector< std::vector< double > > &working_buffer)
	Region-selective transformation using container-based extraction (OUT-OF-PLACE)

Variables
template<typename T >
constexpr bool	is_eigen_matrix_v = is_eigen_matrix<T>::value