moonbit-visual-caliper

    MoonBit-native industrial visual caliper toolkit for edge-based measurement and tolerance reports.

    industrial-vision
    caliper
    measurement
    geometry
    quality-control
    Download zip
    Author
    Version
    0.2.4
    License
    Apache-2.0
    Last updated
    2 months ago
    Downloads
    48

    No dependencies

    #moonbit-visual-caliper

    MoonBit 原生的工业视觉测量核心库:从灰度图和测量线剖面出发,完成边缘定位、几何拟合、标定、公差判定、质量评估和结构化报告输出。核心包不依赖 FFI 或外部图像格式,适合作为制造质检、教学实验、算法验证和相机适配层的基础。

    CI

    #Project positioning

    本项目聚焦“可解释的视觉量规”而不是通用图像框架。输入可以是程序生成或适配器转换后的灰度图,输出是带单位、公差、质量和诊断信息的测量结果。所有核心算法都在 MoonBit 包内实现,便于跨 wasm、wasm-gc、js 和 native 后端复现。

    #Core capabilities

    • 灰度图:安全访问、双线性采样、归一化、裁剪、缩放、卷积、Gaussian/median 平滑、Sobel 梯度、直方图和自适应阈值。
    • 边缘与剖面:任意测量线采样、上升/下降/双极性边缘、亚像素定位、滞后阈值、峰值、相关性和重复性分析。
    • 二值视觉:膨胀、腐蚀、开闭运算、孔洞填充、距离变换、连通域、边界、轮廓、凸包和形状描述子。
    • 几何与标定:点/线/圆/椭圆、鲁棒拟合、仿射变换、三点标定、XY 比例、残差和不确定度传播。
    • 工业测量:宽度、距离、角度、平行度、垂直度、直径、圆度、跳动、面积、周长、批次统计和控制界限。
    • 工程交付:Markdown、CSV、JSON、诊断事件、确定性合成夹具、命令行演示和可复现 benchmark。

    #Quick start

    Install the latest stable MoonBit toolchain using the official installer, then run:

    moon update moon check --target all --deny-warn moon test --target all --deny-warn moon run cmd/main

    Library use:

    ///|
    test "measure a synthetic bracket" {
    let image = make_demo_part()
    let pixels = gauge_width(
    image,
    Point::Point(x=10.0, y=20.0),
    Point::Point(x=70.0, y=20.0),
    )
    let scale = calibration_from_reference(pixels, 22.0)
    let tolerance = Tolerance::Tolerance(nominal=22.0, lower=21.8, upper=22.2)
    let result = analyze_gap("outer width", pixels, scale, tolerance)
    assert_eq(result.decision, MeasurementDecision::Pass)
    }

    #CLI

    The demo executable creates a deterministic bracket-like image, measures its outer width, and prints a Markdown report:

    moon run cmd/main

    For a deterministic algorithm workload and checksum output:

    moon run cmd/benchmark

    The CLI is intentionally small. Applications can call the root package and add their own camera, decoder, storage, or UI adapter without coupling those concerns to the measurement core.

    #Architecture

    The root package is split by responsibility. Files are implementation units inside one MoonBit package; public symbols are exposed by the package interface, not by filenames.

    LayerResponsibilities
    types.mbt, numeric.mbtDomain records, vectors, matrices, statistics, tolerances
    image.mbt, image_ops.mbt, image_statistics.mbt, image_pyramid.mbtImage storage, filtering, gradients, thresholds, pyramids
    mask.mbt, morphology_advanced.mbt, components.mbt, contours.mbtBinary operations, regions, boundaries, shape descriptors
    profile.mbt, signal_profiles.mbt, caliper_pipeline.mbt, advanced_calipers.mbtProfile calipers, edge policies, quality and repeatability
    geometry.mbt, transforms.mbt, geometry_fit.mbt, geometry_primitives.mbtFitting, transforms, projections and geometric metrics
    calibration*.mbt, uncertainty.mbtPixel-to-unit models, residuals and uncertainty
    measurements.mbt, measurement_suite.mbt, batch*.mbtFeature measurements and batch analytics
    serialization.mbt, report*.mbt, diagnostics.mbtHuman-readable and machine-readable outputs
    fixtures.mbt, benchmark_workloads.mbt, cmd/Reproducible examples and executable entry points

    #Benchmark

    The benchmark workload measures filtering, edge extraction, connected components, geometry fitting, and the complete caliper path on deterministic synthetic images. It prints checksums so a run can be checked for accidental workload changes:

    moon run cmd/benchmark

    benchmarks/RESULTS.md records an actual local run, including the toolchain, OS, command, workload dimensions, checksums, and wall-clock measurements. Wall-clock values are machine-specific; the checksum and workload definitions are the reproducible comparison anchors.

    #Testing

    Run the full local matrix before submitting a change:

    moon fmt --check moon check --target all --deny-warn moon test --target all --deny-warn moon info git diff --exit-code

    The test suite covers normal measurements and boundary behavior: empty and one-pixel images, borders, constant profiles, degenerate geometry, empty batches, hole filling, exact template matches, unit conversion, uncertainty budgets, deterministic fixtures, reports, and contract validation.

    For callers that need explicit validation, the checked try_* APIs return None for invalid geometry, calibration, image rows, filter kernels, profile widths, tolerances, and affine correspondences. The compatibility APIs retain deterministic neutral results for those cases, while contract helpers remain available for diagnostic validation.

    #CI

    GitHub Actions runs the stable MoonBit toolchain on Ubuntu, macOS, and Windows. Each matrix job checks formatting, all compiler targets, all test targets, generated package interfaces, and (on Ubuntu) coverage analysis. The workflow is intentionally dependency-free and does not require credentials for pull requests.

    The manual publish workflow validates the same project, then publishes the module when the repository has the MOONCAKES_MOONBIT_COMMUNITY_TOKEN secret configured.

    #License

    Apache-2.0. See LICENSE.

    #Contributing

    Keep the root package dependency-free unless an adapter is isolated in its own package. Add focused tests for public behavior, preserve deterministic fixtures, run the complete validation commands, and review generated pkg.generated.mbti changes when the public API changes. See CONTRIBUTING.md.

    AffineTransform

    pub(all) struct AffineTransform {
    a : Double
    b : Double
    c : Double
    d : Double
    tx : Double
    ty : Double
    } derive(
    Debug
    )

    AffineTransform::AffineTransform

    fn AffineTransform::AffineTransform(a~ : Double, b~ : Double, c~ : Double, d~ : Double, tx~ : Double, ty~ : Double) -> AffineTransform

    AffineTransform::apply

    fn AffineTransform::apply(transform : AffineTransform, point : Point) -> Point

    AffineTransform::compose

    AffineTransform::determinant

    fn AffineTransform::determinant(transform : AffineTransform) -> Double

    AffineTransform::from_correspondences

    fn AffineTransform::from_correspondences(source : Array[Point], target : Array[Point]) -> AffineTransform

    AffineTransform::identity

    AffineTransform::inverse

    fn AffineTransform::inverse(transform : AffineTransform) -> AffineTransform

    AffineTransform::rotation

    fn AffineTransform::rotation(angle : Double) -> AffineTransform

    AffineTransform::scaling

    fn AffineTransform::scaling(sx~ : Double, sy~ : Double) -> AffineTransform

    AffineTransform::translation

    fn AffineTransform::translation(dx~ : Double, dy~ : Double) -> AffineTransform

    AffineTransform::try_from_correspondences

    fn AffineTransform::try_from_correspondences(source : Array[Point], target : Array[Point]) -> AffineTransform?

    BatchRun

    pub(all) struct BatchRun {
    id : String
    records : Array[Measurement]
    } derive(
    Debug
    )

    BatchRun::accepted

    fn BatchRun::accepted(batch : BatchRun) -> Array[Measurement]

    BatchRun::add

    fn BatchRun::add(batch : BatchRun, measurement : Measurement) -> Unit

    BatchRun::failed

    fn BatchRun::failed(batch : BatchRun) -> Array[Measurement]

    BatchRun::measurements

    fn BatchRun::measurements(batch : BatchRun) -> Array[Measurement]

    BatchRun::merge

    fn BatchRun::merge(first : BatchRun, second : BatchRun) -> BatchRun

    BatchRun::new

    fn BatchRun::new(id : String) -> BatchRun

    BatchRun::summary

    fn BatchRun::summary(batch : BatchRun) -> MeasurementSummary

    BatchStatistics

    pub(all) struct BatchStatistics {
    id : String
    total : Int
    accepted : Int
    rejected : Int
    mean : Double
    standard_deviation : Double
    minimum : Double
    maximum : Double
    } derive(
    Debug
    )

    BinaryMask

    pub(all) struct BinaryMask {
    width : Int
    height : Int
    values : Array[Bool]
    } derive(
    Debug
    )

    BinaryMask::BinaryMask

    fn BinaryMask::BinaryMask(width~ : Int, height~ : Int) -> BinaryMask

    BinaryMask::at

    fn BinaryMask::at(mask : BinaryMask, x : Int, y : Int) -> Bool

    BinaryMask::boundary

    fn BinaryMask::boundary(mask : BinaryMask) -> BinaryMask

    BinaryMask::bounds

    fn BinaryMask::bounds(mask : BinaryMask) -> Bounds

    BinaryMask::clear

    fn BinaryMask::clear(mask : BinaryMask) -> Unit

    BinaryMask::clone

    fn BinaryMask::clone(mask : BinaryMask) -> BinaryMask

    BinaryMask::closing

    fn BinaryMask::closing(mask : BinaryMask, radius : Int) -> BinaryMask

    BinaryMask::column_projection

    fn BinaryMask::column_projection(mask : BinaryMask) -> Array[Int]

    BinaryMask::count

    fn BinaryMask::count(mask : BinaryMask) -> Int

    BinaryMask::difference

    fn BinaryMask::difference(a : BinaryMask, b : BinaryMask) -> BinaryMask

    BinaryMask::dilate

    fn BinaryMask::dilate(mask : BinaryMask, radius : Int) -> BinaryMask

    BinaryMask::erode

    fn BinaryMask::erode(mask : BinaryMask, radius : Int) -> BinaryMask

    BinaryMask::fill

    fn BinaryMask::fill(mask : BinaryMask, value : Bool) -> Unit

    BinaryMask::inside

    fn BinaryMask::inside(mask : BinaryMask, x : Int, y : Int) -> Bool

    BinaryMask::intersect

    fn BinaryMask::intersect(a : BinaryMask, b : BinaryMask) -> BinaryMask

    BinaryMask::invert

    fn BinaryMask::invert(mask : BinaryMask) -> BinaryMask

    BinaryMask::opening

    fn BinaryMask::opening(mask : BinaryMask, radius : Int) -> BinaryMask

    BinaryMask::row_projection

    fn BinaryMask::row_projection(mask : BinaryMask) -> Array[Int]

    BinaryMask::set

    fn BinaryMask::set(mask : BinaryMask, x : Int, y : Int, value : Bool) -> Unit

    BinaryMask::union

    BorderPolicy

    pub(all) enum BorderPolicy {
    Constant(value~ : Double)
    Clamp
    Reflect
    } derive(Eq,
    Debug
    )

    Bounds

    pub(all) struct Bounds {
    min_x : Int
    min_y : Int
    max_x : Int
    max_y : Int
    } derive(Eq,
    Debug
    )

    CalibrationFit

    pub(all) struct CalibrationFit {
    transform : AffineTransform
    residuals : Array[Double]
    rms_error : Double
    max_error : Double
    } derive(
    Debug
    )

    CaliperConfig

    pub(all) struct CaliperConfig {
    start : Point
    finish : Point
    threshold : Double
    mode : EdgeMode
    expected_edges : Int
    unit : String
    } derive(
    Debug
    )

    CaliperConfig::new

    fn CaliperConfig::new(start~ : Point, finish~ : Point, threshold~ : Double, mode? : EdgeMode, expected_edges? : Int, unit? : String) -> CaliperConfig

    Circle

    pub(all) struct Circle {
    center : Point
    radius : Double
    rms_error : Double
    } derive(
    Debug
    )

    Circle::Circle

    fn Circle::Circle(center~ : Point, radius~ : Double, rms_error~ : Double) -> Circle

    Component

    pub(all) struct Component {
    label : Int
    area : Int
    bounds : Bounds
    centroid : Point
    perimeter : Double
    circularity : Double
    } derive(
    Debug
    )

    DiagnosticEvent

    pub(all) struct DiagnosticEvent {
    code : String
    stage : String
    detail : String
    value : Double
    } derive(
    Debug
    )

    DoubleBounds

    pub(all) struct DoubleBounds {
    min : Double
    max : Double
    } derive(
    Debug
    )

    EdgeMapSummary

    pub(all) struct EdgeMapSummary {
    edges : BinaryMask
    count : Int
    density : Double
    mean_strength : Double
    } derive(
    Debug
    )

    EdgeMode

    pub(all) enum EdgeMode {
    Rising
    Falling
    Both
    } derive(Eq,
    Debug
    )

    EdgePoint

    pub(all) struct EdgePoint {
    point : Point
    strength : Double
    polarity : Int
    } derive(
    Debug
    )

    EdgePolicy

    pub(all) struct EdgePolicy {
    low_threshold : Double
    high_threshold : Double
    mode : EdgeMode
    min_strength : Double
    } derive(
    Debug
    )

    EdgePolicy::new

    fn EdgePolicy::new(low_threshold~ : Double, high_threshold~ : Double, mode? : EdgeMode, min_strength? : Double) -> EdgePolicy

    Ellipse

    pub(all) struct Ellipse {
    center : Point
    major_radius : Double
    minor_radius : Double
    angle : Double
    rms_error : Double
    } derive(
    Debug
    )

    FeatureMeasurement

    pub(all) struct FeatureMeasurement {
    name : String
    value : Double
    unit : String
    confidence : Double
    decision : MeasurementDecision
    } derive(
    Debug
    )

    GrayImage

    pub(all) struct GrayImage {
    width : Int
    height : Int
    pixels : Array[Double]
    } derive(
    Debug
    )

    GrayImage::GrayImage

    fn GrayImage::GrayImage(width~ : Int, height~ : Int, fill? : Double) -> GrayImage

    GrayImage::at

    fn GrayImage::at(image : GrayImage, x : Int, y : Int) -> Double

    GrayImage::copy

    fn GrayImage::copy(image : GrayImage) -> GrayImage

    GrayImage::from_rows

    fn GrayImage::from_rows(rows : Array[Array[Double]]) -> GrayImage

    GrayImage::inside

    fn GrayImage::inside(image : GrayImage, x : Int, y : Int) -> Bool

    GrayImage::sample_bilinear

    fn GrayImage::sample_bilinear(image : GrayImage, p : Point) -> Double

    GrayImage::set

    fn GrayImage::set(image : GrayImage, x : Int, y : Int, value : Double) -> Unit

    GrayImage::sobel_magnitude

    fn GrayImage::sobel_magnitude(image : GrayImage, x : Int, y : Int) -> Double

    GrayImage::threshold_edges

    fn GrayImage::threshold_edges(image : GrayImage, threshold : Double) -> Array[EdgePoint]

    GrayImage::try_from_rows

    fn GrayImage::try_from_rows(rows : Array[Array[Double]]) -> GrayImage?

    Histogram

    pub(all) struct Histogram {
    minimum : Double
    maximum : Double
    bins : Array[Int]
    } derive(
    Debug
    )

    Line

    pub(all) struct Line {
    a : Double
    b : Double
    c : Double
    } derive(
    Debug
    )

    Line::Line

    fn Line::Line(a~ : Double, b~ : Double, c~ : Double) -> Line

    Line::distance_to

    fn Line::distance_to(line : Line, p : Point) -> Double

    Line::offset

    fn Line::offset(line : Line, pixels : Double) -> Line

    MatchResult

    pub(all) struct MatchResult {
    found : Bool
    location : Point
    score : Double
    candidates : Array[Point]
    } derive(
    Debug
    )

    Matrix2

    pub(all) struct Matrix2 {
    m00 : Double
    m01 : Double
    m10 : Double
    m11 : Double
    } derive(
    Debug
    )

    Matrix2::add

    fn Matrix2::add(a : Matrix2, b : Matrix2) -> Matrix2

    Matrix2::apply

    fn Matrix2::apply(matrix : Matrix2, vector : Vector2) -> Vector2

    Matrix2::determinant

    fn Matrix2::determinant(matrix : Matrix2) -> Double

    Matrix2::identity

    fn Matrix2::identity() -> Matrix2

    Matrix2::inverse

    fn Matrix2::inverse(matrix : Matrix2) -> Matrix2

    Matrix2::multiply

    fn Matrix2::multiply(a : Matrix2, b : Matrix2) -> Matrix2

    Matrix2::new

    fn Matrix2::new(m00~ : Double, m01~ : Double, m10~ : Double, m11~ : Double) -> Matrix2

    Matrix2::scale

    fn Matrix2::scale(matrix : Matrix2, factor : Double) -> Matrix2

    Matrix2::trace

    fn Matrix2::trace(matrix : Matrix2) -> Double

    Measurement

    pub(all) struct Measurement {
    name : String
    value : Double
    unit : String
    decision : MeasurementDecision
    deviation : Double
    } derive(
    Debug
    )

    MeasurementDecision

    pub(all) enum MeasurementDecision {
    Pass
    Warn
    Fail
    } derive(Eq,
    Debug
    )

    MeasurementReport

    pub(all) struct MeasurementReport {
    part_id : String
    measurements : Array[Measurement]
    notes : Array[String]
    } derive(
    Debug
    )

    MeasurementSummary

    pub(all) struct MeasurementSummary {
    total : Int
    pass : Int
    warn : Int
    fail : Int
    acceptance_rate : Double
    values : StatsSummary
    } derive(
    Debug
    )

    MeasurementTable

    pub(all) struct MeasurementTable {
    columns : Array[String]
    rows : Array[Array[String]]
    } derive(
    Debug
    )

    PipelineDiagnostic

    pub(all) struct PipelineDiagnostic {
    stage : String
    message : String
    severity : MeasurementDecision
    } derive(
    Debug
    )

    PipelineResult

    pub(all) struct PipelineResult {
    measurements : Array[Measurement]
    diagnostics : Array[PipelineDiagnostic]
    accepted : Bool
    confidence : Double
    } derive(
    Debug
    )

    PixelThreshold

    pub(all) enum PixelThreshold {
    Below(value~ : Double)
    Above(value~ : Double)
    Between(lower~ : Double, upper~ : Double)
    } derive(Eq,
    Debug
    )

    Point

    pub(all) struct Point {
    x : Double
    y : Double
    } derive(
    Debug
    )

    Point::Point

    fn Point::Point(x~ : Double, y~ : Double) -> Point

    Point::scale

    fn Point::scale(point : Point, factor : Double) -> Point

    PolygonMetrics

    pub(all) struct PolygonMetrics {
    area : Double
    perimeter : Double
    centroid : Point
    circularity : Double
    rectangularity : Double
    } derive(
    Debug
    )

    ProfileSample

    pub(all) struct ProfileSample {
    point : Point
    value : Double
    gradient : Double
    } derive(
    Debug
    )

    ProfileSample::detect_edges

    fn ProfileSample::detect_edges(samples : Array[ProfileSample], threshold : Double, mode? : EdgeMode) -> Array[EdgePoint]

    ProfileSummary

    pub(all) struct ProfileSummary {
    samples : Array[ProfileSample]
    edges : Array[EdgePoint]
    strongest_edge : EdgePoint?
    mean_gradient : Double
    noise : Double
    signal_to_noise : Double
    } derive(
    Debug
    )

    PyramidLevel

    pub(all) struct PyramidLevel {
    scale : Double
    image : GrayImage
    } derive(
    Debug
    )

    QualitySummary

    pub(all) struct QualitySummary {
    signal_to_noise : Double
    edge_count : Int
    confidence : Double
    stable : Bool
    notes : Array[String]
    } derive(
    Debug
    )

    Roi

    pub(all) struct Roi {
    id : String
    bounds : Bounds
    mask : BinaryMask
    } derive(
    Debug
    )

    Roi::crop

    fn Roi::crop(roi : Roi, image : GrayImage) -> GrayImage

    Roi::from_bounds

    fn Roi::from_bounds(id : String, bounds : Bounds, image : GrayImage) -> Roi

    Roi::from_mask

    fn Roi::from_mask(id : String, mask : BinaryMask) -> Roi

    Roi::masked_image

    fn Roi::masked_image(roi : Roi, image : GrayImage, background : Double) -> GrayImage

    Roi::statistics

    fn Roi::statistics(roi : Roi, image : GrayImage) -> StatsSummary

    Roi::values

    fn Roi::values(roi : Roi, image : GrayImage) -> Array[Double]

    StatsSummary

    pub(all) struct StatsSummary {
    count : Int
    sum : Double
    mean : Double
    variance : Double
    standard_deviation : Double
    minimum : Double
    maximum : Double
    median : Double
    ordered : Array[Double]
    } derive(
    Debug
    )

    StatsSummary::percentile

    fn StatsSummary::percentile(summary : StatsSummary, _q : Double) -> Double

    Tolerance

    pub(all) struct Tolerance {
    nominal : Double
    lower : Double
    upper : Double
    unit : String
    } derive(
    Debug
    )

    Tolerance::Tolerance

    fn Tolerance::Tolerance(nominal~ : Double, lower~ : Double, upper~ : Double, unit? : String) -> Tolerance

    Tolerance::judge

    fn Tolerance::judge(tolerance : Tolerance, value : Double) -> MeasurementDecision

    Tolerance::try_new

    fn Tolerance::try_new(nominal~ : Double, lower~ : Double, upper~ : Double, unit? : String) -> Tolerance?

    UncertaintyEstimate

    pub(all) struct UncertaintyEstimate {
    standard : Double
    expanded : Double
    coverage : Double
    source : String
    } derive(
    Debug
    )

    Vector2

    pub(all) struct Vector2 {
    x : Double
    y : Double
    } derive(
    Debug
    )

    Vector2::Vector2

    fn Vector2::Vector2(x~ : Double, y~ : Double) -> Vector2

    Vector2::add

    fn Vector2::add(a : Vector2, b : Vector2) -> Vector2

    Vector2::angle

    fn Vector2::angle(v : Vector2) -> Double

    Vector2::cross

    fn Vector2::cross(a : Vector2, b : Vector2) -> Double

    Vector2::distance

    fn Vector2::distance(a : Vector2, b : Vector2) -> Double

    Vector2::dot

    fn Vector2::dot(a : Vector2, b : Vector2) -> Double

    Vector2::length

    fn Vector2::length(v : Vector2) -> Double

    Vector2::new

    fn Vector2::new(x~ : Double, y~ : Double) -> Vector2

    Vector2::normalized

    fn Vector2::normalized(v : Vector2) -> Vector2

    Vector2::scale

    fn Vector2::scale(v : Vector2, factor : Double) -> Vector2

    Vector2::sub

    fn Vector2::sub(a : Vector2, b : Vector2) -> Vector2

    adaptive_threshold

    fn adaptive_threshold(image : GrayImage, radius : Int, offset : Double) -> BinaryMask

    algorithm_inventory

    fn algorithm_inventory() -> Array[String]

    align_centroids

    fn align_centroids(source : Array[Point], target : Array[Point]) -> AffineTransform

    analyze_gap

    fn analyze_gap(name : String, pixel_gap : Double, scale : Double, tolerance : Tolerance) -> Measurement

    angle_between_lines

    fn angle_between_lines(first : Line, second : Line) -> Double

    angle_difference

    fn angle_difference(first : Double, second : Double) -> Double

    angular_profile

    fn angular_profile(points : Array[Point], center : Point, bins : Int) -> Array[Double]

    api_contract_inventory

    fn api_contract_inventory() -> Array[String]

    api_surface_summary

    fn api_surface_summary() -> String

    apply_tolerances

    fn apply_tolerances(measurements : Array[Measurement], tolerances : Array[Tolerance]) -> Array[Measurement]

    approx_equal

    fn approx_equal(a : Double, b : Double, tolerance? : Double) -> Bool

    batch_control_limits

    fn batch_control_limits(values : Array[Double], sigma : Double) -> DoubleBounds

    batch_cumulative_mean

    fn batch_cumulative_mean(values : Array[Double]) -> Array[Double]

    batch_cumulative_sum

    fn batch_cumulative_sum(values : Array[Double]) -> Array[Double]

    batch_decision_rate

    fn batch_decision_rate(batches : Array[BatchRun]) -> Double

    batch_drift

    fn batch_drift(values : Array[Double]) -> Double

    batch_group_by_decision

    fn batch_group_by_decision(measurements : Array[Measurement]) -> Array[Array[Measurement]]

    batch_linear_trend

    fn batch_linear_trend(values : Array[Double]) -> Double

    batch_mean_by_name

    fn batch_mean_by_name(batches : Array[BatchRun], name : String) -> StatsSummary

    batch_measurement_table

    fn batch_measurement_table(batch : BatchRun) -> MeasurementTable

    batch_moving_average

    fn batch_moving_average(values : Array[Double], window : Int) -> Array[Double]

    batch_out_of_control

    fn batch_out_of_control(values : Array[Double], limits : DoubleBounds) -> Array[Bool]

    batch_quality

    fn batch_quality(batch : BatchRun) -> Double

    batch_snapshot

    fn batch_snapshot(batch : BatchRun) -> String

    batch_statistics

    fn batch_statistics(batch : BatchRun) -> BatchStatistics

    batch_values_by_index

    fn batch_values_by_index(batches : Array[BatchRun], index : Int) -> Array[Double]

    benchmark_checksum

    fn benchmark_checksum() -> Array[Double]

    benchmark_checksum_text

    fn benchmark_checksum_text() -> String

    benchmark_component_workload

    fn benchmark_component_workload(width : Int, height : Int, rounds : Int) -> Int

    benchmark_geometry_workload

    fn benchmark_geometry_workload(point_count : Int, rounds : Int) -> Double

    benchmark_image_workload

    fn benchmark_image_workload(width : Int, height : Int, rounds : Int) -> Double

    benchmark_pipeline_workload

    fn benchmark_pipeline_workload(rounds : Int) -> Double

    best_template_match

    fn best_template_match(image : GrayImage, template : GrayImage, minimum_score : Double) -> MatchResult

    bias_against_nominal

    fn bias_against_nominal(values : Array[Double], nominal : Double) -> Double

    blank_fixture

    fn blank_fixture(width : Int, height : Int, value : Double) -> GrayImage

    blur_downsample

    fn blur_downsample(image : GrayImage, levels : Int, radius : Int) -> Array[PyramidLevel]

    border_mask

    fn border_mask(width : Int, height : Int, thickness : Int) -> BinaryMask

    bounding_area

    fn bounding_area(bounds : Bounds) -> Double

    bounding_box_of_points

    fn bounding_box_of_points(points : Array[Point]) -> Bounds

    bounding_height

    fn bounding_height(bounds : Bounds) -> Double

    bounding_width

    fn bounding_width(bounds : Bounds) -> Double

    bounds_contains

    fn bounds_contains(bounds : Bounds, point : Point) -> Bool

    bounds_from_center

    fn bounds_from_center(center : Point, width : Int, height : Int) -> Bounds

    bounds_intersection

    fn bounds_intersection(first : Bounds, second : Bounds) -> Bounds

    bounds_is_empty

    fn bounds_is_empty(bounds : Bounds) -> Bool

    bounds_union

    fn bounds_union(first : Bounds, second : Bounds) -> Bounds

    box_blur

    fn box_blur(image : GrayImage, radius : Int) -> GrayImage

    bracket_fixture

    fn bracket_fixture() -> GrayImage

    build_pyramid

    fn build_pyramid(image : GrayImage, levels : Int) -> Array[PyramidLevel]

    calibrate_anisotropic

    fn calibrate_anisotropic(pixel_x : Double, pixel_y : Double, physical_x : Double, physical_y : Double) -> AffineTransform

    calibrate_from_grid

    fn calibrate_from_grid(source_grid : Array[Point], target_grid : Array[Point]) -> CalibrationFit

    calibrate_from_rectangle

    fn calibrate_from_rectangle(source : Bounds, target_width : Double, target_height : Double) -> AffineTransform

    calibrated_area

    fn calibrated_area(fit : AffineTransform, pixel_area : Double) -> Double

    calibrated_circle

    fn calibrated_circle(fit : AffineTransform, circle : Circle) -> Circle

    calibrated_distance

    fn calibrated_distance(fit : AffineTransform, first : Point, second : Point) -> Double

    calibration_anisotropy

    fn calibration_anisotropy(fit : CalibrationFit) -> Double

    calibration_apply_to_batch

    fn calibration_apply_to_batch(fit : CalibrationFit, batch : BatchRun) -> BatchRun

    calibration_apply_to_components

    fn calibration_apply_to_components(fit : CalibrationFit, components : Array[Component]) -> Array[Component]

    calibration_apply_to_measurement

    fn calibration_apply_to_measurement(fit : CalibrationFit, measurement : Measurement) -> Measurement

    calibration_fit

    fn calibration_fit(source : Array[Point], target : Array[Point]) -> CalibrationFit

    calibration_from_reference

    fn calibration_from_reference(pixel_distance : Double, physical_distance : Double) -> Double

    calibration_grid_fixture

    fn calibration_grid_fixture(columns : Int, rows : Int, spacing : Double) -> Array[Point]

    calibration_is_usable

    fn calibration_is_usable(fit : CalibrationFit, maximum_rms_error : Double) -> Bool

    calibration_isotropic

    fn calibration_isotropic(fit : CalibrationFit) -> Double

    calibration_quality_score

    fn calibration_quality_score(fit : CalibrationFit, sample_count : Int) -> Double

    calibration_reference_distance

    fn calibration_reference_distance(fit : CalibrationFit, first : Point, second : Point) -> Double

    calibration_report

    fn calibration_report(fit : CalibrationFit) -> String

    calibration_residual_plot

    fn calibration_residual_plot(fit : CalibrationFit, width : Int, height : Int) -> GrayImage

    calibration_rotation

    fn calibration_rotation(fit : CalibrationFit) -> Double

    calibration_roundtrip_error

    fn calibration_roundtrip_error(fit : AffineTransform, points : Array[Point]) -> Double

    calibration_scale

    fn calibration_scale(fit : CalibrationFit) -> Vector2

    calibration_scale_report

    fn calibration_scale_report(fit : CalibrationFit) -> String

    calibration_transform_at

    fn calibration_transform_at(fit : CalibrationFit, _point : Point) -> AffineTransform

    calibration_translate_origin

    fn calibration_translate_origin(fit : CalibrationFit, origin : Point) -> AffineTransform

    calibration_validate_grid

    fn calibration_validate_grid(source : Array[Point], target : Array[Point], maximum_error : Double) -> Array[PipelineDiagnostic]

    caliper_config_report

    fn caliper_config_report(config : CaliperConfig) -> String

    caliper_direction

    fn caliper_direction(config : CaliperConfig) -> Vector2

    caliper_is_valid

    fn caliper_is_valid(config : CaliperConfig) -> Bool

    caliper_length

    fn caliper_length(config : CaliperConfig) -> Double

    caliper_midpoint

    fn caliper_midpoint(config : CaliperConfig) -> Point

    caliper_suite_report

    fn caliper_suite_report(result : PipelineResult, part_id : String) -> String

    caliper_suite_spread

    fn caliper_suite_spread(result : PipelineResult) -> Double

    caliper_suite_widths

    fn caliper_suite_widths(result : PipelineResult) -> Array[Double]

    capability_index

    fn capability_index(values : Array[Double], lower : Double, upper : Double) -> Double

    centroid_of_points

    fn centroid_of_points(points : Array[Point]) -> Point

    chamfer_distance

    fn chamfer_distance(first : Array[Point], second : Array[Point]) -> Double

    checker_fixture

    fn checker_fixture(width : Int, height : Int, cell : Int) -> GrayImage

    choose_edge_pair

    fn choose_edge_pair(profile : ProfileSummary, minimum_spacing : Double) -> Array[EdgePoint]

    circle_fit_error

    fn circle_fit_error(points : Array[Point]) -> Double

    circle_fixture

    fn circle_fixture(width : Int, height : Int, center : Point, radius : Double, background : Double, foreground : Double) -> GrayImage

    circle_residuals

    fn circle_residuals(circle : Circle, points : Array[Point]) -> Array[Double]

    circle_roundness

    fn circle_roundness(circle : Circle) -> Double

    circle_to_string

    fn circle_to_string(circle : Circle) -> String

    circular_runout

    fn circular_runout(points : Array[Point], reference : Point) -> Double

    clamp_double

    fn clamp_double(value : Double, lower : Double, upper : Double) -> Double

    column_statistics

    fn column_statistics(image : GrayImage) -> Array[StatsSummary]

    combine_rois

    fn combine_rois(rois : Array[Roi], width : Int, height : Int) -> BinaryMask

    compare_batches

    fn compare_batches(first : BatchRun, second : BatchRun) -> Array[Measurement]

    compare_quality

    fn compare_quality(first : QualitySummary, second : QualitySummary) -> Int

    compare_templates

    fn compare_templates(image : GrayImage, first : GrayImage, second : GrayImage) -> Int

    component_aspect_ratio

    fn component_aspect_ratio(component : Component) -> Double

    component_dimensions_text

    fn component_dimensions_text(component : Component) -> String

    component_fill_ratio

    fn component_fill_ratio(component : Component) -> Double

    component_labels

    fn component_labels(mask : BinaryMask) -> Array[Int]

    component_mask

    fn component_mask(mask : BinaryMask, label : Int) -> BinaryMask

    component_pixels

    fn component_pixels(mask : BinaryMask, label : Int) -> Array[Point]

    components_sorted_by_area

    fn components_sorted_by_area(mask : BinaryMask, descending? : Bool) -> Array[Component]

    confidence_from_uncertainty

    fn confidence_from_uncertainty(measurement : Measurement, uncertainty : UncertaintyEstimate, tolerance : Tolerance) -> Double

    confidence_interval

    fn confidence_interval(values : Array[Double], z_score : Double) -> DoubleBounds

    contour_compactness

    fn contour_compactness(points : Array[Point]) -> Double

    contour_curvature

    fn contour_curvature(points : Array[Point]) -> Array[Double]

    contour_loops

    fn contour_loops(mask : BinaryMask) -> Array[Array[Point]]

    contour_points

    fn contour_points(mask : BinaryMask) -> Array[Point]

    contract_diagnostics_calibration

    fn contract_diagnostics_calibration(fit : CalibrationFit) -> Array[PipelineDiagnostic]

    contract_diagnostics_image

    fn contract_diagnostics_image(image : GrayImage) -> Array[PipelineDiagnostic]

    contract_diagnostics_mask

    fn contract_diagnostics_mask(mask : BinaryMask) -> Array[PipelineDiagnostic]

    contract_diagnostics_points

    fn contract_diagnostics_points(points : Array[Point], minimum : Int) -> Array[PipelineDiagnostic]

    contract_diagnostics_tolerance

    fn contract_diagnostics_tolerance(tolerance : Tolerance) -> Array[PipelineDiagnostic]

    contract_merge

    fn contract_merge(first : Array[PipelineDiagnostic], second : Array[PipelineDiagnostic]) -> Array[PipelineDiagnostic]

    contract_passed

    fn contract_passed(diagnostics : Array[PipelineDiagnostic]) -> Bool

    contract_summary

    fn contract_summary(diagnostics : Array[PipelineDiagnostic]) -> String

    contrast_quality

    fn contrast_quality(image : GrayImage, bounds : Bounds) -> Double

    convert_measurement_unit

    fn convert_measurement_unit(measurement : Measurement, target : String) -> Measurement

    convert_tolerance_unit

    fn convert_tolerance_unit(tolerance : Tolerance, target : String) -> Tolerance

    convex_hull

    fn convex_hull(points : Array[Point]) -> Array[Point]

    convolve3

    fn convolve3(image : GrayImage, kernel : Array[Double], policy? : BorderPolicy) -> GrayImage

    convolve_separable

    fn convolve_separable(image : GrayImage, kernel : Array[Double], policy? : BorderPolicy) -> GrayImage

    correlation_values

    fn correlation_values(a : Array[Double], b : Array[Double]) -> Double

    count_true_neighbors

    fn count_true_neighbors(mask : BinaryMask, x : Int, y : Int, radius : Int) -> Int

    covariance_values

    fn covariance_values(a : Array[Double], b : Array[Double]) -> Double

    crop_image

    fn crop_image(image : GrayImage, bounds : Bounds) -> GrayImage

    decision_counts

    fn decision_counts(measurements : Array[Measurement]) -> Array[Int]

    decision_penalty

    fn decision_penalty(decision : MeasurementDecision) -> Double

    decision_streak

    fn decision_streak(decisions : Array[MeasurementDecision], target : MeasurementDecision) -> Int

    default_caliper

    fn default_caliper(image : GrayImage) -> CaliperConfig

    default_edge_policy

    fn default_edge_policy() -> EdgePolicy

    default_roi

    fn default_roi(image : GrayImage) -> Roi

    default_tolerance

    fn default_tolerance(nominal : Double, unit : String) -> Tolerance

    describe_samples

    fn describe_samples(values : Array[Double]) -> StatsSummary

    descriptor_distance

    fn descriptor_distance(first : Array[Double], second : Array[Double]) -> Double

    detect_circle_from_points

    fn detect_circle_from_points(points : Array[Point]) -> Circle

    detect_dominant_line

    fn detect_dominant_line(edges : Array[EdgePoint]) -> Line

    deterministic_fixture_inventory

    fn deterministic_fixture_inventory() -> Array[String]

    deterministic_sort_components

    fn deterministic_sort_components(components : Array[Component]) -> Array[Component]

    deterministic_sort_measurements

    fn deterministic_sort_measurements(measurements : Array[Measurement]) -> Array[Measurement]

    deterministic_sort_values

    fn deterministic_sort_values(values : Array[Double]) -> Array[Double]

    diagnostic_error

    fn diagnostic_error(stage : String, detail : String) -> PipelineDiagnostic

    diagnostic_event

    fn diagnostic_event(code : String, stage : String, detail : String, value : Double) -> DiagnosticEvent

    diagnostic_ok

    fn diagnostic_ok(stage : String, detail : String) -> PipelineDiagnostic

    diagnostic_severity

    fn diagnostic_severity(events : Array[PipelineDiagnostic]) -> MeasurementDecision

    diagnostic_warning

    fn diagnostic_warning(stage : String, detail : String) -> PipelineDiagnostic

    diagnostics_filter

    fn diagnostics_filter(events : Array[DiagnosticEvent], code : String) -> Array[DiagnosticEvent]

    diagnostics_for_batch

    fn diagnostics_for_batch(batch : BatchRun) -> Array[DiagnosticEvent]

    diagnostics_for_calibration

    fn diagnostics_for_calibration(fit : CalibrationFit) -> Array[DiagnosticEvent]

    diagnostics_for_image

    fn diagnostics_for_image(image : GrayImage) -> Array[DiagnosticEvent]

    diagnostics_max

    fn diagnostics_max(events : Array[DiagnosticEvent]) -> DiagnosticEvent?

    diagnostics_merge

    fn diagnostics_merge(groups : Array[Array[DiagnosticEvent]]) -> Array[DiagnosticEvent]

    diagnostics_ok

    fn diagnostics_ok(events : Array[PipelineDiagnostic]) -> Bool

    diagnostics_summary

    fn diagnostics_summary(events : Array[DiagnosticEvent]) -> StatsSummary

    diagnostics_text

    fn diagnostics_text(events : Array[DiagnosticEvent]) -> String

    diagnostics_to_markdown

    fn diagnostics_to_markdown(events : Array[PipelineDiagnostic]) -> String

    diagonal_edge_fixture

    fn diagonal_edge_fixture(width : Int, height : Int, slope : Double, intercept : Double) -> GrayImage

    distance

    fn distance(a : Point, b : Point) -> Double

    distance_transform

    fn distance_transform(mask : BinaryMask) -> GrayImage

    downsample_half

    fn downsample_half(image : GrayImage) -> GrayImage

    edge_confidence

    fn edge_confidence(edge : EdgePoint, profile_noise : Double, threshold : Double) -> Double

    edge_distance_along_ray

    fn edge_distance_along_ray(edge : EdgePoint, center : Point, direction : Vector2) -> Double

    edge_map

    fn edge_map(image : GrayImage, low : Double, high : Double) -> EdgeMapSummary

    edge_map_circle_fit

    fn edge_map_circle_fit(summary : EdgeMapSummary) -> Circle

    edge_map_close

    fn edge_map_close(summary : EdgeMapSummary, radius : Int) -> EdgeMapSummary

    edge_map_components

    fn edge_map_components(summary : EdgeMapSummary) -> Array[Component]

    edge_map_dilate

    fn edge_map_dilate(summary : EdgeMapSummary, radius : Int) -> EdgeMapSummary

    edge_map_largest

    fn edge_map_largest(summary : EdgeMapSummary) -> Component

    edge_map_line_fit

    fn edge_map_line_fit(summary : EdgeMapSummary) -> Line

    edge_map_overlay

    fn edge_map_overlay(image : GrayImage, summary : EdgeMapSummary, value : Double) -> GrayImage

    edge_map_quality

    fn edge_map_quality(summary : EdgeMapSummary) -> Double

    edge_map_report

    fn edge_map_report(summary : EdgeMapSummary) -> String

    edge_map_skeleton

    fn edge_map_skeleton(summary : EdgeMapSummary) -> BinaryMask

    edge_map_strengths

    fn edge_map_strengths(summary : EdgeMapSummary, magnitude : GrayImage) -> Array[Double]

    edge_map_thin

    fn edge_map_thin(summary : EdgeMapSummary) -> EdgeMapSummary

    edge_map_threshold

    fn edge_map_threshold(image : GrayImage, threshold : Double) -> EdgeMapSummary

    edge_pair_midpoint

    fn edge_pair_midpoint(edges : Array[EdgePoint]) -> Point

    edge_pair_orientation

    fn edge_pair_orientation(edges : Array[EdgePoint]) -> Double

    edge_pair_width

    fn edge_pair_width(edges : Array[EdgePoint], direction : Vector2) -> Double

    edge_points

    fn edge_points(summary : EdgeMapSummary) -> Array[EdgePoint]

    edge_polarity_count

    fn edge_polarity_count(profile : ProfileSummary, polarity : Int) -> Int

    edge_profile

    fn edge_profile(image : GrayImage, start : Point, finish : Point, steps? : Int) -> Array[ProfileSample]

    edge_quality

    fn edge_quality(samples : Array[ProfileSample], threshold : Double) -> QualitySummary

    ellipse_area

    fn ellipse_area(ellipse : Ellipse) -> Double

    ellipse_from_points

    fn ellipse_from_points(points : Array[Point]) -> Ellipse

    ellipse_perimeter_approximation

    fn ellipse_perimeter_approximation(ellipse : Ellipse) -> Double

    entropy_image

    fn entropy_image(image : GrayImage, bins : Int) -> Double

    expand_roi

    fn expand_roi(roi : Roi, padding : Int, image : GrayImage) -> Roi

    exponential_smooth

    fn exponential_smooth(values : Array[Double], alpha : Double) -> Array[Double]

    feature_to_measurement

    fn feature_to_measurement(feature : FeatureMeasurement, nominal : Double, lower : Double, upper : Double) -> Measurement

    fill_mask_holes

    fn fill_mask_holes(mask : BinaryMask) -> BinaryMask

    filter_components_by_area

    fn filter_components_by_area(mask : BinaryMask, minimum : Int, maximum : Int) -> BinaryMask

    first_failure

    fn first_failure(decisions : Array[MeasurementDecision]) -> Int?

    fit_affine

    fn fit_affine(source : Array[Point], target : Array[Point]) -> CalibrationFit

    fit_line

    fn fit_line(points : Array[Point]) -> Line

    fixture_checksum_suite

    fn fixture_checksum_suite() -> Array[Double]

    fixture_measurement

    fn fixture_measurement(image : GrayImage, start : Point, finish : Point, nominal : Double) -> Measurement

    focus_score

    fn focus_score(image : GrayImage) -> Double

    frame_acceptance_rate

    fn frame_acceptance_rate(results : Array[PipelineResult]) -> Double

    frame_checksum

    fn frame_checksum(image : GrayImage) -> Double

    frame_component_count

    fn frame_component_count(image : GrayImage) -> Int

    frame_contour_count

    fn frame_contour_count(image : GrayImage) -> Int

    frame_diagnostics

    fn frame_diagnostics(image : GrayImage, config : CaliperConfig, tolerance : Tolerance) -> Array[DiagnosticEvent]

    frame_dimensions

    fn frame_dimensions(image : GrayImage) -> Bounds

    frame_dynamic_range

    fn frame_dynamic_range(image : GrayImage) -> Double

    frame_edge_count

    fn frame_edge_count(image : GrayImage) -> Int

    frame_entropy

    fn frame_entropy(image : GrayImage) -> Double

    frame_focus

    fn frame_focus(image : GrayImage) -> Double

    frame_health_text

    fn frame_health_text(image : GrayImage) -> String

    frame_noise

    fn frame_noise(image : GrayImage) -> Double

    frame_quality

    fn frame_quality(image : GrayImage) -> QualitySummary

    frame_quality_score

    fn frame_quality_score(image : GrayImage) -> Double

    frame_report

    fn frame_report(results : Array[PipelineResult]) -> String

    frame_sharpness

    fn frame_sharpness(image : GrayImage) -> Double

    full_frame_roi

    fn full_frame_roi(image : GrayImage) -> Roi

    gauge_risk_score

    fn gauge_risk_score(profile : ProfileSummary, tolerance : Tolerance, measurement : Double) -> Double

    gauge_width

    fn gauge_width(image : GrayImage, start : Point, finish : Point, threshold? : Double) -> Double

    gaussian_blur

    fn gaussian_blur(image : GrayImage, radius : Int, sigma : Double) -> GrayImage

    generate_caliper_lines

    fn generate_caliper_lines(center : Point, radius : Double, count : Int) -> Array[CaliperConfig]

    geometric_median

    fn geometric_median(points : Array[Point], iterations : Int) -> Point

    gradient_magnitude

    fn gradient_magnitude(image : GrayImage) -> GrayImage

    gradient_orientation

    fn gradient_orientation(image : GrayImage) -> GrayImage

    guard_band_decision

    fn guard_band_decision(value : Double, tolerance : Tolerance, uncertainty : UncertaintyEstimate) -> MeasurementDecision

    has_true_neighbor

    fn has_true_neighbor(mask : BinaryMask, x : Int, y : Int, radius : Int) -> Bool

    hausdorff_distance

    fn hausdorff_distance(first : Array[Point], second : Array[Point]) -> Double

    histogram

    fn histogram(image : GrayImage, bins : Int, bounds? : DoubleBounds) -> Histogram

    histogram_cumulative

    fn histogram_cumulative(histogram_value : Histogram) -> Array[Int]

    histogram_quantile

    fn histogram_quantile(histogram_value : Histogram, q : Double) -> Double

    hu_like_descriptors

    fn hu_like_descriptors(points : Array[Point]) -> Array[Double]

    hysteresis_edges

    fn hysteresis_edges(image : GrayImage, low~ : Double, high~ : Double) -> BinaryMask

    illumination_uniformity

    fn illumination_uniformity(image : GrayImage) -> Double

    image_checksum

    fn image_checksum(image : GrayImage) -> Double

    image_clamp_values

    fn image_clamp_values(image : GrayImage, lower : Double, upper : Double) -> GrayImage

    image_difference_maximum

    fn image_difference_maximum(first : GrayImage, second : GrayImage) -> Double

    image_difference_mean

    fn image_difference_mean(first : GrayImage, second : GrayImage) -> Double

    image_dimensions_text

    fn image_dimensions_text(image : GrayImage) -> String

    image_dynamic_range

    fn image_dynamic_range(image : GrayImage) -> Double

    image_equal_with_tolerance

    fn image_equal_with_tolerance(first : GrayImage, second : GrayImage, tolerance : Double) -> Bool

    image_fraction

    fn image_fraction(image : GrayImage, predicate : (Double) -> Bool) -> Double

    image_histogram_probability

    fn image_histogram_probability(image : GrayImage, bins : Int) -> Array[Double]

    image_mad

    fn image_mad(image : GrayImage) -> Double

    image_mean

    fn image_mean(image : GrayImage) -> Double

    image_median

    fn image_median(image : GrayImage) -> Double

    image_minmax

    fn image_minmax(image : GrayImage) -> DoubleBounds

    image_offset_values

    fn image_offset_values(image : GrayImage, offset : Double) -> GrayImage

    image_patch

    fn image_patch(image : GrayImage, top_left : Point, width : Int, height : Int) -> GrayImage

    image_quality_flags

    fn image_quality_flags(image : GrayImage) -> Array[String]

    image_quality_score

    fn image_quality_score(image : GrayImage) -> Double

    image_range_report

    fn image_range_report(image : GrayImage) -> String

    image_scale_values

    fn image_scale_values(image : GrayImage, factor : Double) -> GrayImage

    image_signal_to_noise

    fn image_signal_to_noise(image : GrayImage, background : Double) -> Double

    image_to_mask

    fn image_to_mask(image : GrayImage, threshold : Double) -> BinaryMask

    image_value_count

    fn image_value_count(image : GrayImage, predicate : (Double) -> Bool) -> Int

    image_variance

    fn image_variance(image : GrayImage) -> Double

    inspect_batch

    fn inspect_batch(images : Array[GrayImage], config : CaliperConfig, tolerance : Tolerance) -> BatchRun

    inspect_circle

    fn inspect_circle(image : GrayImage, center : Point, radius : Double, threshold : Double, scale : Double, nominal_diameter : Double) -> PipelineResult

    inspect_edge_pair

    fn inspect_edge_pair(image : GrayImage, config : CaliperConfig, scale : Double, tolerance : Tolerance) -> PipelineResult

    inspect_rectangle

    fn inspect_rectangle(_image : GrayImage, bounds : Bounds, nominal_width : Double, nominal_height : Double, scale : Double) -> PipelineResult

    inspect_slot

    fn inspect_slot(image : GrayImage, bounds : Bounds, scale : Double, nominal : Double) -> PipelineResult

    inspection_acceptance

    fn inspection_acceptance(result : PipelineResult, minimum_confidence : Double) -> Bool

    inspection_all

    fn inspection_all(image : GrayImage, calipers : Array[CaliperConfig], tolerance : Tolerance, fit : CalibrationFit?) -> PipelineResult

    inspection_capabilities

    fn inspection_capabilities() -> Array[String]

    inspection_compare

    fn inspection_compare(first : PipelineResult, second : PipelineResult) -> Array[Measurement]

    inspection_csv

    fn inspection_csv(result : PipelineResult) -> String

    inspection_diagnostics

    fn inspection_diagnostics(result : PipelineResult) -> String

    inspection_events

    fn inspection_events(image : GrayImage, result : PipelineResult) -> Array[DiagnosticEvent]

    inspection_fingerprint

    fn inspection_fingerprint(image : GrayImage, result : PipelineResult) -> String

    inspection_markdown

    fn inspection_markdown(part_id : String, image : GrayImage, result : PipelineResult) -> String

    inspection_merge

    fn inspection_merge(first : PipelineResult, second : PipelineResult) -> PipelineResult

    inspection_quality

    fn inspection_quality(image : GrayImage, result : PipelineResult) -> QualitySummary

    inspection_report

    fn inspection_report(part_id : String, image : GrayImage, measurements : Array[Measurement], diagnostics : Array[PipelineDiagnostic]) -> MeasurementReport

    inspection_retry

    fn inspection_retry(image : GrayImage, config : CaliperConfig, tolerance : Tolerance, attempts : Int) -> PipelineResult

    inspection_status

    fn inspection_status(result : PipelineResult) -> String

    inspection_summary

    fn inspection_summary(result : PipelineResult) -> String

    inspection_version

    fn inspection_version() -> String

    inspection_with_calibration

    fn inspection_with_calibration(image : GrayImage, config : CaliperConfig, tolerance : Tolerance, fit : CalibrationFit) -> PipelineResult

    inspection_with_preprocessing

    fn inspection_with_preprocessing(image : GrayImage, config : CaliperConfig, tolerance : Tolerance, blur_radius : Int) -> PipelineResult

    inspection_with_roi

    fn inspection_with_roi(image : GrayImage, roi : Roi, config : CaliperConfig, tolerance : Tolerance) -> PipelineResult

    inspection_with_uncertainty

    fn inspection_with_uncertainty(result : PipelineResult, uncertainty : UncertaintyEstimate, tolerance : Tolerance) -> PipelineResult

    integral_image

    fn integral_image(image : GrayImage) -> GrayImage

    integral_sum

    fn integral_sum(integral : GrayImage, bounds : Bounds) -> Double

    interior_mask

    fn interior_mask(width : Int, height : Int, thickness : Int) -> BinaryMask

    interpolate_points

    fn interpolate_points(points : Array[Point], count : Int) -> Array[Point]

    is_finite

    fn is_finite(value : Double) -> Bool

    label_components

    fn label_components(mask : BinaryMask) -> Array[Component]

    largest_component

    fn largest_component(mask : BinaryMask) -> Component

    lerp

    fn lerp(a : Double, b : Double, t : Double) -> Double

    line_angle

    fn line_angle(first : Line, second : Line) -> Double

    line_angle_from_points

    fn line_angle_from_points(first : Point, second : Point) -> Double

    line_fit_error

    fn line_fit_error(points : Array[Point]) -> Double

    line_from_points

    fn line_from_points(first : Point, second : Point) -> Line

    line_intersection

    fn line_intersection(first : Line, second : Line) -> Point

    line_length

    fn line_length(points : Array[Point]) -> Double

    line_midpoint

    fn line_midpoint(_line : Line, bounds : Bounds) -> Point

    line_residuals

    fn line_residuals(line : Line, points : Array[Point]) -> Array[Double]

    line_to_string

    fn line_to_string(line : Line) -> String

    local_contrast

    fn local_contrast(image : GrayImage, radius : Int) -> GrayImage

    local_contrast_normalized

    fn local_contrast_normalized(image : GrayImage, radius : Int) -> GrayImage

    local_mean_image

    fn local_mean_image(image : GrayImage, radius : Int) -> GrayImage

    local_variance_image

    fn local_variance_image(image : GrayImage, radius : Int) -> GrayImage

    majority_filter

    fn majority_filter(mask : BinaryMask, radius : Int) -> BinaryMask

    make_benchmark_image

    fn make_benchmark_image(width : Int, height : Int) -> GrayImage

    make_benchmark_summary

    fn make_benchmark_summary() -> String

    make_csv_for_image

    fn make_csv_for_image(image : GrayImage) -> String

    make_demo_part

    fn make_demo_part() -> GrayImage

    make_json_for_image

    fn make_json_for_image(image : GrayImage, part_id : String) -> String

    make_quality_for_image

    fn make_quality_for_image(image : GrayImage) -> String

    make_report_for_image

    fn make_report_for_image(image : GrayImage, part_id : String) -> String

    map_reference_grid

    fn map_reference_grid(fit : AffineTransform, columns : Int, rows : Int, spacing_x : Double, spacing_y : Double) -> Array[Point]

    mask_dimensions_text

    fn mask_dimensions_text(mask : BinaryMask) -> String

    mask_euler_estimate

    fn mask_euler_estimate(mask : BinaryMask) -> Int

    mask_fill_ratio

    fn mask_fill_ratio(mask : BinaryMask) -> Double

    mask_perimeter

    fn mask_perimeter(mask : BinaryMask) -> Double

    mask_projection_peaks

    fn mask_projection_peaks(mask : BinaryMask, horizontal : Bool, threshold : Int) -> Array[Int]

    mask_symmetry_score

    fn mask_symmetry_score(mask : BinaryMask, horizontal : Bool) -> Double

    mask_to_image

    fn mask_to_image(mask : BinaryMask, foreground : Double, background : Double) -> GrayImage

    match_centroid

    fn match_centroid(matches : Array[MatchResult]) -> Point

    match_confidence

    fn match_confidence(match_result : MatchResult, minimum_score : Double) -> Double

    match_result_report

    fn match_result_report(match_result : MatchResult) -> String

    match_score_histogram

    fn match_score_histogram(image : GrayImage, template : GrayImage, bins : Int) -> Histogram

    match_score_map

    fn match_score_map(image : GrayImage, template : GrayImage) -> GrayImage

    maximum_value

    fn maximum_value(values : Array[Double]) -> Double

    mean_absolute_deviation

    fn mean_absolute_deviation(values : Array[Double]) -> Double

    mean_value

    fn mean_value(values : Array[Double]) -> Double

    measure_angle

    fn measure_angle(first : Point, second : Point) -> Double

    measure_caliper

    fn measure_caliper(image : GrayImage, config : CaliperConfig, tolerance : Tolerance) -> PipelineResult

    measure_caliper_with_scale

    fn measure_caliper_with_scale(image : GrayImage, config : CaliperConfig, scale : Double, tolerance : Tolerance) -> PipelineResult

    measure_circle

    fn measure_circle(circle : Circle, unit : String, scale : Double) -> Array[Measurement]

    measure_diameter

    fn measure_diameter(circle : Circle) -> Double

    measure_distance

    fn measure_distance(first : Point, second : Point) -> Double

    measure_line

    fn measure_line(points : Array[Point]) -> Line

    measure_line_feature

    fn measure_line_feature(line : Line, points : Array[Point], unit : String) -> Array[Measurement]

    measure_polygon

    fn measure_polygon(points : Array[Point], unit : String, scale : Double) -> Array[Measurement]

    measure_radius

    fn measure_radius(points : Array[Point]) -> Circle

    measure_region

    fn measure_region(region : Component, unit : String, scale : Double) -> Array[Measurement]

    measure_signed_distance

    fn measure_signed_distance(line : Line, point : Point) -> Double

    measurement_bounds

    fn measurement_bounds(measurements : Array[Measurement]) -> DoubleBounds

    measurement_by_name

    fn measurement_by_name(measurements : Array[Measurement], name : String) -> Measurement?

    measurement_confidence

    fn measurement_confidence(measurement : Measurement, tolerance : Tolerance, quality : Double) -> Double

    measurement_delta

    fn measurement_delta(first : Array[Measurement], second : Array[Measurement]) -> Array[Measurement]

    measurement_equal_with_tolerance

    fn measurement_equal_with_tolerance(first : Measurement, second : Measurement, tolerance : Double) -> Bool

    measurement_names

    fn measurement_names(measurements : Array[Measurement]) -> Array[String]

    measurement_passes

    fn measurement_passes(measurement : Measurement) -> Bool

    measurement_quality_flags

    fn measurement_quality_flags(measurement : Measurement, tolerance : Tolerance) -> Array[String]

    measurement_quantiles

    fn measurement_quantiles(measurements : Array[Measurement]) -> Array[Double]

    measurement_score

    fn measurement_score(measurement : Measurement, tolerance : Tolerance) -> Double

    measurement_values

    fn measurement_values(measurements : Array[Measurement]) -> Array[Double]

    measurement_with_uncertainty

    fn measurement_with_uncertainty(measurement : Measurement, uncertainty : UncertaintyEstimate) -> String

    measurements_within

    fn measurements_within(measurements : Array[Measurement], lower : Double, upper : Double) -> Array[Measurement]

    medial_axis

    fn medial_axis(mask : BinaryMask, minimum_distance : Double) -> BinaryMask

    median_filter

    fn median_filter(image : GrayImage, radius~ : Int) -> GrayImage

    median_value

    fn median_value(values : Array[Double]) -> Double

    merge_nearby_edges

    fn merge_nearby_edges(edges : Array[EdgePoint], distance_limit : Double) -> Array[EdgePoint]

    merge_pipeline_results

    fn merge_pipeline_results(results : Array[PipelineResult]) -> PipelineResult

    minimum_value

    fn minimum_value(values : Array[Double]) -> Double

    moving_average

    fn moving_average(values : Array[Double], window : Int) -> Array[Double]

    multi_angle_widths

    fn multi_angle_widths(image : GrayImage, center : Point, angles : Array[Double], length : Double, threshold : Double) -> Array[Double]

    multi_part_fixture

    fn multi_part_fixture() -> GrayImage

    nearest_edge

    fn nearest_edge(edges : Array[EdgePoint], point : Point) -> EdgePoint?

    nearest_reference

    fn nearest_reference(point : Point, references : Array[Point]) -> Point

    noisy_fixture

    fn noisy_fixture(image : GrayImage, amplitude : Double, seed : Int) -> GrayImage

    nominal_tolerance

    fn nominal_tolerance(nominal : Double) -> Tolerance

    non_maximum_suppression

    fn non_maximum_suppression(magnitude : GrayImage, radius : Int) -> GrayImage

    non_overlapping_rois

    fn non_overlapping_rois(rois : Array[Roi]) -> Bool

    normalize_angle

    fn normalize_angle(angle : Double) -> Double

    normalize_measurements

    fn normalize_measurements(measurements : Array[Measurement]) -> Array[Measurement]

    normalize_minmax

    fn normalize_minmax(image : GrayImage) -> GrayImage

    normalize_sum

    fn normalize_sum(values : Array[Double]) -> Array[Double]

    normalize_zscore

    fn normalize_zscore(image : GrayImage) -> GrayImage

    normalized_patch_score

    fn normalized_patch_score(image : GrayImage, template : GrayImage, x : Int, y : Int) -> Double

    normalized_quality

    fn normalized_quality(value : Double, lower : Double, upper : Double) -> Double

    oriented_bounds

    fn oriented_bounds(points : Array[Point], angle : Double) -> DoubleBounds

    oriented_shape_similarity

    fn oriented_shape_similarity(first : Array[Point], second : Array[Point]) -> Double

    otsu_threshold

    fn otsu_threshold(image : GrayImage) -> Double

    outlier_flags

    fn outlier_flags(values : Array[Double], z_limit : Double) -> Array[Bool]

    package_health

    fn package_health(image : GrayImage) -> Array[PipelineDiagnostic]

    package_health_text

    fn package_health_text(image : GrayImage) -> String

    pad_image

    fn pad_image(image : GrayImage, padding : Int, value : Double) -> GrayImage

    parallelism_error

    fn parallelism_error(reference : Line, candidate : Line, points : Array[Point]) -> Double

    patch_difference

    fn patch_difference(first : GrayImage, second : GrayImage) -> GrayImage

    patch_mean_squared_error

    fn patch_mean_squared_error(first : GrayImage, second : GrayImage) -> Double

    patch_peak_signal_to_noise

    fn patch_peak_signal_to_noise(first : GrayImage, second : GrayImage) -> Double

    patch_values

    fn patch_values(image : GrayImage, bounds : Bounds) -> Array[Double]

    percentile_threshold

    fn percentile_threshold(image : GrayImage, q : Double) -> Double

    percentile_value

    fn percentile_value(values : Array[Double], q : Double) -> Double

    perpendicularity_error

    fn perpendicularity_error(first : Line, second : Line) -> Double

    pipeline_decision

    fn pipeline_decision(result : PipelineResult) -> MeasurementDecision

    pipeline_has_error

    fn pipeline_has_error(result : PipelineResult) -> Bool

    pipeline_notes

    fn pipeline_notes(result : PipelineResult) -> Array[String]

    pipeline_timeline

    fn pipeline_timeline(results : Array[PipelineResult]) -> Array[Double]

    pixel_tolerance

    fn pixel_tolerance(nominal : Double) -> Tolerance

    point_at_distance

    fn point_at_distance(start : Point, finish : Point, distance_from_start : Double) -> Point

    point_inside_polygon

    fn point_inside_polygon(point : Point, polygon : Array[Point]) -> Bool

    point_line_distance

    fn point_line_distance(first : Point, second : Point, point : Point) -> Double

    point_moments

    fn point_moments(points : Array[Point]) -> Array[Double]

    point_set_spread

    fn point_set_spread(points : Array[Point]) -> Double

    point_to_string

    fn point_to_string(point : Point) -> String

    polygon_area

    fn polygon_area(points : Array[Point]) -> Double

    polygon_bounds

    fn polygon_bounds(points : Array[Point]) -> Bounds

    polygon_centroid

    fn polygon_centroid(points : Array[Point]) -> Point

    polygon_distance

    fn polygon_distance(point : Point, polygon : Array[Point]) -> Double

    polygon_metrics

    fn polygon_metrics(points : Array[Point]) -> PolygonMetrics

    polygon_perimeter

    fn polygon_perimeter(points : Array[Point]) -> Double

    polyline_length

    fn polyline_length(points : Array[Point], closed? : Bool) -> Double

    polyline_normal

    fn polyline_normal(points : Array[Point], index : Int) -> Vector2

    polyline_tangent

    fn polyline_tangent(points : Array[Point], index : Int) -> Vector2

    pooled_standard_deviation

    fn pooled_standard_deviation(groups : Array[Array[Double]]) -> Double

    principal_orientation

    fn principal_orientation(points : Array[Point]) -> Double

    process_frame

    fn process_frame(image : GrayImage, config : CaliperConfig, tolerance : Tolerance) -> PipelineResult

    process_frames

    fn process_frames(images : Array[GrayImage], config : CaliperConfig, tolerance : Tolerance) -> BatchRun

    process_pyramid

    fn process_pyramid(image : GrayImage, config : CaliperConfig, tolerance : Tolerance, levels : Int) -> PipelineResult

    profile_baseline

    fn profile_baseline(samples : Array[ProfileSample]) -> Double

    profile_best_shift

    fn profile_best_shift(first : Array[ProfileSample], second : Array[ProfileSample], maximum_shift : Int) -> Int

    profile_cross_correlation

    fn profile_cross_correlation(first : Array[ProfileSample], second : Array[ProfileSample]) -> Double

    profile_derivative

    fn profile_derivative(samples : Array[ProfileSample]) -> Array[ProfileSample]

    profile_dimensions_text

    fn profile_dimensions_text(profile : ProfileSummary) -> String

    profile_distance

    fn profile_distance(samples : Array[ProfileSample]) -> Double

    profile_dynamic_range

    fn profile_dynamic_range(samples : Array[ProfileSample]) -> Double

    profile_edge_positions

    fn profile_edge_positions(profile : ProfileSummary) -> Array[Point]

    profile_edge_strengths

    fn profile_edge_strengths(profile : ProfileSummary) -> Array[Double]

    profile_energy

    fn profile_energy(samples : Array[ProfileSample]) -> Double

    profile_exponential_smooth

    fn profile_exponential_smooth(samples : Array[ProfileSample], alpha : Double) -> Array[ProfileSample]

    profile_fixture

    fn profile_fixture(length : Int, first_edge : Int, second_edge : Int, low : Double, high : Double) -> Array[ProfileSample]

    profile_from_values

    fn profile_from_values(values : Array[Double], start : Point, finish : Point) -> Array[ProfileSample]

    profile_gradient_energy

    fn profile_gradient_energy(samples : Array[ProfileSample]) -> Double

    profile_gradient_range

    fn profile_gradient_range(samples : Array[ProfileSample]) -> Double

    profile_gradients

    fn profile_gradients(samples : Array[ProfileSample]) -> Array[Double]

    profile_is_monotonic

    fn profile_is_monotonic(samples : Array[ProfileSample]) -> Bool

    profile_normalize

    fn profile_normalize(samples : Array[ProfileSample]) -> Array[ProfileSample]

    profile_outlier_repaired

    fn profile_outlier_repaired(samples : Array[ProfileSample], z_limit : Double) -> Array[ProfileSample]

    profile_peaks

    fn profile_peaks(samples : Array[ProfileSample], threshold : Double) -> Array[EdgePoint]

    profile_quality

    fn profile_quality(profile : ProfileSummary, minimum_signal_to_noise : Double) -> QualitySummary

    profile_quality_flags

    fn profile_quality_flags(profile : ProfileSummary) -> Array[String]

    profile_quantized

    fn profile_quantized(samples : Array[ProfileSample], levels : Int) -> Array[ProfileSample]

    profile_resample

    fn profile_resample(samples : Array[ProfileSample], count : Int) -> Array[ProfileSample]

    profile_sample_spacing

    fn profile_sample_spacing(samples : Array[ProfileSample]) -> Double

    profile_second_derivative

    fn profile_second_derivative(samples : Array[ProfileSample]) -> Array[ProfileSample]

    profile_smooth

    fn profile_smooth(samples : Array[ProfileSample], window : Int) -> Array[ProfileSample]

    profile_valleys

    fn profile_valleys(samples : Array[ProfileSample], threshold : Double) -> Array[EdgePoint]

    profile_values

    fn profile_values(samples : Array[ProfileSample]) -> Array[Double]

    profile_window

    fn profile_window(samples : Array[ProfileSample], first : Int, last : Int) -> Array[ProfileSample]

    profile_zero_crossings

    fn profile_zero_crossings(samples : Array[ProfileSample]) -> Array[Point]

    project_point

    fn project_point(point : Point, line : Line) -> Point

    propagate_addition

    fn propagate_addition(first : UncertaintyEstimate, second : UncertaintyEstimate) -> UncertaintyEstimate

    propagate_product

    fn propagate_product(value : Double, uncertainty : UncertaintyEstimate, factor : Double) -> UncertaintyEstimate

    propagate_scale_uncertainty

    fn propagate_scale_uncertainty(value : Double, scale : Double, scale_uncertainty : Double) -> UncertaintyEstimate

    public_project_summary

    fn public_project_summary() -> String

    pyramid_checksum

    fn pyramid_checksum(pyramid : Array[PyramidLevel]) -> Double

    pyramid_gradient

    fn pyramid_gradient(pyramid : Array[PyramidLevel]) -> Array[PyramidLevel]

    pyramid_level

    fn pyramid_level(pyramid : Array[PyramidLevel], index : Int) -> GrayImage

    pyramid_scales

    fn pyramid_scales(pyramid : Array[PyramidLevel]) -> Array[Double]

    quality_diagnostics

    fn quality_diagnostics(image : GrayImage, profile : ProfileSummary) -> Array[DiagnosticEvent]

    quality_gate

    fn quality_gate(summary : QualitySummary, minimum_confidence : Double) -> Bool

    quality_score_report

    fn quality_score_report(image : GrayImage, profile : ProfileSummary, measurements : Array[Measurement]) -> String

    quality_summary_text

    fn quality_summary_text(summary : QualitySummary) -> String

    radial_caliper_profile

    fn radial_caliper_profile(image : GrayImage, center : Point, angle : Double, length : Double, samples : Int) -> Array[ProfileSample]

    radial_circle_measurement

    fn radial_circle_measurement(image : GrayImage, center : Point, angles : Array[Double], length : Double, threshold : Double, _unit : String) -> Circle

    radial_edge_points

    fn radial_edge_points(image : GrayImage, center : Point, angles : Array[Double], length : Double, threshold : Double) -> Array[EdgePoint]

    radial_profile

    fn radial_profile(points : Array[Point], center : Point, bins : Int) -> Array[Double]

    ramp_fixture

    fn ramp_fixture(width : Int, height : Int, horizontal? : Bool) -> GrayImage

    rectangle_fixture

    fn rectangle_fixture(width : Int, height : Int, left : Int, top : Int, right : Int, bottom : Int, background : Double, foreground : Double) -> GrayImage

    reflect_point

    fn reflect_point(point : Point, line : Line) -> Point

    reflect_points

    fn reflect_points(points : Array[Point], line : Line) -> Array[Point]

    region_height

    fn region_height(mask : BinaryMask) -> Double

    region_width

    fn region_width(mask : BinaryMask) -> Double

    reject_outliers

    fn reject_outliers(values : Array[Double], z_limit : Double) -> Array[Double]

    remove_large_objects

    fn remove_large_objects(mask : BinaryMask, maximum_area : Int) -> BinaryMask

    remove_small_objects

    fn remove_small_objects(mask : BinaryMask, minimum_area : Int) -> BinaryMask

    render_batch_csv

    fn render_batch_csv(batch : BatchRun) -> String

    render_batch_json

    fn render_batch_json(batch : BatchRun) -> String

    render_batch_markdown

    fn render_batch_markdown(batch : BatchRun) -> String

    render_calibration_markdown

    fn render_calibration_markdown(fit : CalibrationFit) -> String

    render_component_json

    fn render_component_json(component : Component) -> String

    render_component_table

    fn render_component_table(components : Array[Component]) -> String

    render_components_json

    fn render_components_json(components : Array[Component]) -> String

    render_diagnostics_csv

    fn render_diagnostics_csv(events : Array[DiagnosticEvent]) -> String

    render_edges_csv

    fn render_edges_csv(edges : Array[EdgePoint]) -> String

    render_full_report

    fn render_full_report(part_id : String, image : GrayImage, result : PipelineResult, toolchain : String) -> String

    render_histogram_text

    fn render_histogram_text(histogram : Histogram) -> String

    render_markdown_report

    fn render_markdown_report(report : MeasurementReport) -> String

    render_measurement_json

    fn render_measurement_json(measurement : Measurement) -> String

    render_measurement_table

    fn render_measurement_table(table : MeasurementTable) -> String

    render_measurements_csv

    fn render_measurements_csv(measurements : Array[Measurement]) -> String

    render_pipeline_markdown

    fn render_pipeline_markdown(result : PipelineResult, part_id : String) -> String

    render_profile_csv

    fn render_profile_csv(profile : ProfileSummary) -> String

    render_quality_markdown

    fn render_quality_markdown(summary : QualitySummary) -> String

    render_summary_csv

    fn render_summary_csv(summary : MeasurementSummary) -> String

    render_summary_json

    fn render_summary_json(summary : MeasurementSummary) -> String

    repeat_caliper

    fn repeat_caliper(image : GrayImage, config : CaliperConfig, tolerance : Tolerance, repetitions : Int) -> StatsSummary

    repeatability

    fn repeatability(values : Array[Double]) -> Double

    repeatability_limit

    fn repeatability_limit(values : Array[Double], multiplier : Double) -> Double

    replace_non_finite_image

    fn replace_non_finite_image(image : GrayImage, replacement : Double) -> GrayImage

    report_contains_failures

    fn report_contains_failures(text : String) -> Bool

    fn report_footer(toolchain : String) -> String

    report_header

    fn report_header(title : String, part_id : String) -> String

    report_is_well_formed

    fn report_is_well_formed(text : String) -> Bool

    report_line_count

    fn report_line_count(text : String) -> Int

    report_measurement_count

    fn report_measurement_count(report : MeasurementReport) -> Int

    report_measurement_names

    fn report_measurement_names(text : String) -> Array[String]

    report_status_line

    fn report_status_line(measurements : Array[Measurement]) -> String

    reproducibility_between_groups

    fn reproducibility_between_groups(groups : Array[Array[Double]]) -> Double

    require_calibration

    fn require_calibration(fit : CalibrationFit) -> Bool

    require_circle_points

    fn require_circle_points(points : Array[Point]) -> Bool

    require_image

    fn require_image(image : GrayImage) -> Bool

    require_line_points

    fn require_line_points(points : Array[Point]) -> Bool

    require_mask

    fn require_mask(mask : BinaryMask) -> Bool

    require_non_empty_points

    fn require_non_empty_points(points : Array[Point]) -> Bool

    require_tolerance

    fn require_tolerance(tolerance : Tolerance) -> Bool

    residual_summary

    fn residual_summary(fit : CalibrationFit) -> StatsSummary

    resize_bilinear

    fn resize_bilinear(image : GrayImage, width : Int, height : Int) -> GrayImage

    ring_fixture

    fn ring_fixture(width : Int, height : Int, center : Point, inner_radius : Double, outer_radius : Double) -> GrayImage

    robust_circle_fit

    fn robust_circle_fit(points : Array[Point], iterations : Int, cutoff : Double) -> Circle

    robust_line_fit

    fn robust_line_fit(points : Array[Point], iterations : Int, cutoff : Double) -> Line

    robust_mean

    fn robust_mean(values : Array[Double], trim_fraction? : Double) -> Double

    roi_centroid

    fn roi_centroid(roi : Roi) -> Point

    roi_components

    fn roi_components(roi : Roi, image : GrayImage, threshold : Double) -> Array[Component]

    roi_contrast

    fn roi_contrast(roi : Roi, image : GrayImage) -> Double

    roi_edge_density

    fn roi_edge_density(roi : Roi, image : GrayImage, threshold : Double) -> Double

    roi_grid

    fn roi_grid(image : GrayImage, columns : Int, rows : Int, margin : Int) -> Array[Roi]

    roi_report

    fn roi_report(roi : Roi, image : GrayImage) -> String

    rolling_decisions

    fn rolling_decisions(values : Array[Double], tolerance : Tolerance, width : Int) -> Array[MeasurementDecision]

    rotate_point

    fn rotate_point(point : Point, center : Point, angle : Double) -> Point

    rotate_points

    fn rotate_points(points : Array[Point], angle : Double) -> Array[Point]

    rotated_rectangle_fixture

    fn rotated_rectangle_fixture(width : Int, height : Int, center : Point, rectangle_width : Double, rectangle_height : Double, angle : Double) -> GrayImage

    round_to

    fn round_to(value : Double, decimals : Int) -> Double

    row_statistics

    fn row_statistics(image : GrayImage) -> Array[StatsSummary]

    run_caliper_suite

    fn run_caliper_suite(image : GrayImage, configs : Array[CaliperConfig], tolerance : Tolerance) -> PipelineResult

    run_default_caliper

    fn run_default_caliper(image : GrayImage) -> PipelineResult

    run_default_inspection

    fn run_default_inspection(image : GrayImage) -> String

    safe_bounds

    fn safe_bounds(width : Int, height : Int, bounds : Bounds) -> Bounds

    safe_calibration_report

    fn safe_calibration_report(fit : CalibrationFit) -> String

    safe_contour_metrics

    fn safe_contour_metrics(mask : BinaryMask) -> PolygonMetrics

    safe_fit_affine

    fn safe_fit_affine(source : Array[Point], target : Array[Point]) -> CalibrationFit?

    safe_fit_circle

    fn safe_fit_circle(points : Array[Point]) -> Circle?

    safe_fit_line

    fn safe_fit_line(points : Array[Point]) -> Line?

    safe_label_components

    fn safe_label_components(mask : BinaryMask) -> Array[Component]

    safe_measure_caliper

    fn safe_measure_caliper(image : GrayImage, config : CaliperConfig, tolerance : Tolerance) -> PipelineResult

    safe_pixel

    fn safe_pixel(image : GrayImage, point : Point, default : Double) -> Double

    sanitize_image

    fn sanitize_image(image : GrayImage, lower : Double, upper : Double) -> GrayImage

    saturation_fraction

    fn saturation_fraction(image : GrayImage, lower : Double, upper : Double) -> Double

    scale_points

    fn scale_points(points : Array[Point], center : Point, factor : Double) -> Array[Point]

    segment_distance

    fn segment_distance(first : Point, second : Point, point : Point) -> Double

    segment_projection

    fn segment_projection(first : Point, second : Point, point : Point) -> Point

    shape_compactness

    fn shape_compactness(points : Array[Point]) -> Double

    shape_extent

    fn shape_extent(points : Array[Point]) -> Double

    shape_similarity

    fn shape_similarity(first : Array[Point], second : Array[Point]) -> Double

    sharpness_score

    fn sharpness_score(image : GrayImage) -> Double

    shrink_roi

    fn shrink_roi(roi : Roi, padding : Int, image : GrayImage) -> Roi

    simplify_polygon

    fn simplify_polygon(points : Array[Point], tolerance : Double) -> Array[Point]

    sliding_window

    fn sliding_window(values : Array[Double], width : Int, step : Int) -> Array[Array[Double]]

    slot_fixture

    fn slot_fixture(width : Int, height : Int, center : Point, slot_width : Double, slot_height : Double) -> GrayImage

    sobel_x

    fn sobel_x(image : GrayImage) -> GrayImage

    sobel_y

    fn sobel_y(image : GrayImage) -> GrayImage

    sort_edges_by_distance

    fn sort_edges_by_distance(edges : Array[EdgePoint], center : Point, direction : Vector2) -> Array[EdgePoint]

    stability_from_repetitions

    fn stability_from_repetitions(values : Array[Double], maximum_deviation : Double) -> Bool

    stable_checksum

    fn stable_checksum(values : Array[Double]) -> Double

    stable_checksum_batch

    fn stable_checksum_batch(batch : BatchRun) -> Double

    stable_checksum_image

    fn stable_checksum_image(image : GrayImage) -> Double

    stable_checksum_measurements

    fn stable_checksum_measurements(measurements : Array[Measurement]) -> Double

    stable_measurement_order

    fn stable_measurement_order(measurements : Array[Measurement]) -> Array[Measurement]

    standard_uncertainty

    fn standard_uncertainty(values : Array[Double]) -> UncertaintyEstimate

    strongest_edges

    fn strongest_edges(edges : Array[EdgePoint], minimum_strength : Double) -> Array[EdgePoint]

    subtract_profile_baseline

    fn subtract_profile_baseline(samples : Array[ProfileSample]) -> Array[ProfileSample]

    suite_csv

    fn suite_csv(result : PipelineResult) -> String

    suite_decision

    fn suite_decision(result : PipelineResult) -> MeasurementDecision

    suite_markdown

    fn suite_markdown(result : PipelineResult, part_id : String) -> String

    suite_merge

    fn suite_merge(first : PipelineResult, second : PipelineResult) -> PipelineResult

    suite_result

    fn suite_result(measurements : Array[Measurement]) -> PipelineResult

    suite_statistics

    fn suite_statistics(result : PipelineResult) -> StatsSummary

    sum_values

    fn sum_values(values : Array[Double]) -> Double

    summarize_profile

    fn summarize_profile(samples : Array[ProfileSample], threshold : Double, mode? : EdgeMode) -> ProfileSummary

    summary_dimensions_text

    fn summary_dimensions_text(summary : MeasurementSummary) -> String

    supported_measurements

    fn supported_measurements() -> Array[String]

    supported_report_formats

    fn supported_report_formats() -> Array[String]

    supported_targets

    fn supported_targets() -> Array[String]

    suppress_nearby_matches

    fn suppress_nearby_matches(matches : Array[MatchResult], radius : Double) -> Array[MatchResult]

    template_candidates

    fn template_candidates(image : GrayImage, template : GrayImage, minimum_score : Double, maximum_count : Int) -> Array[MatchResult]

    texture_noise

    fn texture_noise(image : GrayImage) -> Double

    threshold_by_policy

    fn threshold_by_policy(image : GrayImage, threshold : PixelThreshold) -> BinaryMask

    threshold_edges_in_roi

    fn threshold_edges_in_roi(roi : Roi, image : GrayImage, threshold : Double) -> BinaryMask

    threshold_image

    fn threshold_image(image : GrayImage, threshold : Double) -> BinaryMask

    timeline_summary

    fn timeline_summary(results : Array[PipelineResult]) -> StatsSummary

    to_feature_measurement

    fn to_feature_measurement(name : String, measurement : Measurement, confidence : Double) -> FeatureMeasurement

    tolerance_guard_band

    fn tolerance_guard_band(tolerance : Tolerance, uncertainty : UncertaintyEstimate) -> Tolerance

    transform_points

    fn transform_points(transform : AffineTransform, points : Array[Point]) -> Array[Point]

    transform_residuals

    fn transform_residuals(transform : AffineTransform, source : Array[Point], target : Array[Point]) -> Array[Double]

    transform_to_string

    fn transform_to_string(transform : AffineTransform) -> String

    translate_points

    fn translate_points(points : Array[Point], dx : Double, dy : Double) -> Array[Point]

    triangle_area

    fn triangle_area(first : Point, second : Point, third : Point) -> Double

    triangle_orientation

    fn triangle_orientation(first : Point, second : Point, third : Point) -> Int

    try_calibrate_anisotropic

    fn try_calibrate_anisotropic(pixel_x : Double, pixel_y : Double, physical_x : Double, physical_y : Double) -> AffineTransform?

    try_calibration_from_reference

    fn try_calibration_from_reference(pixel_distance : Double, physical_distance : Double) -> Double?

    try_convolve3

    fn try_convolve3(image : GrayImage, kernel : Array[Double], policy? : BorderPolicy) -> GrayImage?

    try_convolve_separable

    fn try_convolve_separable(image : GrayImage, kernel : Array[Double], policy? : BorderPolicy) -> GrayImage?

    try_fit_circle

    fn try_fit_circle(points : Array[Point]) -> Circle?

    try_fit_line

    fn try_fit_line(points : Array[Point]) -> Line?

    try_gauge_width

    fn try_gauge_width(image : GrayImage, start : Point, finish : Point, threshold? : Double) -> Double?

    try_robust_circle_fit

    fn try_robust_circle_fit(points : Array[Point], iterations : Int, cutoff : Double) -> Circle?

    try_robust_line_fit

    fn try_robust_line_fit(points : Array[Point], iterations : Int, cutoff : Double) -> Line?

    uncertainty_budget_report

    fn uncertainty_budget_report(components : Array[UncertaintyEstimate]) -> String

    uncertainty_from_components

    fn uncertainty_from_components(components : Array[UncertaintyEstimate]) -> UncertaintyEstimate

    uncertainty_is_acceptable

    fn uncertainty_is_acceptable(uncertainty : UncertaintyEstimate, tolerance : Tolerance, maximum_ratio : Double) -> Bool

    uncertainty_ratio

    fn uncertainty_ratio(uncertainty : UncertaintyEstimate, tolerance : Tolerance) -> Double

    unit_convert

    fn unit_convert(value : Double, source : String, target : String) -> Double

    upsample_nearest

    fn upsample_nearest(image : GrayImage, width : Int, height : Int) -> GrayImage

    validate_caliper_config

    fn validate_caliper_config(config : CaliperConfig) -> Array[PipelineDiagnostic]

    validate_image

    fn validate_image(image : GrayImage) -> Array[PipelineDiagnostic]

    validate_tolerance

    fn validate_tolerance(tolerance : Tolerance) -> Array[PipelineDiagnostic]

    variance_value

    fn variance_value(values : Array[Double]) -> Double

    vector_to_string

    fn vector_to_string(vector : Vector2) -> String

    versioned_project_summary

    fn versioned_project_summary() -> String

    weighted_mean

    fn weighted_mean(values : Array[Double], weights : Array[Double]) -> Double

    width_statistics_by_angle

    fn width_statistics_by_angle(image : GrayImage, center : Point, angle_count : Int, length : Double, threshold : Double) -> StatsSummary

    window_statistics

    fn window_statistics(values : Array[Double], width : Int, step : Int) -> Array[StatsSummary]