Struct Field

pub struct Field {
    pub tag: Tag,
    pub ifd_num: In,
    pub value: Value,
}

A TIFF/Exif field.

Fields

tag: Tag

The tag of this field.

ifd_num: In

The index of the IFD to which this field belongs.

value: Value

The value of this field.

Implementations

impl Field

pub fn display_value(&self) -> DisplayValue<'_>

Returns an object that implements std::fmt::Display for printing the value of this field in a tag-specific format.

To print the value with the unit, call with_unit method on the returned object. It takes a parameter, which is either (), &Field, or &Exif, that provides the unit information. If the unit does not depend on another field, () can be used. Otherwise, &Field or &Exif should be used.

Examples

use exif::{Field, In, Tag, Value};

let xres = Field {
    tag: Tag::XResolution,
    ifd_num: In::PRIMARY,
    value: Value::Rational(vec![(72, 1).into()]),
};
let resunit = Field {
    tag: Tag::ResolutionUnit,
    ifd_num: In::PRIMARY,
    value: Value::Short(vec![3]),
};
assert_eq!(xres.display_value().to_string(), "72");
assert_eq!(resunit.display_value().to_string(), "cm");
// The unit of XResolution is indicated by ResolutionUnit.
assert_eq!(xres.display_value().with_unit(&resunit).to_string(),
           "72 pixels per cm");
// If ResolutionUnit is not given, the default value is used.
assert_eq!(xres.display_value().with_unit(()).to_string(),
           "72 pixels per inch");
assert_eq!(xres.display_value().with_unit(&xres).to_string(),
           "72 pixels per inch");

let flen = Field {
    tag: Tag::FocalLengthIn35mmFilm,
    ifd_num: In::PRIMARY,
    value: Value::Short(vec![24]),
};
// The unit of the focal length is always mm, so the argument
// has nothing to do with the result.
assert_eq!(flen.display_value().with_unit(()).to_string(),
           "24 mm");
assert_eq!(flen.display_value().with_unit(&resunit).to_string(),
           "24 mm");

Examples found in repository

examples/dumpexif.rs (line 62)

fn dump_file(path: &Path) -> Result<(), exif::Error> {
    let file = File::open(path)?;

    // To parse strictly:
    // let exif = exif::Reader::new()
    //     .read_from_container(&mut BufReader::new(&file))?;

    // To parse with continue-on-error mode:
    let exif = exif::Reader::new()
        .continue_on_error(true)
        .read_from_container(&mut BufReader::new(&file))
        .or_else(|e| e.distill_partial_result(|errors| {
            eprintln!("{}: {} warning(s)", path.display(), errors.len());
            errors.iter().for_each(|e| eprintln!("  {}", e));
        }))?;

    println!("{}", path.display());
    for f in exif.fields() {
        println!("  {}/{}: {}",
                 f.ifd_num.index(), f.tag,
                 f.display_value().with_unit(&exif));
        println!("      {:?}", f.value);
    }
    Ok(())
}

examples/reading.rs (line 50)

fn main() {
    let file = File::open("tests/exif.jpg").unwrap();
    let exif = Reader::new().read_from_container(
        &mut BufReader::new(&file)).unwrap();

    // To obtain a string representation, `Value::display_as`
    // or `Field::display_value` can be used.  To display a value with its
    // unit, call `with_unit` on the return value of `Field::display_value`.
    let tag_list = [Tag::ExifVersion,
                    Tag::PixelXDimension,
                    Tag::XResolution,
                    Tag::ImageDescription,
                    Tag::DateTime];
    for tag in tag_list {
        if let Some(field) = exif.get_field(tag, In::PRIMARY) {
            println!("{}: {}",
                     field.tag, field.display_value().with_unit(&exif));
        }
    }

    // To get unsigned integer value(s) from either of BYTE, SHORT,
    // or LONG, `Value::get_uint` or `Value::iter_uint` can be used.
    if let Some(field) = exif.get_field(Tag::PixelXDimension, In::PRIMARY) {
        if let Some(width) = field.value.get_uint(0) {
            println!("Valid width of the image is {}.", width);
        }
    }

    // To convert a Rational or SRational to an f64, `Rational::to_f64`
    // or `SRational::to_f64` can be used.
    if let Some(field) = exif.get_field(Tag::XResolution, In::PRIMARY) {
        match field.value {
            Value::Rational(ref vec) if !vec.is_empty() =>
                println!("X resolution is {}.", vec[0].to_f64()),
            _ => {},
        }
    }

    // To parse a DateTime-like field, `DateTime::from_ascii` can be used.
    if let Some(field) = exif.get_field(Tag::DateTime, In::PRIMARY) {
        match field.value {
            Value::Ascii(ref vec) if !vec.is_empty() => {
                if let Ok(datetime) = DateTime::from_ascii(&vec[0]) {
                    println!("Year of DateTime is {}.", datetime.year);
                }
            },
            _ => {},
        }
    }
}

Trait Implementations

impl Clone for Field

fn clone(&self) -> Field

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Field

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

Formats the value using the given formatter.