Struct LiveTextInteractionTypes 

pub struct LiveTextInteractionTypes(/* private fields */);

Implementations

impl LiveTextInteractionTypes

pub const NONE: Self

pub const AUTOMATIC: Self

pub const TEXT_SELECTION: Self

pub const DATA_DETECTORS: Self

pub const IMAGE_SUBJECT: Self

pub const VISUAL_LOOK_UP: Self

pub const AUTOMATIC_TEXT_ONLY: Self

pub const fn new(raw: u64) -> Self

pub const fn bits(self) -> u64

Examples found in repository

examples/02_framework_smoke.rs (line 57)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("== VisionKit.framework smoke ==");
    println!("ImageAnalyzer supported: {}", ImageAnalyzer::is_supported());
    println!(
        "document camera available on macOS: {}",
        VNDocumentCameraViewController::is_available_on_current_platform()?
    );
    println!(
        "data scanner available on macOS: {}",
        DataScannerViewController::is_available_on_current_platform()?
    );

    let languages = ImageAnalyzer::supported_text_recognition_languages()?;
    println!("supported OCR languages: {}", languages.len());
    println!(
        "sample OCR languages: {:?}",
        languages.iter().take(10).collect::<Vec<_>>()
    );

    if !ImageAnalyzer::is_supported() {
        println!("ImageAnalyzer is not supported on this Mac");
        return Ok(());
    }

    let analyzer = ImageAnalyzer::new()?;
    let configuration = ImageAnalyzerConfiguration::new(
        ImageAnalysisTypes::TEXT | ImageAnalysisTypes::MACHINE_READABLE_CODE,
    )
    .with_locales(["en-US"]);
    let asset_path = asset_path();
    let analysis =
        analyzer.analyze_image_at_path(&asset_path, ImageOrientation::Up, &configuration)?;

    println!(
        "has text results: {}",
        analysis.has_results(ImageAnalysisTypes::TEXT)?
    );
    let transcript = analysis.transcript()?;
    println!("transcript: {transcript:?}");

    let interaction = LiveTextInteraction::new()?;
    interaction.track_image_at_path(&asset_path)?;
    interaction.set_analysis(&analysis)?;
    println!(
        "overlay preferred types: {}",
        interaction.preferred_interaction_types()?.bits()
    );
    let overlay_text = interaction.text();
    println!("overlay text: {overlay_text:?}");
    Ok(())
}

pub const fn contains(self, other: Self) -> bool

Trait Implementations

impl BitOr for LiveTextInteractionTypes

type Output = LiveTextInteractionTypes

The resulting type after applying the | operator.

fn bitor(self, rhs: Self) -> Self::Output

Performs the | operation.

impl BitOrAssign for LiveTextInteractionTypes

fn bitor_assign(&mut self, rhs: Self)

Performs the |= operation.

impl Clone for LiveTextInteractionTypes

fn clone(&self) -> LiveTextInteractionTypes

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for LiveTextInteractionTypes

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for LiveTextInteractionTypes

fn default() -> Self

Returns the “default value” for a type.

impl Hash for LiveTextInteractionTypes

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for LiveTextInteractionTypes

fn eq(&self, other: &LiveTextInteractionTypes) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for LiveTextInteractionTypes

impl Eq for LiveTextInteractionTypes

impl StructuralPartialEq for LiveTextInteractionTypes