Loading...
Searching...
No Matches
Yantra.hpp File Reference
Data analysis and transformation convenience API. More...
#include "MayaFlux/Kakshya/NDData/NDData.hpp"
Include dependency graph for Yantra.hpp:
This graph shows which files directly or indirectly include this file:
Go to the source code of this file.
Classes | |
| struct | MayaFlux::MultiChannelFeatures |
| Multi-channel feature analysis result. More... | |
Namespaces | |
| namespace | MayaFlux |
| Main namespace for the Maya Flux audio engine. | |
Functions | |
| double | MayaFlux::mean (const std::vector< double > &data) |
| Calculate mean of single-channel data. | |
| double | MayaFlux::mean (const Kakshya::DataVariant &data) |
| std::vector< double > | MayaFlux::mean_per_channel (const std::vector< Kakshya::DataVariant > &channels) |
| Calculate mean per channel for multi-channel data. | |
| double | MayaFlux::mean_combined (const std::vector< Kakshya::DataVariant > &channels) |
| Calculate mean across all channels (mix then analyze) | |
| double | MayaFlux::rms (const std::vector< double > &data) |
| Calculate RMS (Root Mean Square) energy of single-channel data. | |
| double | MayaFlux::rms (const Kakshya::DataVariant &data) |
| std::vector< double > | MayaFlux::rms_per_channel (const std::vector< Kakshya::DataVariant > &channels) |
| Calculate RMS energy per channel for multi-channel data. | |
| double | MayaFlux::rms_combined (const std::vector< Kakshya::DataVariant > &channels) |
| Calculate RMS energy across all channels (mix then analyze) | |
| double | MayaFlux::std_dev (const std::vector< double > &data) |
| Calculate standard deviation of single-channel data. | |
| double | MayaFlux::std_dev (const Kakshya::DataVariant &data) |
| std::vector< double > | MayaFlux::std_dev_per_channel (const std::vector< Kakshya::DataVariant > &channels) |
| Calculate standard deviation per channel for multi-channel data. | |
| double | MayaFlux::std_dev_combined (const std::vector< Kakshya::DataVariant > &channels) |
| Calculate standard deviation across all channels (mix then analyze) | |
| double | MayaFlux::dynamic_range (const std::vector< double > &data) |
| Calculate dynamic range (max/min ratio in dB) of single-channel data. | |
| double | MayaFlux::dynamic_range (const Kakshya::DataVariant &data) |
| std::vector< double > | MayaFlux::dynamic_range_per_channel (const std::vector< Kakshya::DataVariant > &channels) |
| Calculate dynamic range per channel for multi-channel data. | |
| double | MayaFlux::dynamic_range_global (const std::vector< Kakshya::DataVariant > &channels) |
| Calculate dynamic range across all channels (global min/max) | |
| double | MayaFlux::peak (const std::vector< double > &data) |
| Find peak amplitude in single-channel data. | |
| double | MayaFlux::peak (const Kakshya::DataVariant &data) |
| double | MayaFlux::peak (const std::vector< Kakshya::DataVariant > &channels) |
| Find peak amplitude across all channels (global peak) | |
| std::vector< double > | MayaFlux::peak_per_channel (const std::vector< Kakshya::DataVariant > &channels) |
| Find peak amplitude per channel for multi-channel data. | |
| double | MayaFlux::peak_channel (const std::vector< Kakshya::DataVariant > &channels, size_t channel_index) |
| Find peak amplitude in specific channel. | |
| std::vector< size_t > | MayaFlux::zero_crossings (const std::vector< double > &data, double threshold=0.0) |
| Detect zero crossings in single-channel signal. | |
| std::vector< size_t > | MayaFlux::zero_crossings (const Kakshya::DataVariant &data, double threshold) |
| std::vector< std::vector< size_t > > | MayaFlux::zero_crossings_per_channel (const std::vector< Kakshya::DataVariant > &channels, double threshold=0.0) |
| Detect zero crossings per channel for multi-channel signal. | |
| double | MayaFlux::zero_crossing_rate (const std::vector< double > &data, size_t window_size=0) |
| Calculate zero crossing rate for single-channel data. | |
| double | MayaFlux::zero_crossing_rate (const Kakshya::DataVariant &data, size_t window_size) |
| std::vector< double > | MayaFlux::zero_crossing_rate_per_channel (const std::vector< Kakshya::DataVariant > &channels, size_t window_size=0) |
| Calculate zero crossing rate per channel for multi-channel data. | |
| double | MayaFlux::spectral_centroid (const std::vector< double > &data, double sample_rate=48000.0) |
| Find spectral centroid (brightness measure) for single-channel data. | |
| double | MayaFlux::spectral_centroid (const Kakshya::DataVariant &data, double sample_rate) |
| std::vector< double > | MayaFlux::spectral_centroid_per_channel (const std::vector< Kakshya::DataVariant > &channels, double sample_rate=48000.0) |
| Find spectral centroid per channel for multi-channel data. | |
| std::vector< double > | MayaFlux::detect_onsets (const std::vector< double > &data, double sample_rate=48000.0, double threshold=0.1) |
| Detect onset times in single-channel signal. | |
| std::vector< double > | MayaFlux::detect_onsets (const Kakshya::DataVariant &data, double sample_rate, double threshold) |
| std::vector< std::vector< double > > | MayaFlux::detect_onsets_per_channel (const std::vector< Kakshya::DataVariant > &channels, double sample_rate=48000.0, double threshold=0.1) |
| Detect onset times per channel for multi-channel signal. | |
| MAYAFLUX_API Kakshya::DataVariant | MayaFlux::mix_to_mono (const std::vector< Kakshya::DataVariant > &channels) |
| Mix multi-channel data to mono using equal weighting. | |
| MAYAFLUX_API std::pair< Kakshya::DataVariant, Kakshya::DataVariant > | MayaFlux::stereo_to_mid_side (const std::vector< Kakshya::DataVariant > &lr_channels) |
| Convert stereo L/R channels to Mid/Side format. | |
| MAYAFLUX_API std::pair< Kakshya::DataVariant, Kakshya::DataVariant > | MayaFlux::mid_side_to_stereo (const std::vector< Kakshya::DataVariant > &ms_channels) |
| Convert Mid/Side channels to stereo L/R format. | |
| MAYAFLUX_API double | MayaFlux::stereo_width (const std::vector< Kakshya::DataVariant > &lr_channels) |
| Calculate stereo width measure for L/R channels. | |
| MAYAFLUX_API std::vector< double > | MayaFlux::channel_correlation_matrix (const std::vector< Kakshya::DataVariant > &channels) |
| Calculate correlation matrix between all channel pairs. | |
| MAYAFLUX_API double | MayaFlux::phase_correlation (const Kakshya::DataVariant &channel1, const Kakshya::DataVariant &channel2) |
| Calculate phase correlation between two channels. | |
| MAYAFLUX_API MultiChannelFeatures | MayaFlux::analyze_channels (const std::vector< Kakshya::DataVariant > &channels) |
| Comprehensive multi-channel analysis in single operation. | |
| void | MayaFlux::apply_gain (std::vector< double > &data, double gain_factor) |
| Apply gain to single-channel data (in-place) | |
| void | MayaFlux::apply_gain (Kakshya::DataVariant &data, double gain_factor) |
| void | MayaFlux::apply_gain_channels (std::vector< Kakshya::DataVariant > &channels, double gain_factor) |
| Apply gain to multi-channel data (in-place) | |
| void | MayaFlux::apply_gain_per_channel (std::vector< Kakshya::DataVariant > &channels, const std::vector< double > &gain_factors) |
| Apply different gain to each channel (in-place) | |
| std::vector< double > | MayaFlux::with_gain (const std::vector< double > &data, double gain_factor) |
| Apply gain to single-channel data (non-destructive) | |
| Kakshya::DataVariant | MayaFlux::with_gain (const Kakshya::DataVariant &data, double gain_factor) |
| std::vector< Kakshya::DataVariant > | MayaFlux::with_gain_channels (const std::vector< Kakshya::DataVariant > &channels, double gain_factor) |
| Apply gain to multi-channel data (non-destructive) | |
| void | MayaFlux::normalize (std::vector< double > &data, double target_peak=1.0) |
| Normalize single-channel data to specified peak level (in-place) | |
| void | MayaFlux::normalize (Kakshya::DataVariant &data, double target_peak) |
| void | MayaFlux::normalize_channels (std::vector< Kakshya::DataVariant > &channels, double target_peak=1.0) |
| Normalize each channel independently to specified peak level (in-place) | |
| void | MayaFlux::normalize_together (std::vector< Kakshya::DataVariant > &channels, double target_peak=1.0) |
| Normalize multi-channel data relative to global peak (in-place) | |
| std::vector< double > | MayaFlux::normalized (const std::vector< double > &data, double target_peak=1.0) |
| Normalize single-channel data (non-destructive) | |
| Kakshya::DataVariant | MayaFlux::normalized (const Kakshya::DataVariant &data, double target_peak) |
| std::vector< Kakshya::DataVariant > | MayaFlux::normalized_channels (const std::vector< Kakshya::DataVariant > &channels, double target_peak=1.0) |
| Normalize each channel independently (non-destructive) | |
| void | MayaFlux::reverse (std::vector< double > &data) |
| Reverse time order of single-channel data (in-place) | |
| void | MayaFlux::reverse (Kakshya::DataVariant &data) |
| void | MayaFlux::reverse_channels (std::vector< Kakshya::DataVariant > &channels) |
| Reverse time order of multi-channel data (in-place) | |
| std::vector< double > | MayaFlux::reversed (const std::vector< double > &data) |
| Reverse time order of single-channel data (non-destructive) | |
| Kakshya::DataVariant | MayaFlux::reversed (const Kakshya::DataVariant &data) |
| std::vector< Kakshya::DataVariant > | MayaFlux::reversed_channels (const std::vector< Kakshya::DataVariant > &channels) |
| Reverse time order of multi-channel data (non-destructive) | |
| std::vector< double > | MayaFlux::magnitude_spectrum (const std::vector< double > &data, size_t window_size=0) |
| Compute magnitude spectrum for single-channel data. | |
| std::vector< double > | MayaFlux::magnitude_spectrum (const Kakshya::DataVariant &data, size_t window_size) |
| std::vector< std::vector< double > > | MayaFlux::magnitude_spectrum_per_channel (const std::vector< Kakshya::DataVariant > &channels, size_t window_size=0) |
| Compute magnitude spectrum per channel for multi-channel data. | |
| std::vector< double > | MayaFlux::power_spectrum (const std::vector< double > &data, size_t window_size=0) |
| Compute power spectrum for single-channel data. | |
| std::vector< double > | MayaFlux::power_spectrum (const Kakshya::DataVariant &data, size_t window_size) |
| std::vector< std::vector< double > > | MayaFlux::power_spectrum_per_channel (const std::vector< Kakshya::DataVariant > &channels, size_t window_size=0) |
| Compute power spectrum per channel for multi-channel data. | |
| double | MayaFlux::estimate_pitch (const std::vector< double > &data, double sample_rate=48000.0, double min_freq=80.0, double max_freq=2000.0) |
| Estimate fundamental frequency using autocorrelation for single-channel data. | |
| double | MayaFlux::estimate_pitch (const Kakshya::DataVariant &data, double sample_rate, double min_freq, double max_freq) |
| std::vector< double > | MayaFlux::estimate_pitch_per_channel (const std::vector< Kakshya::DataVariant > &channels, double sample_rate=48000.0, double min_freq=80.0, double max_freq=2000.0) |
| Estimate fundamental frequency per channel for multi-channel data. | |
| std::vector< double > | MayaFlux::extract_silent_data (const std::vector< double > &data, double threshold, size_t min_silence_duration) |
| Extract silent regions from single-channel data. | |
| std::vector< double > | MayaFlux::extract_silent_data (const Kakshya::DataVariant &data, double threshold, size_t min_silence_duration) |
| std::vector< double > | MayaFlux::extract_zero_crossing_regions (const std::vector< double > &data, double threshold, size_t region_size) |
| Extract zero crossing regions from single-channel data. | |
| std::vector< double > | MayaFlux::extract_zero_crossing_regions (const Kakshya::DataVariant &data, double threshold, size_t region_size) |
| void | MayaFlux::apply_window (std::vector< double > &data, const std::string &window_type="hann") |
| Apply window function to single-channel data (in-place) | |
| void | MayaFlux::apply_window (Kakshya::DataVariant &data, const std::string &window_type) |
| void | MayaFlux::apply_window_channels (std::vector< Kakshya::DataVariant > &channels, const std::string &window_type="hann") |
| Apply window function to multi-channel data (in-place) | |
| std::vector< std::vector< double > > | MayaFlux::windowed_segments (const std::vector< double > &data, size_t window_size, size_t hop_size) |
| Split single-channel data into overlapping windows. | |
| std::vector< std::vector< double > > | MayaFlux::windowed_segments (const Kakshya::DataVariant &data, size_t window_size, size_t hop_size) |
| std::vector< std::vector< std::vector< double > > > | MayaFlux::windowed_segments_per_channel (const std::vector< Kakshya::DataVariant > &channels, size_t window_size, size_t hop_size) |
| Split multi-channel data into overlapping windows per channel. | |
| std::vector< std::pair< size_t, size_t > > | MayaFlux::detect_silence (const std::vector< double > &data, double threshold=0.01, size_t min_silence_duration=1024) |
| Detect silence regions in single-channel data. | |
| std::vector< std::pair< size_t, size_t > > | MayaFlux::detect_silence (const Kakshya::DataVariant &data, double threshold, size_t min_silence_duration) |
| std::vector< std::vector< std::pair< size_t, size_t > > > | MayaFlux::detect_silence_per_channel (const std::vector< Kakshya::DataVariant > &channels, double threshold=0.01, size_t min_silence_duration=1024) |
| Detect silence regions per channel for multi-channel data. | |
| std::vector< double > | MayaFlux::mix (const std::vector< std::vector< double > > &streams) |
| Mix multiple data streams with equal weighting. | |
| std::vector< double > | MayaFlux::mix (const std::vector< Kakshya::DataVariant > &streams) |
| std::vector< double > | MayaFlux::mix_with_gains (const std::vector< std::vector< double > > &streams, const std::vector< double > &gains) |
| Mix multiple data streams with specified gains. | |
| std::vector< double > | MayaFlux::mix_with_gains (const std::vector< Kakshya::DataVariant > &streams, const std::vector< double > &gains) |
| std::vector< double > | MayaFlux::to_double_vector (const Kakshya::DataVariant &data) |
| Convert DataVariant to vector<double> if possible. | |
| Kakshya::DataVariant | MayaFlux::to_data_variant (const std::vector< double > &data) |
| Convert vector<double> to DataVariant. | |
| std::vector< std::vector< double > > | MayaFlux::to_double_vectors (const std::vector< Kakshya::DataVariant > &channels) |
| Convert multi-channel data to vector of double vectors. | |
| std::vector< Kakshya::DataVariant > | MayaFlux::to_data_variants (const std::vector< std::vector< double > > &channel_data) |
| Convert vector of double vectors to multi-channel DataVariant format. | |
| void | MayaFlux::initialize_yantra () |
| Initialize Yantra subsystem with default configuration. | |
Detailed Description
Data analysis and transformation convenience API.
This header provides high-level functions for common data analysis and transformation operations. These are simple, direct dispatch functions for immediate results. For complex, multi-stage, or grammar-driven processing, use ComputePipeline, ComputeGrammar, or the full Yantra operation classes directly.
Design Philosophy:
- Simple input → simple output functions
- Work with concrete types: std::vector<double>, DataVariant, and multi-channel data
- Support both single-channel and multi-channel workflows
- Common audio/signal analysis tasks with sensible multi-channel behavior
- Immediate execution (no deferred/lazy evaluation)
- Reasonable defaults for parameters
- Progressive enhancement: existing single-channel functions remain unchanged
Definition in file Yantra.hpp.
