🥮 mooncakes.io
    Sign in

    python123-ops/moon-cv-geometry/ransac does not have a README file

    AdaptiveConsensus

    source
    pub(all) struct AdaptiveConsensus {
      ratio : Double
      threshold : Double
      iterations : Int
    }

    AdaptiveConsensus::iterations

    source
    fn AdaptiveConsensus::iterations(state : AdaptiveConsensus) -> Int

    AdaptiveConsensus::new

    source
    fn AdaptiveConsensus::new(threshold~ : Double) -> AdaptiveConsensus

    AdaptiveConsensus::ratio

    source
    fn AdaptiveConsensus::ratio(state : AdaptiveConsensus) -> Double

    AdaptiveConsensus::should_stop

    source
    fn AdaptiveConsensus::should_stop(state : AdaptiveConsensus, minimum_ratio : Double, minimum_iterations : Int) -> Bool

    AdaptiveConsensus::update

    source
    fn AdaptiveConsensus::update(state : AdaptiveConsensus, residuals : ArrayView[Double]) -> Unit

    AdaptiveStopState

    source
    pub(all) struct AdaptiveStopState {
      minimum_iterations : Int
      target_ratio : Double
      iterations : Int
      best_ratio : Double
      stable_iterations : Int
    } derive(Eq, 
    Debug    )

    Running consensus state for early stopping and budget control.

    AdaptiveStopState::is_stable

    source
    fn AdaptiveStopState::is_stable(state : AdaptiveStopState, minimum_repetitions : Int) -> Bool

    AdaptiveStopState::new

    source
    fn AdaptiveStopState::new(minimum_iterations~ : Int, target_ratio~ : Double) -> AdaptiveStopState

    AdaptiveStopState::observe

    source
    fn AdaptiveStopState::observe(state : AdaptiveStopState, inliers~ : Int, total~ : Int) -> Unit

    AdaptiveStopState::progress

    source
    fn AdaptiveStopState::progress(state : AdaptiveStopState, maximum_iterations : Int) -> Double

    AdaptiveStopState::remaining

    source
    fn AdaptiveStopState::remaining(state : AdaptiveStopState, maximum_iterations : Int) -> Int

    AdaptiveStopState::should_stop

    source
    fn AdaptiveStopState::should_stop(state : AdaptiveStopState) -> Bool

    ConsensusCandidate2

    source
    pub(all) struct ConsensusCandidate2 {
      inliers : Int
      total : Int
      ratio : Double
      score : Double
      residual_sum : Double
      threshold : Double
    } derive(Eq, 
    Debug    )

    Candidate consensus summary used for deterministic model ranking.

    ConsensusRecord

    source
    pub(all) struct ConsensusRecord {
      inlier_count : Int
      score : Double
      residual_sum : Double
    } derive(Eq, 
    Debug    )

    Ranked consensus record for repeated model evaluation.

    ConsensusReport

    source
    pub(all) struct ConsensusReport {
      total : Int
      inliers : Int
      ratio : Double
      mean_inlier_error : Double
      max_inlier_error : Double
    } derive(Eq, 
    Debug    )

    ConsensusReport::acceptable

    source
    fn ConsensusReport::acceptable(report : ConsensusReport, minimum_ratio~ : Double, maximum_mean_error~ : Double) -> Bool

    ConsensusReport::summary_score

    source
    fn ConsensusReport::summary_score(report : ConsensusReport) -> Double

    ConsensusTable

    source
    pub(all) struct ConsensusTable {
      threshold : Double
      records : Array[ConsensusRecord]
    }

    ConsensusTable::best_inlier_count

    source
    fn ConsensusTable::best_inlier_count(table : ConsensusTable) -> Int

    ConsensusTable::best_record

    source
    fn ConsensusTable::best_record(table : ConsensusTable) -> ConsensusRecord?

    ConsensusTable::best_score

    source
    fn ConsensusTable::best_score(table : ConsensusTable) -> Double

    ConsensusTable::clear

    source
    fn ConsensusTable::clear(table : ConsensusTable) -> Unit

    ConsensusTable::evaluated_models

    source
    fn ConsensusTable::evaluated_models(table : ConsensusTable) -> Int

    ConsensusTable::new

    source
    fn ConsensusTable::new(threshold~ : Double) -> ConsensusTable

    ConsensusTable::observe

    source
    fn ConsensusTable::observe(table : ConsensusTable, residuals : ArrayView[Double]) -> Unit

    DeterministicSampler

    source
    pub(all) struct DeterministicSampler {
      state : Int
    }

    A small deterministic integer generator for reproducible RANSAC sampling.

    DeterministicSampler::new

    source

    DeterministicSampler::next

    source
    fn DeterministicSampler::next(sampler : DeterministicSampler, bound : Int) -> Int

    DiagnosticReport

    source
    pub(all) struct DiagnosticReport {
      total : Int
      inliers : Int
      outliers : Int
      inlier_ratio : Double
      mean_inlier : Double
      rms : Double
      maximum : Double
      label : String
    } derive(Eq, 
    Debug    )

    Detailed diagnostics for a residual consensus set.

    InlierMask

    source
    pub(all) struct InlierMask {
      values : Array[Bool]
    } derive(Eq, 
    Debug    )

    InlierMask::count

    source
    fn InlierMask::count(mask : InlierMask) -> Int

    InlierMask::indices

    source
    fn InlierMask::indices(mask : InlierMask) -> Array[Int]

    InlierMask::is_inlier

    source

    InlierMask::length

    source
    fn InlierMask::length(mask : InlierMask) -> Int

    IterationSchedule

    source
    pub(all) struct IterationSchedule {
      max_iterations : Int
      confidence : Double
    }

    IterationSchedule::limit_for

    source
    fn IterationSchedule::limit_for(schedule : IterationSchedule, inlier_ratio : Double, sample_size : Int) -> Int

    IterationSchedule::new

    source
    fn IterationSchedule::new(max_iterations~ : Int, confidence~ : Double) -> IterationSchedule

    IterationSchedule::progress

    source
    fn IterationSchedule::progress(schedule : IterationSchedule, iteration~ : Int, observed_inlier_ratio~ : Double, sample_size~ : Int) -> ScheduleProgress

    MlesacConfig

    source
    pub(all) struct MlesacConfig {
      inlier_scale : Double
      outlier_scale : Double
    } derive(Eq, 
    Debug    )

    MlesacConfig::new

    source
    fn MlesacConfig::new(inlier_scale~ : Double, outlier_scale~ : Double) -> MlesacConfig

    MlesacConfig::valid

    source
    fn MlesacConfig::valid(config : MlesacConfig) -> Bool

    ModelReport

    source
    pub(all) struct ModelReport {
      iterations : Int
      inliers : Int
      total : Int
      ratio : Double
      score : Double
      converged : Bool
    } derive(Eq, 
    Debug    )

    Human- and machine-readable summary for an estimated model.

    ModelReport::confidence

    source
    fn ModelReport::confidence(report : ModelReport) -> Double

    ModelReport::is_usable

    source
    fn ModelReport::is_usable(report : ModelReport, minimum_ratio : Double, minimum_inliers : Int) -> Bool

    ModelSelectionSummary

    source
    pub(all) struct ModelSelectionSummary {
      candidates : Int
      usable : Int
      best_index : Int
      best_score : Double
      mean_ratio : Double
      mean_iterations : Double
    } derive(Eq, 
    Debug    )

    Model-selection and audit helpers for production consensus pipelines.

    RansacConfig

    source
    pub(all) struct RansacConfig {
      iterations : Int
      threshold : Double
      min_inliers : Int
      seed : UInt
    } derive(Eq, 
    Debug    )

    RansacConfig::new

    source
    fn RansacConfig::new(iterations? : Int, threshold? : Double, min_inliers? : Int, seed? : UInt) -> RansacConfig

    RansacConfig::validated

    source

    RansacResult

    source
    pub(all) struct RansacResult[T] {
      model : T
      inliers : InlierMask
      inlier_count : Int
      score : Double
    } derive(Eq, 
    Debug    )

    RansacResult::inlier_ratio

    source
    fn[T] RansacResult::inlier_ratio(result : RansacResult[T]) -> Double

    RansacResult::is_confident

    source
    fn[T] RansacResult::is_confident(result : RansacResult[T], minimum_ratio? : Double) -> Bool

    RansacResult::outlier_count

    source
    fn[T] RansacResult::outlier_count(result : RansacResult[T]) -> Int

    SampleBatchSummary

    source
    pub(all) struct SampleBatchSummary {
      samples : Int
      dimensions : Int
      unique : Int
      duplicate_count : Int
      coverage : Double
      score : Double
    } derive(Eq, 
    Debug    )

    Deterministic sample-set diagnostics for reproducible RANSAC runs.

    ScheduleProgress

    source
    pub(all) struct ScheduleProgress {
      iteration : Int
      iterations_remaining : Int
      best_ratio : Double
      expected_success : Double
    } derive(Eq, 
    Debug    )

    ThresholdSweepResult

    source
    pub(all) struct ThresholdSweepResult {
      threshold : Double
      inliers : Int
      score : Double
    } derive(Eq, 
    Debug    )

    ThresholdSweepResult::acceptable

    source
    fn ThresholdSweepResult::acceptable(result : ThresholdSweepResult, total : Int, minimum_ratio~ : Double) -> Bool

    ThresholdSweepResult::ratio

    source
    fn ThresholdSweepResult::ratio(result : ThresholdSweepResult, total : Int) -> Double

    adaptive_budget_schedule

    source
    fn adaptive_budget_schedule(initial : Int, decay : Double, count : Int) -> Array[Int]

    adaptive_confidence

    source
    fn adaptive_confidence(ratio : Double, sample_size : Int, iterations : Int) -> Double

    adaptive_iteration_bound

    source
    fn adaptive_iteration_bound(inlier_ratio~ : Double, sample_size~ : Int, confidence? : Double) -> Int raise 
    GeometryError

    adaptive_required_iterations

    source
    fn adaptive_required_iterations(ratio : Double, sample_size : Int, target_confidence : Double, maximum : Int) -> Int

    adaptive_threshold

    source
    fn adaptive_threshold(residuals : ArrayView[Double], floor : Double, multiplier : Double) -> Double raise 
    GeometryError

    adaptive_threshold_schedule

    source
    fn adaptive_threshold_schedule(initial : Double, growth : Double, count : Int) -> Array[Double]

    best_model_report

    source
    fn best_model_report(reports : ArrayView[ModelReport]) -> ModelReport?

    better_result

    source
    fn[T] better_result(candidate : RansacResult[T], incumbent : RansacResult[T]) -> Bool

    candidate_inlier_residuals

    source
    fn candidate_inlier_residuals(candidate : ConsensusCandidate2, residuals : ArrayView[Double]) -> Array[Double]

    candidate_is_confident

    source
    fn candidate_is_confident(best : ConsensusCandidate2, second : ConsensusCandidate2, minimum_margin : Double) -> Bool

    candidate_margin

    source
    fn candidate_margin(best : ConsensusCandidate2, second : ConsensusCandidate2) -> Double

    candidate_mask

    source
    fn candidate_mask(candidate : ConsensusCandidate2, residuals : ArrayView[Double]) -> Array[Bool]

    candidate_outlier_residuals

    source
    fn candidate_outlier_residuals(candidate : ConsensusCandidate2, residuals : ArrayView[Double]) -> Array[Double]

    candidate_refined_threshold

    source
    fn candidate_refined_threshold(candidate : ConsensusCandidate2, residuals : ArrayView[Double], multiplier : Double, minimum : Double) -> Double raise 
    GeometryError

    candidate_score_per_point

    source
    fn candidate_score_per_point(candidate : ConsensusCandidate2) -> Double

    candidate_support_score

    source
    fn candidate_support_score(candidate : ConsensusCandidate2, expected_minimum : Int) -> Double

    cauchy_loss2

    source
    fn cauchy_loss2(residual : Double, scale : Double) -> Double

    cauchy_weight2

    source
    fn cauchy_weight2(residual : Double, scale : Double) -> Double

    clipped_residuals

    source
    fn clipped_residuals(residuals : ArrayView[Double], cutoff~ : Double) -> Array[Double]

    confidence_from_success

    source
    fn confidence_from_success(iterations~ : Int, success_probability~ : Double) -> Double raise 
    GeometryError

    consensus_candidate

    source
    fn consensus_candidate(residuals : ArrayView[Double], threshold : Double) -> ConsensusCandidate2

    consensus_candidate_better

    source
    fn consensus_candidate_better(left : ConsensusCandidate2, right : ConsensusCandidate2) -> Bool

    consensus_mask

    source
    fn consensus_mask(residuals : ArrayView[Double], threshold : Double) -> Array[Bool]

    consensus_ratio

    source
    fn consensus_ratio(mask : InlierMask) -> Double

    deterministic_indices

    source
    fn deterministic_indices(length~ : Int, count~ : Int, seed~ : UInt) -> Array[Int] raise 
    GeometryError

    deterministic_sample_indices

    source
    fn deterministic_sample_indices(population~ : Int, sample_size~ : Int, seed~ : Int) -> Array[Int]

    diagnostic_adaptive_threshold

    source
    fn diagnostic_adaptive_threshold(residuals : ArrayView[Double], multiplier : Double, minimum : Double) -> Double raise 
    GeometryError

    diagnostic_compare

    source
    fn diagnostic_compare(left : DiagnosticReport, right : DiagnosticReport) -> Int

    diagnostic_csv_document

    source
    fn diagnostic_csv_document(reports : ArrayView[DiagnosticReport]) -> String

    diagnostic_csv_header

    source
    fn diagnostic_csv_header() -> String

    diagnostic_csv_row

    source
    fn diagnostic_csv_row(report : DiagnosticReport) -> String

    Stable comma-separated diagnostic row for CI and benchmark artifacts.

    diagnostic_inlier_indices

    source
    fn diagnostic_inlier_indices(residuals : ArrayView[Double], threshold : Double) -> Array[Int]

    diagnostic_json_like

    source
    fn diagnostic_json_like(report : DiagnosticReport) -> String

    diagnostic_label

    source
    fn diagnostic_label(inlier_ratio : Double, mean_inlier : Double, threshold : Double) -> String

    diagnostic_mad

    source
    fn diagnostic_mad(residuals : ArrayView[Double]) -> Double raise 
    GeometryError

    diagnostic_outlier_indices

    source
    fn diagnostic_outlier_indices(residuals : ArrayView[Double], threshold : Double) -> Array[Int]

    diagnostic_percentile

    source
    fn diagnostic_percentile(residuals : ArrayView[Double], probability : Double) -> Double raise 
    GeometryError

    diagnostic_quality_bucket

    source
    fn diagnostic_quality_bucket(report : DiagnosticReport) -> Int

    diagnostic_quality_name

    source
    fn diagnostic_quality_name(bucket : Int) -> String

    diagnostic_rank

    source
    fn diagnostic_rank(reports : ArrayView[DiagnosticReport]) -> Array[DiagnosticReport]

    diagnostic_report_acceptable

    source
    fn diagnostic_report_acceptable(report : DiagnosticReport, minimum_ratio : Double, maximum_rms : Double) -> Bool

    diagnostic_report_confidence

    source
    fn diagnostic_report_confidence(report : DiagnosticReport, iterations : Int) -> Double

    diagnostic_report_csv_full

    source
    fn diagnostic_report_csv_full(report : DiagnosticReport) -> String

    diagnostic_report_error_ratio

    source
    fn diagnostic_report_error_ratio(report : DiagnosticReport) -> Double

    diagnostic_report_header

    source
    fn diagnostic_report_header() -> String

    Compact diagnostic exports used by CI benchmark artifacts.

    diagnostic_report_health

    source
    fn diagnostic_report_health(report : DiagnosticReport, minimum_ratio : Double, maximum_rms : Double) -> Double

    diagnostic_report_health_label

    source
    fn diagnostic_report_health_label(report : DiagnosticReport, minimum_ratio : Double, maximum_rms : Double) -> String

    diagnostic_report_inlier_fraction

    source
    fn diagnostic_report_inlier_fraction(report : DiagnosticReport) -> Double

    diagnostic_report_is_empty

    source
    fn diagnostic_report_is_empty(report : DiagnosticReport) -> Bool

    diagnostic_report_is_good

    source
    fn diagnostic_report_is_good(report : DiagnosticReport, minimum_ratio : Double, maximum_rms : Double) -> Bool

    diagnostic_report_json_full

    source
    fn diagnostic_report_json_full(report : DiagnosticReport) -> String

    diagnostic_report_margin

    source
    fn diagnostic_report_margin(report : DiagnosticReport, minimum_ratio : Double, maximum_rms : Double) -> Double

    diagnostic_report_merge

    source
    fn diagnostic_report_merge(left : DiagnosticReport, right : DiagnosticReport) -> DiagnosticReport

    diagnostic_report_outlier_fraction

    source
    fn diagnostic_report_outlier_fraction(report : DiagnosticReport) -> Double

    diagnostic_report_passes

    source
    fn diagnostic_report_passes(report : DiagnosticReport, minimum_inliers : Int, maximum_rms : Double) -> Bool

    diagnostic_report_rows

    source
    fn diagnostic_report_rows(reports : ArrayView[DiagnosticReport]) -> Array[String]

    diagnostic_report_scale

    source
    fn diagnostic_report_scale(report : DiagnosticReport, scale : Double) -> DiagnosticReport

    diagnostic_report_signal_to_error

    source
    fn diagnostic_report_signal_to_error(report : DiagnosticReport) -> Double

    diagnostic_report_threshold

    source
    fn diagnostic_report_threshold(report : DiagnosticReport) -> Double

    diagnostic_reports_csv

    source
    fn diagnostic_reports_csv(reports : ArrayView[DiagnosticReport]) -> String

    diagnostic_reports_json

    source
    fn diagnostic_reports_json(reports : ArrayView[DiagnosticReport]) -> String

    diagnostic_residual_histogram

    source
    fn diagnostic_residual_histogram(residuals : ArrayView[Double], bins : Int, maximum : Double) -> Array[Int]

    diagnostic_score

    source
    fn diagnostic_score(report : DiagnosticReport, scale : Double) -> Double

    diagnostic_series_append

    source
    fn diagnostic_series_append(target : Array[DiagnosticReport], reports : ArrayView[DiagnosticReport]) -> Unit

    diagnostic_series_best

    source
    fn diagnostic_series_best(reports : ArrayView[DiagnosticReport]) -> DiagnosticReport?

    diagnostic_series_buckets

    source
    fn diagnostic_series_buckets(reports : ArrayView[DiagnosticReport]) -> Array[Int]

    diagnostic_series_drop

    source
    fn diagnostic_series_drop(reports : ArrayView[DiagnosticReport], count : Int) -> Array[DiagnosticReport]

    diagnostic_series_improvement

    source
    fn diagnostic_series_improvement(reports : ArrayView[DiagnosticReport]) -> Double

    diagnostic_series_inlier_mean

    source
    fn diagnostic_series_inlier_mean(reports : ArrayView[DiagnosticReport]) -> Double

    diagnostic_series_labels

    source
    fn diagnostic_series_labels(reports : ArrayView[DiagnosticReport]) -> Array[String]

    diagnostic_series_last

    source
    fn diagnostic_series_last(reports : ArrayView[DiagnosticReport]) -> DiagnosticReport?

    diagnostic_series_maximum

    source
    fn diagnostic_series_maximum(reports : ArrayView[DiagnosticReport]) -> Double

    diagnostic_series_mean

    source
    fn diagnostic_series_mean(reports : ArrayView[DiagnosticReport]) -> Double

    Diagnostic time-series helpers for monitoring robust estimators in production.

    diagnostic_series_merge

    source
    fn diagnostic_series_merge(left : ArrayView[DiagnosticReport], right : ArrayView[DiagnosticReport]) -> Array[DiagnosticReport]

    diagnostic_series_minimum

    source
    fn diagnostic_series_minimum(reports : ArrayView[DiagnosticReport]) -> Double

    diagnostic_series_pass_count

    source
    fn diagnostic_series_pass_count(reports : ArrayView[DiagnosticReport], minimum_inliers : Int, maximum_rms : Double) -> Int

    diagnostic_series_pass_ratio

    source
    fn diagnostic_series_pass_ratio(reports : ArrayView[DiagnosticReport], minimum_inliers : Int, maximum_rms : Double) -> Double

    diagnostic_series_quality

    source
    fn diagnostic_series_quality(reports : ArrayView[DiagnosticReport], minimum_inliers : Int, maximum_rms : Double) -> Double

    diagnostic_series_scale

    source
    fn diagnostic_series_scale(reports : ArrayView[DiagnosticReport], scale : Double) -> Array[DiagnosticReport]

    diagnostic_series_stable

    source
    fn diagnostic_series_stable(reports : ArrayView[DiagnosticReport], tolerance : Double) -> Bool

    diagnostic_series_summary

    source
    fn diagnostic_series_summary(reports : ArrayView[DiagnosticReport]) -> String

    diagnostic_series_take

    source
    fn diagnostic_series_take(reports : ArrayView[DiagnosticReport], count : Int) -> Array[DiagnosticReport]

    diagnostic_series_window

    source
    fn diagnostic_series_window(reports : ArrayView[DiagnosticReport], start : Int, width : Int) -> Array[DiagnosticReport]

    diagnostic_summary_line

    source
    fn diagnostic_summary_line(report : DiagnosticReport) -> String

    estimate_fundamental_ransac

    source

    estimate_homography_ransac

    source

    evaluate_consensus_candidates

    source
    fn evaluate_consensus_candidates(residual_sets : ArrayView[Array[Double]], threshold~ : Double) -> Array[ConsensusCandidate2]

    expected_successes

    source
    fn expected_successes(iterations~ : Int, inlier_ratio~ : Double, sample_size~ : Int) -> Double raise 
    GeometryError

    geman_mcclure_loss2

    source
    fn geman_mcclure_loss2(residual : Double, scale : Double) -> Double

    geman_mcclure_weight2

    source
    fn geman_mcclure_weight2(residual : Double, scale : Double) -> Double

    huber_loss

    source
    fn huber_loss(residual~ : Double, delta? : Double) -> Double

    huber_loss2

    source
    fn huber_loss2(residual~ : Double, delta? : Double) -> Double

    Huber loss with an explicit transition scale.

    huber_weight2

    source
    fn huber_weight2(residual : Double, delta : Double) -> Double

    inlier_indices

    source
    fn inlier_indices(residuals : ArrayView[Double], threshold : Double) -> Array[Int]

    Small diagnostics used by CLI reports and CI smoke checks.

    inlier_ratio_from_mask

    source
    fn inlier_ratio_from_mask(mask : InlierMask) -> Double

    inlier_weight

    source
    fn inlier_weight(residual~ : Double, threshold~ : Double) -> Double

    make_diagnostic_report

    source
    fn make_diagnostic_report(residuals : ArrayView[Double], threshold~ : Double) -> DiagnosticReport

    make_model_report

    source
    fn make_model_report(iterations~ : Int, inliers~ : Int, total~ : Int, score~ : Double, converged~ : Bool) -> ModelReport

    median_inlier_residual

    source
    fn median_inlier_residual(residuals : ArrayView[Double], threshold : Double) -> Double raise 
    GeometryError

    minimum_consensus_count

    source
    fn minimum_consensus_count(total~ : Int, ratio~ : Double) -> Int raise 
    GeometryError

    model_report_best

    source
    fn model_report_best(reports : ArrayView[ModelReport], minimum_ratio : Double, minimum_inliers : Int) -> ModelReport?

    model_report_best_index

    source
    fn model_report_best_index(reports : ArrayView[ModelReport], minimum_ratio : Double, minimum_inliers : Int) -> Int

    model_report_bucket_counts

    source
    fn model_report_bucket_counts(reports : ArrayView[ModelReport]) -> Array[Int]

    model_report_budget

    source
    fn model_report_budget(report : ModelReport, maximum_iterations : Int) -> Int

    model_report_consensus_ratio

    source
    fn model_report_consensus_ratio(reports : ArrayView[ModelReport]) -> Double

    model_report_consensus_spread

    source
    fn model_report_consensus_spread(reports : ArrayView[ModelReport]) -> Double

    model_report_expected_success

    source
    fn model_report_expected_success(report : ModelReport, confidence : Double) -> Double

    model_report_filter_converged

    source
    fn model_report_filter_converged(reports : ArrayView[ModelReport]) -> Array[ModelReport]

    model_report_filter_inliers

    source
    fn model_report_filter_inliers(reports : ArrayView[ModelReport], minimum_inliers : Int) -> Array[ModelReport]

    model_report_filter_ratio

    source
    fn model_report_filter_ratio(reports : ArrayView[ModelReport], minimum_ratio : Double) -> Array[ModelReport]

    model_report_is_degenerate

    source
    fn model_report_is_degenerate(report : ModelReport) -> Bool

    model_report_merge

    source
    fn model_report_merge(left : ModelReport, right : ModelReport) -> ModelReport

    model_report_merge_all

    source
    fn model_report_merge_all(reports : ArrayView[ModelReport]) -> ModelReport

    model_report_quality_bucket

    source
    fn model_report_quality_bucket(report : ModelReport) -> Int

    model_report_rank

    source
    fn model_report_rank(reports : ArrayView[ModelReport], minimum_ratio : Double, minimum_inliers : Int) -> Array[Int]

    model_report_reliability

    source
    fn model_report_reliability(report : ModelReport, maximum_iterations : Int) -> Double

    model_report_score

    source
    fn model_report_score(report : ModelReport, ratio_weight : Double, iteration_weight : Double) -> Double

    model_report_sort_by_ratio

    source
    fn model_report_sort_by_ratio(reports : ArrayView[ModelReport]) -> Array[ModelReport]

    model_report_sort_by_score

    source
    fn model_report_sort_by_score(reports : ArrayView[ModelReport]) -> Array[ModelReport]

    model_report_stability

    source
    fn model_report_stability(reports : ArrayView[ModelReport], maximum_spread : Double) -> Double

    model_report_to_csv

    source
    fn model_report_to_csv(report : ModelReport) -> String

    model_reports_to_csv

    source
    fn model_reports_to_csv(reports : ArrayView[ModelReport]) -> String

    model_selection_summary

    source
    fn model_selection_summary(reports : ArrayView[ModelReport], minimum_ratio : Double, minimum_inliers : Int) -> ModelSelectionSummary

    normalized_score

    source
    fn[T] normalized_score(result : RansacResult[T]) -> Double

    outlier_ratio

    source
    fn outlier_ratio(residuals : ArrayView[Double], threshold : Double) -> Double

    pseudo_huber_loss2

    source
    fn pseudo_huber_loss2(residual : Double, delta : Double) -> Double

    pseudo_huber_weight2

    source
    fn pseudo_huber_weight2(residual : Double, delta : Double) -> Double

    quality_label

    source
    fn quality_label(inlier_ratio : Double, median_error : Double, good_ratio : Double, max_error : Double) -> String

    rank_consensus_candidates

    source
    fn rank_consensus_candidates(candidates : ArrayView[ConsensusCandidate2]) -> Array[ConsensusCandidate2]

    rank_model_reports

    source
    fn rank_model_reports(reports : ArrayView[ModelReport]) -> Array[ModelReport]

    rank_results

    source
    fn[T] rank_results(results : ArrayView[RansacResult[T]]) -> Array[Int]

    report_from_residuals

    source
    fn report_from_residuals(residuals : ArrayView[Double], threshold~ : Double) -> ConsensusReport raise 
    GeometryError

    report_summary

    source
    fn report_summary(reports : ArrayView[ModelReport]) -> (Int, Int, Double)

    required_iterations

    source
    fn required_iterations(success_probability~ : Double, confidence? : Double) -> Int raise 
    GeometryError

    residual_is_inlier

    source
    fn residual_is_inlier(residual~ : Double, threshold~ : Double) -> Bool

    residual_mean_for_mask

    source
    fn residual_mean_for_mask(residuals : ArrayView[Double], mask : InlierMask) -> Double raise 
    GeometryError

    residual_quantiles

    source

    residual_threshold_from_sigma

    source
    fn residual_threshold_from_sigma(sigma~ : Double, confidence_multiplier? : Double) -> Double raise 
    GeometryError

    robust_cost

    source
    fn robust_cost(residuals : ArrayView[Double], delta? : Double) -> Double

    robust_loss_batch

    source
    fn robust_loss_batch(residuals : ArrayView[Double], scale : Double) -> Array[Double]

    robust_loss_mean

    source
    fn robust_loss_mean(residuals : ArrayView[Double], scale : Double) -> Double

    robust_loss_sum

    source
    fn robust_loss_sum(residuals : ArrayView[Double], scale : Double) -> Double

    robust_weight_batch

    source
    fn robust_weight_batch(residuals : ArrayView[Double], scale : Double) -> Array[Double]

    robust_weighted_batch

    source
    fn robust_weighted_batch(residuals : ArrayView[Double], weights : ArrayView[Double]) -> Array[Double]

    robust_weighted_residual

    source
    fn robust_weighted_residual(residual : Double, weight : Double) -> Double

    sample_batch_coverage

    source
    fn sample_batch_coverage(indices : ArrayView[Int], population : Int) -> Double

    sample_batch_delta

    source
    fn sample_batch_delta(indices : ArrayView[Int]) -> Array[Int]

    sample_batch_difference

    source
    fn sample_batch_difference(left : ArrayView[Int], right : ArrayView[Int]) -> Array[Int]

    sample_batch_duplicate_count

    source
    fn sample_batch_duplicate_count(indices : ArrayView[Int]) -> Int

    sample_batch_evenness

    source
    fn sample_batch_evenness(indices : ArrayView[Int]) -> Double

    sample_batch_intersection

    source
    fn sample_batch_intersection(left : ArrayView[Int], right : ArrayView[Int]) -> Array[Int]

    sample_batch_is_valid

    source
    fn sample_batch_is_valid(indices : ArrayView[Int], population : Int, minimum : Int) -> Bool

    sample_batch_jaccard

    source
    fn sample_batch_jaccard(left : ArrayView[Int], right : ArrayView[Int]) -> Double

    sample_batch_maximum

    source
    fn sample_batch_maximum(indices : ArrayView[Int]) -> Int

    sample_batch_mean_delta

    source
    fn sample_batch_mean_delta(indices : ArrayView[Int]) -> Double

    sample_batch_minimum

    source
    fn sample_batch_minimum(indices : ArrayView[Int]) -> Int

    sample_batch_out_of_range

    source
    fn sample_batch_out_of_range(indices : ArrayView[Int], population : Int) -> Array[Int]

    sample_batch_partition

    source
    fn sample_batch_partition(indices : ArrayView[Int], partition_count : Int) -> Array[Array[Int]]

    sample_batch_partition_balance

    source
    fn sample_batch_partition_balance(indices : ArrayView[Int], partition_count : Int) -> Double

    sample_batch_repeat

    source
    fn sample_batch_repeat(indices : ArrayView[Int], repetitions : Int) -> Array[Int]

    sample_batch_rotate

    source
    fn sample_batch_rotate(indices : ArrayView[Int], offset : Int) -> Array[Int]

    sample_batch_sorted

    source
    fn sample_batch_sorted(indices : ArrayView[Int]) -> Array[Int]

    sample_batch_span

    source
    fn sample_batch_span(indices : ArrayView[Int]) -> Int

    sample_batch_stride

    source
    fn sample_batch_stride(population : Int, stride : Int, offset : Int) -> Array[Int]

    sample_batch_summary

    source
    fn sample_batch_summary(indices : ArrayView[Int], population : Int, dimensions : Int) -> SampleBatchSummary

    sample_batch_union

    source
    fn sample_batch_union(left : ArrayView[Int], right : ArrayView[Int]) -> Array[Int]

    sample_batch_unique

    source
    fn sample_batch_unique(indices : ArrayView[Int]) -> Array[Int]

    sample_batch_window

    source
    fn sample_batch_window(population : Int, start : Int, width : Int) -> Array[Int]

    sample_batches

    source
    fn sample_batches(population : Int, sample_size : Int, count : Int, seed : Int) -> Array[Array[Int]]

    sample_complement

    source
    fn sample_complement(population : Int, selected : ArrayView[Int]) -> Array[Int]

    sample_frequency

    source
    fn sample_frequency(batches : ArrayView[Array[Int]], population : Int) -> Array[Int]

    sample_intersection

    source
    fn sample_intersection(left : ArrayView[Int], right : ArrayView[Int]) -> Array[Int]

    sample_is_valid

    source
    fn sample_is_valid(indices : ArrayView[Int], population : Int, sample_size : Int) -> Bool

    sample_probability

    source
    fn sample_probability(inlier_ratio~ : Double, sample_size~ : Int) -> Double raise 
    GeometryError

    sample_union

    source
    fn sample_union(left : ArrayView[Int], right : ArrayView[Int]) -> Array[Int]

    sample_without_replacement

    source
    fn sample_without_replacement(length~ : Int, count~ : Int, seed~ : UInt) -> Array[Int] raise 
    GeometryError

    sampling_coverage

    source
    fn sampling_coverage(batches : ArrayView[Array[Int]], population : Int) -> Double

    schedule_checkpoints

    source
    fn schedule_checkpoints(schedule : IterationSchedule, count : Int) -> Array[Int]

    Generate deterministic checkpoints for progress reporting and early stopping.

    schedule_required_iterations

    source
    fn schedule_required_iterations(sample_size : Int, inlier_ratio : Double, confidence : Double) -> Int

    Numerically stable RANSAC iteration estimate.

    score_margin

    source
    fn score_margin(best : Double, second : Double) -> Double

    score_mlesac

    source
    fn score_mlesac(residuals : ArrayView[Double], config : MlesacConfig) -> Double

    score_mlesac_with_threshold

    source
    fn score_mlesac_with_threshold(residuals : ArrayView[Double], threshold~ : Double, config : MlesacConfig) -> Double

    score_residuals

    source
    fn score_residuals(residuals : ArrayView[Double], threshold~ : Double) -> RansacResult[Array[Double]] raise 
    GeometryError

    select_best_candidate

    source
    fn select_best_candidate(candidates : ArrayView[ConsensusCandidate2]) -> ConsensusCandidate2

    select_best_score

    source
    fn select_best_score(scores : ArrayView[Double]) -> Int raise 
    GeometryError

    sorted_indices

    source
    fn sorted_indices(indices : ArrayView[Int]) -> Array[Int]

    stable_model

    source
    fn stable_model(best : ModelReport, second : ModelReport, minimum_margin : Double) -> Bool

    sweep_thresholds

    source
    fn sweep_thresholds(residuals : ArrayView[Double], thresholds : ArrayView[Double]) -> ThresholdSweepResult

    threshold_from_mad

    source
    fn threshold_from_mad(residuals : ArrayView[Double], multiplier? : Double) -> Double raise 
    GeometryError

    tukey_loss2

    source
    fn tukey_loss2(residual : Double, cutoff : Double) -> Double

    tukey_weight

    source
    fn tukey_weight(residual~ : Double, cutoff~ : Double) -> Double

    tukey_weight2

    source
    fn tukey_weight2(residual : Double, cutoff : Double) -> Double

    unique_index_count

    source
    fn unique_index_count(indices : ArrayView[Int]) -> Int

    update_inlier_ratio

    source
    fn update_inlier_ratio(previous : Double, observed : Int, total : Int, momentum? : Double) -> Double

    Update an inlier estimate without restarting a running solver.

    validate_mask

    source
    fn validate_mask(mask : InlierMask, expected_length~ : Int) -> Bool

    weighted_consensus

    source
    fn weighted_consensus(residuals : ArrayView[Double], threshold~ : Double) -> Double

    Source Files

    Powered by MoonBit

    Site sourceReport issuePackagesBuild queueSkillsStatistics

    © 2026 mooncakes.io