🥮 mooncakes.io

    moonbit-thermal-vision

    Thermal infrared matrix analysis toolkit for MoonBit.

    thermal
    infrared
    vision
    matrix
    inspection
    Download zip
    Author
    Version
    0.2.0
    License
    Apache-2.0
    Repository
    Last updated
    26 days ago
    Downloads
    17

    #moonbit-thermal-vision

    A pure MoonBit toolkit for analyzing calibrated thermal-infrared temperature matrices. It is designed for industrial inspection, equipment monitoring, low-light sensing, and educational pipelines where a camera or upstream adapter provides a numeric temperature grid.

    #Core capabilities

    • Validated matrices with safe indexing, rows, crops, rescaling, mapping, and CSV.
    • Mixed-delimiter text parsing for comma, semicolon, space, and tab data.
    • Thermal statistics, percentiles, histograms, z-score anomalies, and gradients.
    • Gray, ironbow, and blue-red palettes with ASCII PPM export.
    • Threshold masks, morphology, connected regions, bounding boxes, and PBM export.
    • Local hotspot detection, frame deltas, row/column trends, and quality reports.
    • Emissivity/gain/offset calibration, mean/median filters, kernels, convolution, Laplacian and sharpening helpers.
    • Deterministic 2048-entry pseudocolor and normalization lookup tables for embedded/native deployments that need stable output without interpolation.

    The root package owns the domain model and algorithms. cmd/main is a small demonstration; cmd/benchmark is a reproducible workload entry point.

    #Quick start

    moon run cmd/main

    Library usage:

    let matrix = @thermal.parse_temperature_matrix(
      #|31.2, 33.5, 35.1
      #|30.9, 48.8, 36.2
      #|29.8, 45.3, 34.4
    )
    let report = matrix.inspect_threshold(threshold=40.0)
    let frame = matrix.colorize(palette=@thermal.Ironbow)
    println(report.to_markdown())
    println(frame.to_ppm_ascii())

    #CLI and benchmark

    The demo prints a Markdown inspection report and a PPM preview header:

    moon run cmd/main
moon run --target native cmd/benchmark

    The benchmark performs 100 real 8x8 frames through mean filtering, threshold region extraction, and statistics. On the development machine (MoonBit 0.1.20260807, Windows, native target), the measured workload completed in approximately 121–126 ms for the complete native command across five local runs (including process startup); the program prints a checksum so a run cannot silently skip the work. Re-run the command on your own target when comparing machines.

    #Architecture

    root package
├── matrix / types       validated data model and safe access
├── parse / export        text and portable PPM/PBM/CSV representations
├── palette               pseudocolor conversion
├── mask / regions        binary morphology and connected components
├── hotspots / analytics  local peaks, histograms, anomalies
├── calibration / quality input correction and quality classification
├── filters / spatial     smoothing, kernels, gradients, convolution
├── temporal / tracking   frame deltas, trends, and region trajectories
└── lookup_tables         deterministic 2048-entry edge-deployment LUTs

    Algorithms operate on ordinary MoonBit arrays and standard-library types. No vendor SDK, generated runtime, or device-specific binary format is required. Private camera adapters can be layered above this package without changing its core data model.

    #Testing and CI

    The repository contains unit tests, documentation examples, and a broad boundary regression matrix. Run the same checks locally as CI:

    moon fmt --check
moon check --deny-warn
moon info
moon test --deny-warn
moon build --target native

    GitHub Actions tests Ubuntu, macOS, and Windows with the latest stable MoonBit installer, checks generated interfaces, runs all tests, and builds the native target. A separate workflow runs the benchmark smoke test on pushes to main.

    #License

    Apache-2.0. See LICENSE.

    ThermalError

    source
    pub(all) suberror ThermalError {
      InvalidDimensions(width~ : Int, height~ : Int, values~ : Int)
      EmptyMatrix
      OutOfBounds(x~ : Int, y~ : Int, width~ : Int, height~ : Int)
      RaggedRows(expected~ : Int, actual~ : Int, row~ : Int)
      ParseNumber(token~ : String, row~ : Int, col~ : Int)
    } derive(Eq, ToJson, 
    Debug    )

    Anomaly

    source
    pub(all) struct Anomaly {
      point : ThermalPoint
      value : Double
      z_score : Double
    } derive(Eq, ToJson, 
    Debug    )

    BoundaryPixel

    source
    pub(all) struct BoundaryPixel {
      point : ThermalPoint
      value : Double
      normal_x : Int
      normal_y : Int
    } derive(Eq, ToJson, 
    Debug    )

    Calibration

    source
    pub(all) struct Calibration {
      emissivity : Double
      reflected_temperature : Double
      ambient_temperature : Double
      gain : Double
      offset : Double
    } derive(Eq, ToJson, 
    Debug    )

    Calibration::apply

    source
    fn Calibration::apply(calibration : Calibration, raw : Double) -> Double

    Calibration::corrected_emission

    source
    fn Calibration::corrected_emission(calibration : Calibration, apparent : Double) -> Double

    Calibration::identity

    source
    fn Calibration::identity() -> Calibration

    Calibration::new

    source
    fn Calibration::new(emissivity~ : Double, reflected_temperature~ : Double, ambient_temperature~ : Double, gain? : Double, offset? : Double) -> Calibration

    CalibrationReport

    source
    pub(all) struct CalibrationReport {
      before : ThermalStats
      after : ThermalStats
      calibration : Calibration
    } derive(Eq, ToJson, 
    Debug    )

    ColorFrame

    source
    pub(all) struct ColorFrame {
      width : Int
      height : Int
      pixels : Array[Rgb]
    } derive(Eq, ToJson, 
    Debug    )

    ColorFrame::pixel

    source
    fn ColorFrame::pixel(frame : ColorFrame, point : ThermalPoint) -> Rgb raise ThermalError

    ColorFrame::to_ppm_ascii

    source
    fn ColorFrame::to_ppm_ascii(frame : ColorFrame) -> String

    ColorFrame::to_ppm_ascii_wrapped

    source
    fn ColorFrame::to_ppm_ascii_wrapped(frame : ColorFrame, columns~ : Int) -> String

    CsvOptions

    source
    pub(all) struct CsvOptions {
      delimiter : String
      decimals : Int
      include_header : Bool
    } derive(Eq, ToJson, 
    Debug    )

    CsvOptions::default

    source
    fn CsvOptions::default() -> CsvOptions

    FilterKind

    source
    pub(all) enum FilterKind {
      Mean
      Median
      Minimum
      Maximum
    } derive(Eq, ToJson, 
    Debug    )

    FrameDelta

    source
    pub(all) struct FrameDelta {
      changed : Int
      mean_absolute : Double
      maximum_absolute : Double
      normalized : Double
    } derive(Eq, ToJson, 
    Debug    )

    HistogramBin

    source
    pub(all) struct HistogramBin {
      lower : Double
      upper : Double
      count : Int
    } derive(Eq, ToJson, 
    Debug    )

    Hotspot

    source
    pub(all) struct Hotspot {
      point : ThermalPoint
      temperature : Double
      contrast : Double
    } derive(Eq, ToJson, 
    Debug    )

    InspectionReport

    source
    pub(all) struct InspectionReport {
      frame_width : Int
      frame_height : Int
      threshold : Double
      stats : ThermalStats
      hotspots : Array[Hotspot]
      regions : Array[ThermalRegion]
    } derive(Eq, ToJson, 
    Debug    )

    InspectionReport::to_markdown

    source
    fn InspectionReport::to_markdown(report : InspectionReport) -> String

    Kernel

    source
    pub(all) struct Kernel {
      width : Int
      height : Int
      values : Array[Double]
    } derive(Eq, ToJson, 
    Debug    )

    Kernel::box

    source
    fn Kernel::box(size~ : Int) -> Kernel raise ThermalError

    Kernel::new

    source
    fn Kernel::new(width~ : Int, height~ : Int, values~ : Array[Double]) -> Kernel raise ThermalError

    MotionSummary

    source
    pub(all) struct MotionSummary {
      track_count : Int
      active_count : Int
      total_observations : Int
      fastest_track : Int
      hottest_track : Int
    } derive(Eq, ToJson, 
    Debug    )

    Palette

    source
    pub(all) enum Palette {
      Gray
      Ironbow
      BlueRed
    } derive(Eq, ToJson, 
    Debug    )

    ProfileSample

    source
    pub(all) struct ProfileSample {
      distance : Int
      temperature : Double
    } derive(Eq, ToJson, 
    Debug    )

    QualitySummary

    source
    pub(all) struct QualitySummary {
      total : Int
      valid : Int
      missing : Int
      non_finite : Int
      below_limit : Int
      above_limit : Int
      min_valid : Double
      max_valid : Double
    } derive(Eq, ToJson, 
    Debug    )

    QualitySummary::to_markdown

    source
    fn QualitySummary::to_markdown(summary : QualitySummary) -> String

    Rgb

    source
    pub(all) struct Rgb {
      r : Int
      g : Int
      b : Int
    } derive(Eq, ToJson, 
    Debug    )

    Rgb::new

    source
    fn Rgb::new(r~ : Int, g~ : Int, b~ : Int) -> Rgb

    SampleQuality

    source
    pub(all) enum SampleQuality {
      Valid
      Missing
      NonFinite
      BelowPhysicalLimit
      AbovePhysicalLimit
    } derive(Eq, ToJson, 
    Debug    )

    SignalPeak

    source
    pub(all) struct SignalPeak {
      index : Int
      value : Double
      prominence : Double
      width : Int
    } derive(Eq, ToJson, 
    Debug    )

    TemperatureLimits

    source
    pub(all) struct TemperatureLimits {
      minimum : Double
      maximum : Double
    } derive(Eq, ToJson, 
    Debug    )

    TemperatureLimits::contains

    source
    fn TemperatureLimits::contains(limits : TemperatureLimits, value : Double) -> Bool

    TemperatureLimits::new

    source
    fn TemperatureLimits::new(minimum~ : Double, maximum~ : Double) -> TemperatureLimits

    TemperatureRange

    source
    pub(all) struct TemperatureRange {
      min : Double
      max : Double
    } derive(Eq, ToJson, 
    Debug    )

    TemperatureRange::contains

    source
    fn TemperatureRange::contains(range : TemperatureRange, value : Double) -> Bool

    TemperatureRange::span

    source
    fn TemperatureRange::span(range : TemperatureRange) -> Double

    ThermalMask

    source
    pub(all) struct ThermalMask {
      width : Int
      height : Int
      cells : Array[Bool]
    } derive(Eq, ToJson, 
    Debug    )

    ThermalMask::bounding_box

    source
    fn ThermalMask::bounding_box(mask : ThermalMask) -> ThermalRegion?

    ThermalMask::close

    source
    fn ThermalMask::close(mask : ThermalMask, radius? : Int) -> ThermalMask

    ThermalMask::count

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

    ThermalMask::dilate

    source
    fn ThermalMask::dilate(mask : ThermalMask, radius? : Int) -> ThermalMask

    ThermalMask::erode

    source
    fn ThermalMask::erode(mask : ThermalMask, radius? : Int) -> ThermalMask

    ThermalMask::fill_holes

    source
    fn ThermalMask::fill_holes(mask : ThermalMask) -> ThermalMask

    ThermalMask::get

    source
    fn ThermalMask::get(mask : ThermalMask, point : ThermalPoint) -> Bool raise ThermalError

    ThermalMask::intersection

    source
    fn ThermalMask::intersection(a : ThermalMask, b : ThermalMask) -> ThermalMask raise ThermalError

    ThermalMask::invert

    source
    fn ThermalMask::invert(mask : ThermalMask) -> ThermalMask

    ThermalMask::new

    source
    fn ThermalMask::new(width~ : Int, height~ : Int, cells~ : Array[Bool]) -> ThermalMask raise ThermalError

    ThermalMask::open

    source
    fn ThermalMask::open(mask : ThermalMask, radius? : Int) -> ThermalMask

    ThermalMask::remove_small_components

    source
    fn ThermalMask::remove_small_components(mask : ThermalMask, minimum_area~ : Int) -> ThermalMask

    ThermalMask::to_ascii

    source
    fn ThermalMask::to_ascii(mask : ThermalMask, hot? : String, cold? : String) -> String

    ThermalMask::to_pbm_ascii

    source
    fn ThermalMask::to_pbm_ascii(mask : ThermalMask) -> String

    ThermalMask::union

    source

    ThermalMatrix

    source
    pub(all) struct ThermalMatrix {
      width : Int
      height : Int
      values : Array[Double]
    } derive(Eq, ToJson, 
    Debug    )

    ThermalMatrix::adaptive_mask

    source
    fn ThermalMatrix::adaptive_mask(matrix : ThermalMatrix, mode : ThresholdMode) -> ThermalMask raise ThermalError

    ThermalMatrix::anomalies

    source
    fn ThermalMatrix::anomalies(matrix : ThermalMatrix, z_limit? : Double) -> Array[Anomaly] raise ThermalError

    ThermalMatrix::boundary

    source
    fn ThermalMatrix::boundary(matrix : ThermalMatrix, mask : ThermalMask) -> Array[BoundaryPixel] raise ThermalError

    ThermalMatrix::calibrate

    source
    fn ThermalMatrix::calibrate(matrix : ThermalMatrix, calibration : Calibration) -> ThermalMatrix

    ThermalMatrix::calibration_report

    source
    fn ThermalMatrix::calibration_report(matrix : ThermalMatrix, calibration : Calibration) -> CalibrationReport raise ThermalError

    ThermalMatrix::colorize

    source
    fn ThermalMatrix::colorize(matrix : ThermalMatrix, palette? : Palette, range? : TemperatureRange) -> ColorFrame raise ThermalError

    ThermalMatrix::colorize_lut

    source
    fn ThermalMatrix::colorize_lut(matrix : ThermalMatrix, palette? : Palette, range? : TemperatureRange) -> ColorFrame

    ThermalMatrix::column_signal

    source
    fn ThermalMatrix::column_signal(matrix : ThermalMatrix, x : Int) -> Array[Double] raise ThermalError

    fn ThermalMatrix::column_trends(matrix : ThermalMatrix) -> Array[Trend]

    ThermalMatrix::convolve

    source
    fn ThermalMatrix::convolve(matrix : ThermalMatrix, kernel : Kernel) -> ThermalMatrix

    ThermalMatrix::correct_emissivity

    source
    fn ThermalMatrix::correct_emissivity(matrix : ThermalMatrix, calibration : Calibration) -> ThermalMatrix

    ThermalMatrix::crop

    source
    fn ThermalMatrix::crop(matrix : ThermalMatrix, origin~ : ThermalPoint, width~ : Int, height~ : Int) -> ThermalMatrix raise ThermalError

    ThermalMatrix::delta

    source

    ThermalMatrix::detect_hotspots

    source
    fn ThermalMatrix::detect_hotspots(matrix : ThermalMatrix, min_temp~ : Double, radius? : Int, min_contrast? : Double, limit? : Int) -> Array[Hotspot]

    ThermalMatrix::filter

    source
    fn ThermalMatrix::filter(matrix : ThermalMatrix, radius? : Int, kind? : FilterKind) -> ThermalMatrix

    ThermalMatrix::from_rows

    source
    fn ThermalMatrix::from_rows(rows : Array[Array[Double]]) -> ThermalMatrix raise ThermalError

    ThermalMatrix::get

    source
    fn ThermalMatrix::get(matrix : ThermalMatrix, point : ThermalPoint) -> Double raise ThermalError

    ThermalMatrix::gradient

    source
    fn ThermalMatrix::gradient(matrix : ThermalMatrix) -> ThermalMatrix

    ThermalMatrix::histogram

    source
    fn ThermalMatrix::histogram(matrix : ThermalMatrix, bins~ : Int) -> Array[HistogramBin] raise ThermalError

    ThermalMatrix::hot_fraction

    source
    fn ThermalMatrix::hot_fraction(matrix : ThermalMatrix, threshold~ : Double) -> Double

    ThermalMatrix::index

    source
    fn ThermalMatrix::index(matrix : ThermalMatrix, point : ThermalPoint) -> Int raise ThermalError

    ThermalMatrix::inspect_threshold

    source
    fn ThermalMatrix::inspect_threshold(matrix : ThermalMatrix, threshold~ : Double, hotspot_limit? : Int) -> InspectionReport raise ThermalError

    ThermalMatrix::laplacian

    source
    fn ThermalMatrix::laplacian(matrix : ThermalMatrix) -> ThermalMatrix raise ThermalError

    ThermalMatrix::line_profile

    source
    fn ThermalMatrix::line_profile(matrix : ThermalMatrix, start~ : ThermalPoint, end~ : ThermalPoint) -> Array[ProfileSample] raise ThermalError

    ThermalMatrix::map

    source
    fn ThermalMatrix::map(matrix : ThermalMatrix, f : (Double) -> Double) -> ThermalMatrix

    ThermalMatrix::masked_values

    source
    fn ThermalMatrix::masked_values(matrix : ThermalMatrix, mask : ThermalMask) -> Array[Double] raise ThermalError

    ThermalMatrix::mean_filter

    source
    fn ThermalMatrix::mean_filter(matrix : ThermalMatrix, radius? : Int) -> ThermalMatrix

    ThermalMatrix::median_filter

    source
    fn ThermalMatrix::median_filter(matrix : ThermalMatrix, radius? : Int) -> ThermalMatrix

    ThermalMatrix::new

    source
    fn ThermalMatrix::new(width~ : Int, height~ : Int, values~ : Array[Double]) -> ThermalMatrix raise ThermalError

    ThermalMatrix::peak_map

    source
    fn ThermalMatrix::peak_map(matrix : ThermalMatrix, radius? : Int) -> ThermalMask

    ThermalMatrix::quality

    source
    fn ThermalMatrix::quality(matrix : ThermalMatrix, limits : TemperatureLimits) -> QualitySummary

    ThermalMatrix::range

    source

    ThermalMatrix::region_adjacency

    source
    fn ThermalMatrix::region_adjacency(matrix : ThermalMatrix, regions : Array[ThermalRegion]) -> Array[Array[Int]]

    ThermalMatrix::rescale

    source
    fn ThermalMatrix::rescale(matrix : ThermalMatrix, width~ : Int, height~ : Int) -> ThermalMatrix raise ThermalError

    ThermalMatrix::roi

    source

    ThermalMatrix::roi_column_profile

    source
    fn ThermalMatrix::roi_column_profile(matrix : ThermalMatrix, roi : ThermalRoi) -> Array[Double] raise ThermalError

    ThermalMatrix::roi_mean_profile

    source
    fn ThermalMatrix::roi_mean_profile(matrix : ThermalMatrix, roi : ThermalRoi) -> Array[Double] raise ThermalError

    ThermalMatrix::roi_stats

    source
    fn ThermalMatrix::roi_stats(matrix : ThermalMatrix, roi : ThermalRoi) -> ThermalStats raise ThermalError

    ThermalMatrix::row

    source
    fn ThermalMatrix::row(matrix : ThermalMatrix, y : Int) -> Array[Double] raise ThermalError

    ThermalMatrix::row_signal

    source
    fn ThermalMatrix::row_signal(matrix : ThermalMatrix, y : Int) -> Array[Double] raise ThermalError

    fn ThermalMatrix::row_trends(matrix : ThermalMatrix) -> Array[Trend] raise ThermalError

    ThermalMatrix::sharpen

    source
    fn ThermalMatrix::sharpen(matrix : ThermalMatrix, amount? : Double) -> ThermalMatrix raise ThermalError

    ThermalMatrix::stats

    source

    ThermalMatrix::threshold_mask

    source
    fn ThermalMatrix::threshold_mask(matrix : ThermalMatrix, min_temp~ : Double, max_temp? : Double) -> ThermalMask

    ThermalMatrix::threshold_regions

    source
    fn ThermalMatrix::threshold_regions(matrix : ThermalMatrix, min_temp~ : Double, max_temp? : Double) -> Array[ThermalRegion]

    ThermalMatrix::threshold_value

    source
    fn ThermalMatrix::threshold_value(matrix : ThermalMatrix, mode : ThresholdMode) -> Double raise ThermalError

    ThermalMatrix::to_csv

    source
    fn ThermalMatrix::to_csv(matrix : ThermalMatrix) -> String

    ThermalMatrix::to_csv_with

    source
    fn ThermalMatrix::to_csv_with(matrix : ThermalMatrix, options : CsvOptions) -> String

    ThermalMatrix::track_frame_sequence

    source
    fn ThermalMatrix::track_frame_sequence(frames : Array[ThermalMatrix], threshold~ : Double, config? : TrackingConfig) -> Array[ThermalTrack]

    ThermalMatrix::unsafe_get

    source
    fn ThermalMatrix::unsafe_get(matrix : ThermalMatrix, x~ : Int, y~ : Int) -> Double

    ThermalMatrix::valid_mask

    source
    fn ThermalMatrix::valid_mask(matrix : ThermalMatrix, limits : TemperatureLimits) -> ThermalMask

    ThermalMatrix::weighted_mean

    source
    fn ThermalMatrix::weighted_mean(matrix : ThermalMatrix, weights : ThermalMatrix) -> Double raise ThermalError

    ThermalPoint

    source
    pub(all) struct ThermalPoint {
      x : Int
      y : Int
    } derive(Eq, ToJson, 
    Debug    )

    ThermalPoint::chebyshev

    source
    fn ThermalPoint::chebyshev(a : ThermalPoint, b : ThermalPoint) -> Int

    ThermalPoint::manhattan

    source
    fn ThermalPoint::manhattan(a : ThermalPoint, b : ThermalPoint) -> Int

    ThermalPoint::neighbors

    source
    fn ThermalPoint::neighbors(point : ThermalPoint, connectivity? : Int) -> Array[ThermalPoint]

    ThermalPoint::new

    source
    fn ThermalPoint::new(x~ : Int, y~ : Int) -> ThermalPoint

    ThermalPoint::translate

    source
    fn ThermalPoint::translate(point : ThermalPoint, dx~ : Int, dy~ : Int) -> ThermalPoint

    ThermalRegion

    source
    pub(all) struct ThermalRegion {
      id : Int
      pixels : Array[ThermalPoint]
      min_x : Int
      min_y : Int
      max_x : Int
      max_y : Int
      min_temp : Double
      max_temp : Double
      average_temp : Double
      peak : ThermalPoint
    } derive(Eq, ToJson, 
    Debug    )

    ThermalRegion::area

    source
    fn ThermalRegion::area(region : ThermalRegion) -> Int

    ThermalRegion::centroid

    source
    fn ThermalRegion::centroid(region : ThermalRegion) -> ThermalPoint

    ThermalRegion::compactness

    source
    fn ThermalRegion::compactness(region : ThermalRegion) -> Double

    ThermalRegion::perimeter

    source
    fn ThermalRegion::perimeter(region : ThermalRegion) -> Int

    ThermalRegion::summary

    source
    fn ThermalRegion::summary(region : ThermalRegion) -> String

    ThermalRoi

    source
    pub(all) struct ThermalRoi {
      origin : ThermalPoint
      width : Int
      height : Int
    } derive(Eq, ToJson, 
    Debug    )

    ThermalRoi::area

    source
    fn ThermalRoi::area(roi : ThermalRoi) -> Int

    ThermalRoi::contains

    source
    fn ThermalRoi::contains(roi : ThermalRoi, point : ThermalPoint) -> Bool

    ThermalRoi::end

    source

    ThermalRoi::intersection

    source
    fn ThermalRoi::intersection(a : ThermalRoi, b : ThermalRoi) -> ThermalRoi?

    ThermalRoi::new

    source
    fn ThermalRoi::new(origin~ : ThermalPoint, width~ : Int, height~ : Int) -> ThermalRoi raise ThermalError

    ThermalRoi::union

    source

    ThermalStats

    source
    pub(all) struct ThermalStats {
      count : Int
      min : Double
      max : Double
      mean : Double
      stddev : Double
      p50 : Double
      p90 : Double
      p95 : Double
    } derive(Eq, ToJson, 
    Debug    )

    ThermalTrack

    source
    pub(all) struct ThermalTrack {
      id : Int
      observations : Array[TrackObservation]
      active : Bool
    } derive(Eq, ToJson, 
    Debug    )

    ThermalTrack::last

    source

    ThermalTrack::length

    source
    fn ThermalTrack::length(track : ThermalTrack) -> Int

    ThermalTrack::peak

    source

    ThermalTrack::to_markdown

    source
    fn ThermalTrack::to_markdown(track : ThermalTrack) -> String

    ThermalTrack::velocity

    source
    fn ThermalTrack::velocity(track : ThermalTrack) -> ThermalPoint

    ThresholdMode

    source
    pub(all) enum ThresholdMode {
      Absolute(Double)
      MeanOffset(Double)
      MedianOffset(Double)
      Percentile(Double)
    } derive(Eq, ToJson, 
    Debug    )

    TrackObservation

    source
    pub(all) struct TrackObservation {
      frame : Int
      point : ThermalPoint
      temperature : Double
      area : Int
    } derive(Eq, ToJson, 
    Debug    )

    TrackingConfig

    source
    pub(all) struct TrackingConfig {
      maximum_distance : Int
      maximum_gap : Int
      minimum_temperature : Double
    } derive(Eq, ToJson, 
    Debug    )

    TrackingConfig::default

    source

    Trend

    source
    pub(all) struct Trend {
      slope : Double
      intercept : Double
      first : Double
      last : Double
      direction : Int
    } derive(Eq, ToJson, 
    Debug    )

    autocorrelation

    source
    fn autocorrelation(values : Array[Double], lag~ : Int) -> Double

    auxiliary_lut_resolution

    source
    fn auxiliary_lut_resolution() -> Int

    blue_red_lut

    source
    fn blue_red_lut() -> Array[Rgb]

    classify_temperature

    source
    fn classify_temperature(value : Double, limits : TemperatureLimits) -> SampleQuality

    confidence_lut

    source
    fn confidence_lut() -> Array[Double]

    derivative

    source
    fn derivative(values : Array[Double]) -> Array[Double]

    edge_response_lut

    source
    fn edge_response_lut() -> Array[Double]

    find_peaks

    source
    fn find_peaks(values : Array[Double], minimum_prominence? : Double, minimum_distance? : Int) -> Array[SignalPeak]

    gamma_lut

    source
    fn gamma_lut() -> Array[Double]

    gray_lut

    source
    fn gray_lut() -> Array[Rgb]

    integrate

    source
    fn integrate(values : Array[Double], step? : Double) -> Double

    ironbow_lut

    source
    fn ironbow_lut() -> Array[Rgb]

    lut_resolution

    source
    fn lut_resolution() -> Int

    normalized_temperature_lut

    source
    fn normalized_temperature_lut() -> Array[Double]

    parse_temperature_matrix

    source
    fn parse_temperature_matrix(text : String) -> ThermalMatrix raise ThermalError

    quantization_lut

    source
    fn quantization_lut() -> Array[Int]

    second_derivative

    source
    fn second_derivative(values : Array[Double]) -> Array[Double]

    smooth_signal

    source
    fn smooth_signal(values : Array[Double], radius? : Int) -> Array[Double]

    summarize_tracks

    source
    fn summarize_tracks(tracks : Array[ThermalTrack]) -> MotionSummary

    track_regions

    source
    fn track_regions(frames : Array[Array[ThermalRegion]], config? : TrackingConfig) -> Array[ThermalTrack]

    trend

    source
    fn trend(values : Array[Double]) -> Trend

    Source Files

    Powered by MoonBit

    Site sourceReport issuePackagesBuild queueSkillsStatistics

    © 2026 mooncakes.io