compute_grain_attribute()

double MayaFlux::Yantra::Granular::AttributeOp::compute_grain_attribute ( const Kakshya::Region &  grain, const std::shared_ptr< Kakshya::SignalSourceContainer > &  container, uint32_t  channel, const ExecutionContext &  ctx  ) const

private

Resolve and execute attribution for a single grain.

Parameters

grain	Source region defining the grain boundaries.
container	Signal data source.
channel	Channel index to extract samples from.
ctx	Current execution context carrying parameters.

Returns

Scalar attribute value for this grain.

Definition at line 480 of file GranularWorkflow.cpp.

{
    AttributeExecutor exec;
 
    if (ctx.execution_metadata.contains("attribute_executor")) {
        exec = safe_any_cast_or_default<AttributeExecutor>(
            ctx.execution_metadata.at("attribute_executor"), nullptr);
    }
 
    if (!exec) {
        if (auto p = this->get_parameter("attribute_executor"); p.has_value())
            exec = safe_any_cast_or_default<AttributeExecutor>(p, nullptr);
    }
 
    if (exec) {
        const auto samples = Kakshya::extract_region_channel(grain, container, channel);
        return exec(std::span<const double>(samples.data(), samples.size()), ctx);
    }
 
    const auto grain_variants = container->get_region_data(grain);
 
    const std::string qualifier = [&]() -> std::string {
        if (ctx.execution_metadata.contains("analyzer_qualifier")) {
            return safe_any_cast_or_default<std::string>(
                ctx.execution_metadata.at("analyzer_qualifier"), {});
        }
        auto p = this->get_parameter("analyzer_qualifier");
        return p.has_value() ? safe_any_cast_or_default<std::string>(p, {}) : std::string {};
    }();
 
    const AnalysisType type = [&]() {
        if (ctx.execution_metadata.contains("analysis_type")) {
            return safe_any_cast_or_default<AnalysisType>(
                ctx.execution_metadata.at("analysis_type"), AnalysisType::FEATURE);
        }
 
        auto p = this->get_parameter("analysis_type");
        return p.has_value()
            ? safe_any_cast_or_default<AnalysisType>(p, AnalysisType::FEATURE)
            : AnalysisType::FEATURE;
    }();
 
    std::shared_ptr<void> raw_analyzer;
    if (ctx.execution_metadata.contains("analyzer")) {
        raw_analyzer = safe_any_cast_or_default<std::shared_ptr<void>>(
            ctx.execution_metadata.at("analyzer"), nullptr);
    }
 
    if (!raw_analyzer) {
        if (auto p = this->get_parameter("analyzer"); p.has_value())
            raw_analyzer = safe_any_cast_or_default<std::shared_ptr<void>>(p, nullptr);
    }
 
    if (raw_analyzer) {
        if (type == AnalysisType::FEATURE) {
            return extract_scalar_energy(
                std::static_pointer_cast<VariantEnergyAnalyzer<>>(raw_analyzer)
                    ->analyze_energy(grain_variants),
                qualifier);
        }
 
        if (type == AnalysisType::STATISTICAL) {
            return extract_scalar_statistics(
                std::static_pointer_cast<VariantStatisticalAnalyzer<>>(raw_analyzer)
                    ->analyze_statistics(grain_variants),
                qualifier);
        }
        return 0.0;
    }
 
    if (type == AnalysisType::FEATURE) {
        return extract_scalar_energy(
            m_energy_analyzer.analyze_energy(grain_variants), qualifier);
    }
 
    if (type == AnalysisType::STATISTICAL) {
        return extract_scalar_statistics(
            m_stat_analyzer.analyze_statistics(grain_variants), qualifier);
    }
 
    return 0.0;
}

References MayaFlux::Yantra::EnergyAnalyzer< InputType, OutputType >::analyze_energy(), MayaFlux::Yantra::StatisticalAnalyzer< InputType, OutputType >::analyze_statistics(), channel, MayaFlux::Yantra::ExecutionContext::execution_metadata, MayaFlux::Kakshya::extract_region_channel(), MayaFlux::Yantra::extract_scalar_energy(), MayaFlux::Yantra::extract_scalar_statistics(), MayaFlux::Yantra::FEATURE, MayaFlux::Yantra::UniversalAnalyzer< InputType, OutputType >::get_parameter(), m_energy_analyzer, m_stat_analyzer, and MayaFlux::Yantra::STATISTICAL.

Referenced by analyze_implementation().

Here is the call graph for this function:

Here is the caller graph for this function: