Panduan Cepat

Mulai gunakan RustO! di berbagai bahasa pemrograman dengan contoh ringkas yang siap disalin dan dijalankan di bawah ini.

Contoh Gambar Dokumen

Sebagai gambaran masukan, kita menggunakan gambar struk pembayaran receipt.jpg:

┌────────────────────────────────────────┐
│             KEDAI KOPI                 │
│ 2026-08-20                     12:30   │
│                                        │
│ Menu                  Jumlah    Harga  │
│ ────────────────────────────────────── │
│ Espresso Double         1     Rp25.000 │
│ Croissant               2     Rp40.000 │
│ Flat White              1     Rp30.000 │
│ ────────────────────────────────────── │
│ Total                         Rp95.000 │
└────────────────────────────────────────┘

1. Rust

use rusto::{
    DetectTextResult, ImageSource, InitializeConfig, OcrRunOptions,
    OutputGranularity, RustO,
};

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // 1. Inisialisasi mesin dengan preset bawaan PP-OCRv6
    let config = InitializeConfig::ppv6("models/det.rten", "models/rec.rten", "models/dict.txt");
    let mut ocr = RustO::initialize(config)?;

    // 2. Jalankan deteksi teks terstruktur per baris
    let image = ImageSource::Path("receipt.jpg".into());
    let mut options = OcrRunOptions::default();
    options.output = OutputGranularity::Lines;

    let result = ocr.detect_text(&image, &options)?;

    match result {
        DetectTextResult::Structured(lines) => {
            println!("--- Hasil Teks Terstruktur ({} baris) ---", lines.len());
            for line in lines {
                println!(
                    "[{:5.1}, {:5.1}, {:5.1}, {:5.1}] (Skor: {:.2}) {}",
                    line.frame.left, line.frame.top, line.frame.width, line.frame.height,
                    line.score, line.text
                );
            }
        }
        DetectTextResult::Spatial(text) => println!("{text}"),
    }

    // 3. Jalankan rekonstruksi tata letak spasial
    options.output = OutputGranularity::Spatial;
    options.line_y_threshold = Some(0.5);
    options.word_x_threshold = Some(0.4);

    if let DetectTextResult::Spatial(spatial_text) = ocr.detect_text(&image, &options)? {
        println!("\n--- Tata Letak Spasial Hasil Rekonstruksi ---\n{spatial_text}");
    }

    Ok(())
}

2. Node.js (TypeScript / JavaScript)

import { RustO } from '@rustors/node';

const config = {
  detection: { model_path: 'models/det.rten' },
  recognition: { model_path: 'models/rec.rten', dict_path: 'models/dict.txt' }
};

const engine = new RustO(JSON.stringify(config));

// Deteksi baris terstruktur
const lines = engine.detectTextFile('receipt.jpg', JSON.stringify({}));
for (const line of lines) {
  console.log(`[${line.score.toFixed(2)}] ${line.text}`);
}

// Rekonstruksi tata letak spasial
const spatialText = engine.detectTextFileSpatial('receipt.jpg', JSON.stringify({}));
console.log(spatialText);

3. Python

from rusto import RustO, InitializeConfig, OcrRunOptions, ImageSource, OutputGranularity

# Inisialisasi engine dengan preset PP-OCRv6
config = InitializeConfig.ppv6("models/det.rten", "models/rec.rten", "models/dict.txt")
engine = RustO.initialize(config)

# Deteksi baris terstruktur
options = OcrRunOptions(output=OutputGranularity.LINES)
result = engine.detect_text(ImageSource.PATH("receipt.jpg"), options)
if result.is_STRUCTURED():
    for line in result.results:
        print(f"[{line.score:.2f}] {line.text}")

# Rekonstruksi tata letak spasial
spatial_options = OcrRunOptions(output=OutputGranularity.SPATIAL)
spatial_result = engine.detect_text(ImageSource.PATH("receipt.jpg"), spatial_options)
if spatial_result.is_SPATIAL():
    print(spatial_result.text)

4. Golang

package main

import (
    "fmt"
    "log"

    "github.com/byrizki/rusto-rs/packages/go"
)

func main() {
    config := `{"detection":{"model_path":"models/det.rten"},"recognition":{"model_path":"models/rec.rten","dict_path":"models/dict.txt"}}`
    engine, err := rusto.New(config)
    if err != nil {
        log.Fatalf("Inisialisasi gagal: %v", err)
    }
    defer engine.Close()

    lines, err := engine.DetectTextFile("receipt.jpg", "{}")
    if err != nil {
        log.Fatalf("OCR gagal: %v", err)
    }

    for _, line := range lines {
        fmt.Printf("[%.2f] %s\n", line.Score, line.Text)
    }
}

5. Java / Kotlin

import com.byrizki.rusto.RustO;
import com.byrizki.rusto.TextResult;
import java.util.List;

public class App {
    public static void main(String[] args) {
        String config = "{\"detection\":{\"model_path\":\"models/det.rten\"},\"recognition\":{\"model_path\":\"models/rec.rten\",\"dict_path\":\"models/dict.txt\"}}";
        try (RustO engine = RustO.initialize(config)) {
            List<TextResult> lines = engine.detectTextFile("receipt.jpg");
            for (TextResult line : lines) {
                System.out.printf("[%.2f] %s%n", line.getScore(), line.getText());
            }
        }
    }
}

6. Flutter & Dart

import 'package:rusto/rusto.dart';

void main() {
  final engine = RustO.initialize('''
  {
    "detection": { "model_path": "models/det.rten" },
    "recognition": { "model_path": "models/rec.rten", "dict_path": "models/dict.txt" }
  }
  ''');

  final results = engine.detectTextFile('receipt.jpg');
  for (final line in results) {
    print('[${line.score.toStringAsFixed(2)}] ${line.text}');
  }
  engine.close();
}

7. .NET / C#

using System;
using RustODotnet;

// 1. Inisialisasi mesin (memuat model bawaan PP-OCRv6 secara otomatis)
using var ocr = RustO.Initialize();

// 2. Deteksi teks terstruktur per baris
var imageSource = new UriImageSource("receipt.jpg");
var options = new OcrRunOptions { Output = OutputGranularity.Lines };

var result = ocr.DetectText(imageSource, options);
if (result is StructuredDetectTextResult structured)
{
    foreach (var item in structured.Items)
    {
        Console.WriteLine($"[{item.Frame.Left:F0}, {item.Frame.Top:F0}] ({item.Score:P0}) {item.Text}");
    }
}

// 3. Rekonstruksi tata letak spasial
var spatialOptions = new OcrRunOptions { Output = OutputGranularity.Spatial };
var spatialResult = ocr.DetectText(imageSource, spatialOptions);
if (spatialResult is SpatialDetectTextResult spatial)
{
    Console.WriteLine("\n--- Tata Letak Spasial ---");
    Console.WriteLine(spatial.Text);
}

8. React Native

import React, { useEffect, useState } from 'react';
import { Button, SafeAreaView, ScrollView, Text } from 'react-native';
import { detectText, initialize, TextResult } from '@rustors/react-native';

export default function QuickScanApp() {
  const [lines, setLines] = useState<TextResult[]>([]);

  useEffect(() => {
    initialize();
  }, []);

  const handleScanStructured = async () => {
    const results = await detectText(
      { uri: 'file:///path/to/receipt.jpg' },
      { output: 'lines' }
    );
    setLines(results as TextResult[]);
  };

  return (
    <SafeAreaView style={{ flex: 1, padding: 16 }}>
      <Button title="Pindai Baris Teks" onPress={handleScanStructured} />
      <ScrollView style={{ marginTop: 16 }}>
        {lines.map((line, idx) => (
          <Text key={idx}>{line.text} ({Math.round(line.score * 100)}%)</Text>
        ))}
      </ScrollView>
    </SafeAreaView>
  );
}

9. iOS (Swift)

import Foundation
import RustO

func runQuickOcr() {
    do {
        let ocr = try RustO.initialize()
        let result = try ocr.detectText(.uri("receipt.jpg"), options: OcrRunOptions(output: .lines))
        if case .structured(let items) = result {
            for item in items {
                print("[\(item.frame.left), \(item.frame.top)] (\(item.score)) \(item.text)")
            }
        }
    } catch {
        print("Kesalahan OCR: \(error)")
    }
}

10. Android (Kotlin)

package com.example.ocr

import android.content.Context
import com.byrizki.rusto.*

fun processReceipt(context: Context, imageUri: String) {
    RustO.initialize(context).use { ocr ->
        val source = ImageSource.Uri(imageUri)
        val structured = ocr.detectText(source, OcrRunOptions(output = OutputGranularity.LINES))
        if (structured is DetectTextResult.Structured) {
            structured.items.forEach { line ->
                println("${line.text} (Skor: ${line.score})")
            }
        }
    }
}

11. Antarmuka Baris Perintah (CLI)

# 1. Keluaran JSON terstruktur dengan koordinat poligon
rusto --det-model det.rten --rec-model rec.rten --dict dict.txt --format json receipt.jpg

# 2. Keluaran tata letak teks spasial terformat
rusto --det-model det.rten --rec-model rec.rten --dict dict.txt --format text-ordered receipt.jpg

# 3. Keluaran nilai dipisahkan tab (TSV)
rusto --det-model det.rten --rec-model rec.rten --dict dict.txt --format tsv receipt.jpg