Inizia

Inferenza Ultralytics per Rust

Ultralytics Inference GitHub Ultralytics Inference Crates.io Ultralytics Inference docs.rs Ultralytics Inference Downloads Ultralytics Inference MSRV

Ultralytics Inference è una libreria di inferenza YOLO ad alte prestazioni e uno strumento a riga di comando scritto in Rust. Esegue modelli ONNX esportati tramite ONNX Runtime per fornire previsioni rapide e sicure per la memoria su immagini, video, webcam e flussi, senza richiedere un runtime Python durante l'inferenza.

Il progetto è distribuito come un singolo crate, ultralytics-inference, utilizzabile in due modi: come CLI per previsioni rapide e processi in batch oppure come libreria integrata direttamente nella tua applicazione Rust. Supporta tutte le attività Ultralytics e un'ampia gamma di backend hardware tramite un'interfaccia uniforme per i dispositivi. Per l'inferenza nel browser, lo stesso repository pubblica il pacchetto npm @ultralytics/yolo; consulta la guida alla configurazione.

Perché usare Rust per l'inferenza?#

  • Velocità nativa e ingombro ridotto. Viene compilato in un binario nativo senza interprete, ideale per server, container e dispositivi edge.
  • Sicurezza della memoria. Il modello di proprietà di Rust elimina intere categorie di errori in fase di esecuzione senza un garbage collector.
  • Tutte le attività YOLO. Rilevamento, segmentazione, segmentazione semantica, stima della profondità, classificazione, posa e OBB da un'unica API, oltre a OCR del testo nelle scene e inferenza a tasselli per immagini di grandi dimensioni.
  • Ampio supporto hardware. CPU e provider di esecuzione CUDA, TensorRT, CoreML, OpenVINO, DirectML, ROCm, MIGraphX e XNNPACK selezionati al momento della compilazione, oltre ai modelli OpenVINO IR nativi.
  • Preelaborazione sulla GPU. Un kernel CUDA fuso facoltativo esegue letterbox, normalizzazione e conversione del layout sulla GPU e passa il risultato al modello senza uscire dal dispositivo.
  • Download automatico. I nomi noti dei modelli YOLO, i modelli OCR e le risorse di esempio vengono scaricati automaticamente al primo utilizzo.
  • Stesso output di Python. Le maschere, i contorni delle maschere e i risultati disegnati seguono il pacchetto Python Ultralytics, quindi --save genera la stessa immagine di plot().
Cerchi il pacchetto Python?

Questa pagina descrive il crate Rust autonomo. Per il flusso di lavoro Python (addestramento, convalida, esportazione e previsione), consulta la Guida rapida principale e la modalità Predict. Esporta qualsiasi modello Ultralytics in ONNX con l'integrazione ONNX, quindi eseguilo qui.

Installazione#

È richiesto Rust 1.92 o versioni successive. La funzionalità video richiede inoltre che nel sistema sia installato FFmpeg dalla versione 6 alla 9.

# Install the command-line tool from crates.io
cargo install ultralytics-inference

# Or with GPU support compiled in
cargo install ultralytics-inference --features cuda,tensorrt

Il binario si trova in ~/.cargo/bin/ultralytics-inference (Linux e macOS) oppure in %USERPROFILE%\.cargo\bin\ su Windows.

Guida rapida alla CLI#

La CLI espone un sottocomando predict. Senza argomenti, scarica un modello di rilevamento nano e immagini di esempio, esegue l'inferenza e salva i risultati annotati in runs/detect/predict.

# Detect on the built-in samples (downloads model and images)
ultralytics-inference predict

# Detect on your own image
ultralytics-inference predict --model yolo26n.onnx --source image.jpg

# Segmentation (auto-downloads yolo26n-seg.onnx)
ultralytics-inference predict --task segment --source image.jpg

# Pose on a video, shown live in a window
ultralytics-inference predict --task pose --source video.mp4 --show

# Depth estimation (auto-downloads yolo26n-depth.onnx)
ultralytics-inference predict --task depth --source image.jpg

# Tune thresholds and filter to specific classes
ultralytics-inference predict --source image.jpg --conf 0.5 --iou 0.45 --classes "0,1,2"

# Run a whole folder on the GPU in half precision
ultralytics-inference predict --source images/ --device cuda:0 --quantize 16

# Tile a large aerial image into overlapping 640 px windows to find small objects
ultralytics-inference predict --model yolo26n-obb.onnx --source aerial.jpg --tile 640

# Read scene text (auto-downloads yolo26n-text.onnx and the PaddleOCR models)
ultralytics-inference predict --ocr --source sign.jpg

# Thicker lines, no confidences in labels
ultralytics-inference predict --source image.jpg --line-width 4 --show-conf false

Tutti i flag predict:

FlagPredefinitoDescrizione
--model, -myolo26n.onnxPercorso a un modello ONNX o a un'esportazione OpenVINO; un nome YOLO noto viene scaricato automaticamente.
--taskdetectUno tra detect, segment, semantic, depth, classify, pose, obb; se --model viene omesso, seleziona il modello nano.
--source, -sesempioImmagine, directory, glob, video, indice della webcam, stream o URL.
--conf0.25Soglia di confidenza.
--iou0.5Soglia IoU per la soppressione dei non massimi.
--max-det300Numero massimo di rilevamenti per immagine.
--imgszmetadati del modelloDimensione dell'immagine per l'inferenza.
--rect [<BOOL>]trueInferenza rettangolare con padding minimo.
--tile [<TILE>]disattivatoDimensione dei tasselli per l'inferenza con finestre sovrapposte; --tile senza valore usa --imgsz. Vedi inferenza a tasselli.
--retina-masksfalseCrea le maschere di segmentazione alla dimensione originale dell'immagine invece che alla dimensione usata per l'inferenza.
--ocrfalseLegge il testo in ogni riquadro, riquadro orientato o maschera con PaddleOCR; senza --model viene eseguito yolo26n-text.onnx. Vedi OCR.
--batch1Dimensione del batch per l'inferenza.
--quantizeprecisione del modelloPrecisione dell'inferenza: 8, 16, 32, int8, fp16, fp32, w8a8, w16a16, w32a32, w8a16 oppure w8a32.
--save [<BOOL>]trueSalva i risultati annotati in runs/<task>/predict.
--save-framesfalseSalva i singoli fotogrammi per l'input video invece di un file video.
--save-jsonfalseSalva le mappe di classe PNG della segmentazione semantica.
--showfalseMostra i risultati in una finestra.
--show-labels [<BOOL>]trueMostra i nomi delle classi nelle etichette dei riquadri.
--show-conf [<BOOL>]trueMostra i valori di confidenza nelle etichette dei riquadri.
--show-boxes [<BOOL>]trueDisegna i riquadri e le relative etichette.
--line-widthdalla dimensione dell'immagineSpessore della linea del riquadro in pixel, che determina anche la dimensione delle etichette.
--deviceautomaticoDispositivo di esecuzione, ad esempio cpu, cuda:0, tensorrt:0, coreml, intel:gpu, directml:0, rocm:0, migraphx:0, xnnpack.
--verbose [<BOOL>]trueStampa i risultati e i tempi per ogni immagine.
--classestuttiFiltra i rilevamenti in base agli ID delle classi, ad esempio 0, "0,1,2" oppure "[0, 1, 2]".

[<BOOL>] indica un flag il cui valore è facoltativo: se lo specifichi senza valore (--rect), viene impostato su true, mentre --rect false lo disattiva. Il flag legacy --half è ancora accettato, corrisponde a --quantize 16 e mostra lo stesso avviso di deprecazione del pacchetto Python.

Guida rapida alla libreria#

Carica un modello ed esegui una previsione. I metadati del modello, come i nomi delle classi, il tipo di attività e le dimensioni dell'immagine, vengono letti automaticamente dal file ONNX.

use ultralytics_inference::YOLOModel;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Metadata (classes, task, imgsz) is parsed from the model.
    let mut model = YOLOModel::load("yolo26n.onnx")?;

    let results = model.predict("image.jpg")?;

    for result in &results {
        if let Some(boxes) = &result.boxes {
            for i in 0..boxes.len() {
                let class_id = boxes.cls()[i] as usize;
                let conf = boxes.conf()[i];
                let name = result.names.get(&class_id).map_or("unknown", |s| s.as_str());
                println!("{name} {conf:.2}");
            }
        }
    }

    Ok(())
}

Usa InferenceConfig per controllare soglie, dimensioni dell'immagine, precisione e dispositivo con un'API basata su builder:

use ultralytics_inference::{Device, InferenceConfig, Quantization, YOLOModel};

let config = InferenceConfig::new()
    .with_confidence(0.5)
    .with_iou(0.45)
    .with_imgsz(640, 640)
    .with_device(Device::Cuda(0))
    .with_quantize(Quantization::Fp16);

let mut model = YOLOModel::load_with_config("yolo26n.onnx", config)?;
let results = model.predict("image.jpg")?;

Ogni attività popola un campo diverso in Results. Ogni scheda qui sotto è un programma completo ed eseguibile; il modello e gli input di esempio vengono scaricati automaticamente alla prima esecuzione. Sostituisci predict_default() con predict("image.jpg") per lavorare con i tuoi file.

use ultralytics_inference::YOLOModel;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut model = YOLOModel::load("yolo26n.onnx")?;
    let results = model.predict_default()?;

    for result in &results {
        if let Some(boxes) = &result.boxes {
            println!("{} detections", boxes.len());
            let xyxy = boxes.xyxy(); // rows of [x1, y1, x2, y2]
            for i in 0..boxes.len() {
                let class_id = boxes.cls()[i] as usize;
                let name = result.names.get(&class_id).map_or("unknown", |s| s.as_str());
                println!("  {name} {:.2} {:?}", boxes.conf()[i], xyxy.row(i).to_vec());
            }
        }
    }

    Ok(())
}

Attività supportate#

Sono supportate tutte le attività di Ultralytics. Se ometti --model, viene scaricato automaticamente il modello nano corrispondente all'attività selezionata.

Attività--taskOutputModello predefinito
RilevamentodetectRiquadri di delimitazione e classiyolo26n.onnx
Segmentazione di istanzesegmentRiquadri e maschere per ogni istanzayolo26n-seg.onnx
Segmentazione semanticasemanticMappa delle classi per pixelyolo26n-sem.onnx
Stima della profonditàdepthMappa di profondità per pixel in metriyolo26n-depth.onnx
ClassificazioneclassifyProbabilità delle classiyolo26n-cls.onnx
PosaposeRiquadri e punti chiaveyolo26n-pose.onnx
Riquadri orientatiobbRiquadri di delimitazione ruotatiyolo26n-obb.onnx

--ocr aggiunge la lettura del testo nelle scene a qualsiasi modello di rilevamento, segmentazione o OBB; senza --model viene eseguito il rilevatore di testo yolo26n-text.onnx. Vedi OCR del testo nelle scene.

Compatibilità dei modelli#

Qualsiasi modello Ultralytics esportato in ONNX può essere caricato da un file locale. Il download automatico è disponibile per i nomi standard dei modelli YOLO26, YOLO11 e YOLOv8 nelle dimensioni n, s, m, l e x:

Famiglia di modelliVarianti scaricabili automaticamente
YOLO26yolo26{n,s,m,l,x}.onnx, -seg, -sem, -depth, -cls, -pose, -obb e -text
YOLO11yolo11{n,s,m,l,x}.onnx, -seg, -cls, -pose e -obb
YOLOv8yolov8{n,s,m,l,x}.onnx, -seg, -cls, -pose e -obb

La segmentazione semantica (-sem), la stima della profondità (-depth) e i rilevatori di testo nelle scene -text sono disponibili solo con YOLO26. Anche il riconoscitore PaddleOCR PP-OCRv6_medium_rec.onnx e il classificatore di orientamento PP-LCNet_x0_25_textline_ori.onnx usati da --ocr (Apache-2.0) vengono scaricati automaticamente. I modelli di rilevamento RT-DETR funzionano, ma non vengono scaricati automaticamente: prima esportane uno in ONNX. Le esportazioni IR native di OpenVINO funzionano con la funzionalità openvino-native; vedi modelli OpenVINO IR.

Sorgenti di input#

L'argomento --source (e il tipo Source nella libreria) accetta molti tipi di input, rilevati automaticamente a partire dalla stringa:

OrigineEsempioNote
Immagineimage.jpgFile singolo.
Directoryimages/Tutte le immagini nella cartella.
Globimages/*.jpgPattern in stile shell.
Videovideo.mp4Richiede la funzionalità video.
Webcam0Richiede la funzionalità video.
Streamrtsp://...Richiede la funzionalità video.
URLhttps://example.com/image.jpgDownload di immagini remote.

Inferenza a tasselli#

Le immagini di grandi dimensioni con oggetti piccoli, come le foto aeree o satellitari, possono essere suddivise in finestre sovrapposte e ricomposte in un unico risultato, come con l'argomento Python tile. Le finestre si sovrappongono del 20%, i riquadri vengono ricondotti all'immagine sorgente e i duplicati vengono rimossi per classe. Con un'esportazione a batch dinamico, --batch elabora più finestre in un'unica chiamata di inferenza. Sono supportate tutte le attività.

# 640 px windows; a bare --tile uses --imgsz
ultralytics-inference predict --model yolo26n-obb.onnx --source aerial.jpg --tile 640
use ultralytics_inference::{InferenceConfig, YOLOModel};

// with_tile(0) uses the inference size
let config = InferenceConfig::new().with_tile(640);
let mut model = YOLOModel::load_with_config("yolo26n.onnx", config)?;
let results = model.predict("aerial.jpg")?;

OCR del testo nelle scene#

I rilevatori YOLO26-Text individuano le parole come riquadri orientati, mentre TextRecognizer le legge con PP-OCRv6 di PaddleOCR, lo stesso riconoscitore usato nella soluzione OCR Python. Funzionano anche i riquadri dei modelli di rilevamento e le maschere dei modelli di segmentazione: una maschera viene ricavata dal rettangolo di area minima che racchiude il suo contorno e ne conserva il contorno come poligono. Ogni ritaglio viene ruotato per raddrizzarlo; i testi che il classificatore di orientamento rileva capovolti vengono letti di nuovo dopo una rotazione di 180°, e i testi vengono restituiti nell'ordine di lettura. Il riconoscitore viene eseguito sul dispositivo del rilevatore.

# Auto-downloads yolo26n-text.onnx and the PaddleOCR models
ultralytics-inference predict --ocr --source sign.jpg

# Any size of the text detector, on the GPU
ultralytics-inference predict --ocr --model yolo26x-text.onnx --source sign.jpg --device cuda:0

L'esempio della libreria carica l'immagine con il crate image, quindi aggiungilo accanto al pacchetto con cargo add image.

use ultralytics_inference::YOLOModel;
use ultralytics_inference::ocr::{DEFAULT_ORIENTATION, DEFAULT_RECOGNIZER, TextRecognizer};

let mut detector = YOLOModel::load("yolo26n-text.onnx")?;
let mut ocr = TextRecognizer::new(&detector, DEFAULT_RECOGNIZER, DEFAULT_ORIENTATION)?;
let image = image::open("sign.jpg")?;
let result = detector.predict_image(&image, "sign.jpg".into())?.remove(0);
for text in ocr.read(&image, &result)? {
    println!("{} {:.2} {:?}", text.text, text.confidence, text.polygon);
}

predict --ocr disegna ogni testo come la soluzione Python, e anche --line-width, --show-labels e --show-conf si applicano al testo.

Dispositivi e provider di esecuzione#

I backend GPU e acceleratori vengono compilati come funzionalità Cargo e selezionati in fase di esecuzione con --device (CLI) o Device (libreria). Se non specifichi un dispositivo, i provider compilati nella build vengono registrati seguendo un ordine di preferenza fisso (prima TensorRT, poi CUDA e così via); pertanto, una build con solo le funzionalità predefinite viene eseguita su CPU.

Stringa del dispositivoVariante DeviceFunzionalità di buildHardware
cpuDevice::CpuintegratoQualsiasi CPU
cuda:0Device::Cuda(0)cudaGPU NVIDIA
tensorrt:0Device::TensorRt(0)tensorrtGPU NVIDIA, ottimizzata
coremlDevice::CoreMlcoremlApple Silicon / macOS
intel:cpuDevice::IntelCpuopenvino o openvino-nativeCPU Intel
intel:gpuDevice::IntelGpuopenvino o openvino-nativeGPU Intel
intel:npuDevice::IntelNpuopenvino o openvino-nativeNPU Intel
directml:0Device::DirectMl(0)directmlGPU Windows
rocm:0Device::Rocm(0)rocmGPU AMD
migraphx:0Device::MiGraphX(0)migraphxGPU AMD (Linux x64)
xnnpackDevice::XnnpackxnnpackCPU ottimizzata
# Build the CLI with the providers you need
cargo install ultralytics-inference --features cuda,tensorrt

Modelli OpenVINO IR#

Con la funzionalità openvino-native, --model accetta anche un'esportazione OpenVINO nativa, il file .xml o la cartella yolo export format=openvino e la esegue tramite il runtime OpenVINO invece di ONNX Runtime. Tutte le attività vengono eseguite su intel:cpu, intel:gpu e intel:npu, e la libreria lo carica con YOLOModel::load("yolo26n_openvino_model"). Per la compilazione non serve installare OpenVINO; il runtime viene caricato all'apertura del primo modello. Per la configurazione, vedi la guida OpenVINO.

yolo export model=yolo26n.pt format=openvino # add quantize=16, quantize=8, dynamic=True, or batch=4
ultralytics-inference predict --model yolo26n_openvino_model --source bus.jpg --device intel:gpu

Accelerazione GPU e preelaborazione CUDA#

Sull'hardware NVIDIA, la funzionalità cuda abilita il provider di esecuzione CUDA, mentre tensorrt aggiunge il provider TensorRT per un'ulteriore ottimizzazione (include cuda, che esegue anche il riconoscitore OCR). Per ottenere la latenza di inferenza più bassa possibile, la funzionalità cuda-preprocess sposta la preelaborazione sulla GPU.

cuda-preprocess esegue il ridimensionamento letterbox, la normalizzazione e la conversione del layout da HWC a CHW come un unico kernel CUDA fuso, quindi passa il risultato al modello come tensore del dispositivo senza copie. Il fotogramma grezzo a 8 bit viene comunque caricato sulla GPU, attraverso un buffer di staging bloccato sulle GPU discrete; il kernel elimina il ridimensionamento, la normalizzazione e la conversione del layout sulla CPU, oltre al caricamento separato del tensore preelaborato, con vantaggi soprattutto per i batch ad alto throughput e gli stream in tempo reale.

# Build with fused GPU preprocessing (implies cuda + tensorrt)
cargo build --release --features cuda-preprocess

Il percorso rapido viene usato automaticamente, senza modifiche all'API, quando sono soddisfatte tutte le seguenti condizioni: la funzionalità è inclusa nella compilazione; il dispositivo è CUDA, TensorRT o non è specificato; l'attività è rilevamento, segmentazione, segmentazione semantica (solo immagini singole), stima della profondità, posa o OBB; il modello usa input FP32. È abilitato per impostazione predefinita e può essere disattivato per ciascun modello:

use ultralytics_inference::{Device, InferenceConfig};

let config = InferenceConfig::new()
    .with_device(Device::TensorRt(0))
    .with_cuda_preprocess(false); // force CPU preprocessing
Fai corrispondere il tuo toolkit CUDA

cuda-preprocess richiede un toolkit CUDA corrispondente in fase di compilazione e usa NVRTC in fase di esecuzione per il kernel di preelaborazione fuso. Consulta la guida all'accelerazione CUDA e TensorRT per i requisiti delle versioni e la risoluzione dei problemi.

Funzionalità Cargo#

Le funzionalità vengono abilitate in fase di compilazione. Le impostazioni predefinite includono l'annotazione e la visualizzazione dal vivo.

CaratteristicaPredefinitoScopo
annotatesìDisegna riquadri, maschere, punti chiave, etichette e testi OCR; necessario per --save.
visualizesìVisualizzazione in tempo reale in una finestra per --show.
videonoLeggi e scrivi file video (richiede FFmpeg dalla versione 6 alla 9).
cudanoProvider di esecuzione NVIDIA CUDA.
tensorrtnoProvider di esecuzione NVIDIA TensorRT (include cuda).
cuda-preprocessnoPreelaborazione GPU fusa (implica cuda e tensorrt; richiede il toolkit CUDA).
coremlnoProvider di esecuzione Apple CoreML.
openvinonoProvider di esecuzione Intel OpenVINO (Linux e Windows x64).
openvino-nativenoModelli OpenVINO IR nativi (.xml) tramite il runtime OpenVINO.
rocmnoProvider di esecuzione AMD ROCm (richiede una tua compilazione di ONNX Runtime).
migraphxnoProvider di esecuzione AMD MIGraphX (Linux x64).
directmlnoProvider di esecuzione Windows DirectML.
xnnpacknoProvider di esecuzione XNNPACK per un'inferenza CPU ottimizzata.

I gruppi di utilità raccolgono provider correlati: nvidia (cuda, tensorrt), amd (rocm, migraphx), intel (openvino, onednn), mobile (nnapi, coreml, qnn) e all (annotate, visualize, video). Sono disponibili anche altri provider: onednn, nnapi, qnn, acl, tvm, rknpu, cann, webgpu e azure.

Abilita le funzionalità durante l'installazione della CLI o l'aggiunta della libreria:

cargo install ultralytics-inference --features video
cargo install ultralytics-inference --features cuda,tensorrt
[dependencies]
ultralytics-inference = { version = "0.0.58", features = ["video"] }

Output e salvataggio#

Per impostazione predefinita, le previsioni vengono annotate e salvate in una directory di esecuzione con numerazione incrementale automatica:

runs/
└── detect/
    └── predict/          # then predict2, predict3, ...
        └── image.jpg     # annotated result

La sottocartella corrisponde all'attività (runs/segment/, runs/pose/ e così via). Per le sorgenti video, l'output annotato viene scritto come file video; passa --save-frames per scrivere invece i singoli fotogrammi. Per l'attività semantic, --save-json scrive mappe di classe PNG per pixel in una sottocartella results/. Per l'attività depth, la mappa di profondità colorata viene sovrapposta all'immagine sorgente, come nell'output plot() di Ultralytics Python. Il salvataggio di immagini e video annotati richiede la funzionalità annotate; l'esportazione delle mappe di classe semantiche in PNG non la richiede. L'input e l'output video richiedono la funzionalità video.

Il disegno segue quello di Python Results.plot(): lo spessore della linea predefinito è lo 0,3% del lato medio dell'immagine (almeno 2 px), le etichette si trovano sopra ogni riquadro o al suo interno quando non c'è spazio, e le maschere delle istanze vengono sovrapposte allo stesso modo, così le immagini salvate corrispondono a quelle Python. --line-width, --show-labels, --show-conf e --show-boxes funzionano come gli argomenti Python omonimi. Nella libreria, passali tramite AnnotateOptions:

use ultralytics_inference::annotate::{AnnotateOptions, annotate_image_with_options};

let options = AnnotateOptions {
    line_width: Some(3),
    show_conf: false,
    ..Default::default()
};
let annotated = annotate_image_with_options(&image, &results[0], &options);

Le maschere di segmentazione vengono create alla dimensione di inferenza, come in Python; passa --retina-masks (o InferenceConfig::with_retina_masks(true)) per crearle alla dimensione originale dell'immagine.

Domande frequenti#

  • No. Il crate esegue direttamente i modelli ONNX esportati tramite ONNX Runtime. Python serve solo se prima addestri o esporti i modelli con il pacchetto Ultralytics.

  • Qualsiasi modello YOLO di Ultralytics esportato in ONNX, inclusi YOLO26, YOLO11 e YOLOv8. I nomi dei modelli riconosciuti vengono scaricati automaticamente; puoi anche indicare a --model qualsiasi file .onnx locale.

  • Esporta dal pacchetto Python, ad esempio con l'integrazione ONNX, oppure lascia che la CLI scarichi alla prima esecuzione un modello nano standard per l'attività scelta.

  • Sì. --ocr legge il testo nelle scene con un rilevatore YOLO26-Text e PaddleOCR, come nella soluzione OCR Python, e funziona anche sui riquadri o sulle maschere dei tuoi modelli di rilevamento e segmentazione. Vedi OCR del testo nelle scene.

  • Usa l'inferenza a tasselli: --tile 640 suddivide l'immagine in finestre sovrapposte da 640 px e ricompone i rilevamenti in un unico risultato.

  • Sì, con la funzionalità video abilitata e FFmpeg dalla versione 6 alla 9 installato sul sistema. Sono supportati file video, webcam e flussi RTSP/RTMP/HTTP.

  • Entrambe sono abilitate per impostazione predefinita. annotate disegna riquadri, maschere, punti chiave ed etichette delle classi sull'immagine ed è necessaria affinché --save scriva i risultati annotati. visualize apre una finestra live per --show. Per una build più leggera e senza interfaccia grafica, che restituisce i risultati solo a livello programmatico, disabilitale con cargo build --no-default-features (riabilita le singole funzionalità secondo necessità).

  • Questa pagina offre una panoramica generale. Il riferimento API completo, suddiviso per tipo, per ogni struct pubblica, metodo e opzione di configurazione è pubblicato su docs.rs e generato direttamente dal codice sorgente.

Commenti

Fai una domanda, condividi i tuoi risultati o aiuta qualcun altro.