Yantra.cpp File Reference

#include "Yantra.hpp"
#include "MayaFlux/Nodes/Generators/WindowGenerator.hpp"
#include "MayaFlux/Yantra/Analyzers/EnergyAnalyzer.hpp"
#include "MayaFlux/Yantra/Analyzers/StatisticalAnalyzer.hpp"
#include "MayaFlux/Yantra/Extractors/FeatureExtractor.hpp"
#include "MayaFlux/Yantra/Transformers/MathematicalTransformer.hpp"
#include "MayaFlux/Yantra/Transformers/TemporalTransformer.hpp"

Include dependency graph for Yantra.cpp:

Go to the source code of this file.

Namespaces
namespace	MayaFlux
	Main namespace for the Maya Flux audio engine.

Functions
static bool	MayaFlux::is_same_size (const std::vector< std::span< double > > &data)
static std::vector< double >	MayaFlux::concat_vectors (const std::vector< std::span< double > > &data)
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.
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.