Atomize image

Author: joepio

Cargo.lock

@@ -6,6 +6,7 @@ version = "0.1.0"
 
 [dependencies]
 atomic_lib = {version = "0.34.0", path = "../lib"}
+kamadak-exif = "0.5.5"
 # Should match the version of pdf-extract
 mime_guess = "2.0.4"
-pdf-extract = {git = "https://github.com/Hessesian/pdf-extract"}
+pdf-extract = {path = "../../../joepio/pdf-extract"}

atomizer/Cargo.toml

@@ -1,38 +1,52 @@
-use std::{collections::HashMap, error::Error};
+use std::{collections::HashMap, error::Error, io::Read};
 
 use atomic_lib::resources::PropVals;
 use mime_guess::Mime;
 
-use crate::pdf;
-
 pub struct File {
     filename: String,
     mime: Mime,
-    bytes: Vec<u8>,
+    reader: std::io::BufReader<std::fs::File>,
 }
 
 impl File {
     pub fn open(filename: &str) -> Result<File, Box<dyn Error>> {
-        let bytes = std::fs::read(filename)?;
+        let bytes = std::fs::File::open(filename)?;
+        let reader = std::io::BufReader::new(bytes);
         let mime = mime_guess::from_path(filename).first_or_octet_stream();
 
         Ok(File {
             filename: filename.to_string(),
             mime,
-            bytes,
+            reader,
         })
     }
 
     /// Creates property-value combinations based on the file's contents.
     /// Defaults to an empty HashMap if the file type is not supported.
-    pub fn atomize(&self) -> PropVals {
+    pub fn atomize(self) -> PropVals {
         match self.mime.to_string().as_str() {
-            "application/pdf" => pdf::atomize(self),
+            "application/pdf" => crate::pdf::atomize(self),
+            "image/jpeg" => crate::image::atomize(self),
             _ => HashMap::new(),
         }
     }
 
-    pub fn bytes(&self) -> &[u8] {
-        &self.bytes
+    pub fn bytes(&mut self) -> Result<Vec<u8>, Box<dyn Error>> {
+        let mut buffer = vec![];
+        self.reader.read_to_end(&mut buffer)?;
+        Ok(buffer)
+    }
+
+    pub fn reader(&mut self) -> &mut std::io::BufReader<std::fs::File> {
+        &mut self.reader
+    }
+
+    pub fn mime(&self) -> &Mime {
+        &self.mime
+    }
+
+    pub fn filename(&self) -> &str {
+        &self.filename
     }
 }

atomizer/src/file.rs

@@ -0,0 +1,60 @@
+use atomic_lib::resources::PropVals;
+use exif::{In, Tag};
+
+const date_time: &str = "date_time";
+
+fn map_tag(tag: Tag) -> String {
+    match tag {
+        Tag::PixelXDimension => "pixel_x_dimension",
+        Tag::XResolution => "x_resolution",
+        Tag::ImageDescription => "image_description",
+        Tag::DateTime => date_time,
+        _ => "unknown",
+    }
+    .to_string()
+}
+
+/// Extracts the location from an image file's EXIF data.
+pub fn atomize(mut file: crate::file::File) -> PropVals {
+    let mut props = PropVals::new();
+
+    println!("Reading EXIF data from {}", file.filename());
+
+    let exif = exif::Reader::new()
+        .read_from_container(file.reader())
+        .unwrap();
+
+    let tag_list = [
+        Tag::PixelXDimension,
+        Tag::XResolution,
+        Tag::ImageDescription,
+        Tag::DateTime,
+    ];
+
+    for tag in tag_list {
+        if let Some(field) = exif.get_field(tag, In::PRIMARY) {
+            props.insert(
+                map_tag(tag),
+                atomic_lib::Value::String(field.display_value().to_string()),
+            );
+            println!("{}: {}", field.tag, field.display_value().with_unit(&exif));
+        }
+    }
+
+    props
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::file::File;
+
+    #[test]
+    fn load_image() {
+        let f = File::open("./test/image.jpg").unwrap();
+        let propvals = f.atomize();
+        let dt = propvals.get(date_time).unwrap();
+        println!("Date: {}", dt);
+        assert!(dt.to_string().contains("2008"));
+    }
+}

atomizer/src/image.rs

@@ -1,4 +1,5 @@
 pub mod file;
+mod image;
 mod pdf;
 
 use atomic_lib::Resource;

atomizer/src/lib.rs

@@ -3,11 +3,10 @@ use atomic_lib::resources::PropVals;
 const content_prop: &str = "content";
 
 /// Extracts the text from a PDF file.
-pub fn atomize(file: &crate::file::File) -> PropVals {
+pub fn atomize(mut file: crate::file::File) -> PropVals {
     let mut props = PropVals::new();
-    let mut s = String::new();
-    let mut output = pdf_extract::PlainTextOutput::new(&mut s);
-    let text = pdf_extract::extract_text_mem(file.bytes()).unwrap();
+    let bytes = file.bytes().unwrap();
+    let text = pdf_extract::extract_text_from_mem(&bytes).unwrap();
     props.insert(content_prop.into(), atomic_lib::Value::String(text));
     props
 }

atomizer/src/pdf.rs

@@ -9,7 +9,7 @@ use crate::{
     parse::ParseOpts,
     schema::{Class, Property},
     storelike::Query,
-    urls, Storelike, Value,
+    urls, Resource, Storelike, Value,
 };
 
 /// Populates a store with some of the most fundamental Properties and Classes needed to bootstrap the whole.