Enum Location 

pub enum Location {
    Text {
        start: usize,
        end: usize,
    },
    BoundingBox {
        x: f32,
        y: f32,
        width: f32,
        height: f32,
        page: Option<u32>,
    },
    Temporal {
        start_sec: f64,
        end_sec: f64,
        frame: Option<u64>,
    },
    Cuboid {
        center: [f32; 3],
        dimensions: [f32; 3],
        rotation: [f32; 4],
    },
    Genomic {
        contig: String,
        start: u64,
        end: u64,
        strand: Option<char>,
    },
    Discontinuous {
        segments: Vec<(usize, usize)>,
    },
    TextWithBbox {
        start: usize,
        end: usize,
        bbox: Box<Location>,
    },
}

A location in some source medium.

This is the universal “localization unit” that enables the isomorphism between vision detection and NER. Both tasks answer “where is it?” just in different coordinate systems.

Relationship to Span

entity::Span is a simplified subset of Location for the detection layer:

Location variant	Span equivalent
Text	Span::Text
BoundingBox	Span::BoundingBox
TextWithBbox	Span::Hybrid
Temporal	none
Cuboid	none
Genomic	none
Discontinuous	none (use DiscontinuousSpan)

Use to_span() to convert where possible.

Design Note

We use an enum rather than a trait to enable:

• Efficient storage in contiguous arrays
• Easy serialization
• Exhaustive matching for safety

Variants

Text

Text span: 1D interval [start, end) in character offsets.

Fields

start: usize

Start character offset (inclusive)

end: usize

End character offset (exclusive)

BoundingBox

Visual bounding box: 2D rectangle in normalized [0,1] coordinates.

Fields

x: f32

X coordinate of top-left corner

y: f32

Y coordinate of top-left corner

width: f32

Width

height: f32

Height

page: Option<u32>

Page number for multi-page documents

Temporal

Temporal interval: for audio/video signals.

Fields

start_sec: f64

Start time in seconds

end_sec: f64

End time in seconds

frame: Option<u64>

Optional frame number for video

Cuboid

3D cuboid: for LiDAR/point cloud signals.

Fields

center: [f32; 3]

Center position (x, y, z)

dimensions: [f32; 3]

Dimensions (width, height, depth)

rotation: [f32; 4]

Rotation (quaternion: w, x, y, z)

Genomic

Genomic interval: 1D interval in sequence coordinates.

Fields

contig: String

Chromosome/contig identifier

start: u64

Start position (0-based, inclusive)

end: u64

End position (0-based, exclusive)

strand: Option<char>

Strand (+/-)

Discontinuous

Discontinuous text span: non-contiguous regions.

Fields

segments: Vec<(usize, usize)>

Multiple text intervals

TextWithBbox

Hybrid: text with visual location (OCR).

Fields

start: usize

Text start offset

end: usize

Text end offset

bbox: Box<Location>

Visual bounding box

Implementations

impl Location

pub const fn text(start: usize, end: usize) -> Location

Create a text location.

pub fn bbox(x: f32, y: f32, width: f32, height: f32) -> Location

Create a bounding box location.

pub const fn modality(&self) -> Modality

Get the modality of this location.

pub fn text_offsets(&self) -> Option<(usize, usize)>

Get text offsets if this is a text location.

pub fn overlaps(&self, other: &Location) -> bool

Check if two locations overlap.

pub fn iou(&self, other: &Location) -> Option<f64>

Calculate IoU (Intersection over Union) for compatible location types.

Returns None if the locations are incompatible (e.g., text vs bbox).

impl Location

Convert Location to Span where possible.

Not all Location variants have a corresponding Span:

• Location::Text → Span::Text
• Location::BoundingBox → Span::BoundingBox
• Location::TextWithBbox → Span::Hybrid
• Location::Discontinuous → None (use DiscontinuousSpan instead)
• Location::Temporal, Location::Cuboid, Location::Genomic → None

pub fn to_span(&self) -> Option<Span>

Try to convert this Location to a Span.

Returns None for Location variants that don’t map to Span (Temporal, Cuboid, Genomic, Discontinuous).

Trait Implementations

impl Clone for Location

fn clone(&self) -> Location

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Location

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

Formats the value using the given formatter.

impl Default for Location

fn default() -> Location

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Location

fn deserialize<__D>( __deserializer: __D, ) -> Result<Location, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<&Span> for Location

fn from(span: &Span) -> Location

Converts to this type from the input type.

impl From<Span> for Location

fn from(span: Span) -> Location

Converts to this type from the input type.

impl PartialEq for Location

fn eq(&self, other: &Location) -> 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 Serialize for Location

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Location