feat: improved immage processing

Author: RouHim

src/exif_reader.rs

@@ -3,6 +3,7 @@ use exif::{Exif, In, Reader, Tag};
 
 use crate::{geo_location, WebDavClient, WebDavResource};
 use crate::geo_location::GeoLocation;
+use crate::image_processor::ImageOrientation;
 
 pub fn get_exif_date(exif_data: &Exif) -> Option<NaiveDateTime> {
     let mut exif_date: Option<NaiveDateTime> = detect_exif_date(
@@ -58,10 +59,12 @@ pub fn fill_exif_data(web_dav_client: &WebDavClient, resource: &WebDavResource)
 
     let mut taken_date = None;
     let mut location = None;
+    let mut orientation = None;
 
     if let Some(exif_data) = maybe_exif_data {
         taken_date = get_exif_date(&exif_data);
         location = detect_location(&exif_data);
+        orientation = detect_orientation(&exif_data);
     }
 
     if taken_date.is_none() {
@@ -70,6 +73,7 @@ pub fn fill_exif_data(web_dav_client: &WebDavClient, resource: &WebDavResource)
 
     augmented_resource.taken = taken_date;
     augmented_resource.location = location;
+    augmented_resource.orientation = orientation;
 
     augmented_resource
 }
@@ -88,6 +92,23 @@ fn detect_location(exif_data: &Exif) -> Option<GeoLocation> {
     None
 }
 
+fn detect_orientation(exif_data: &Exif) -> Option<ImageOrientation> {
+    let maybe_orientation = exif_data.get_field(Tag::Orientation, In::PRIMARY)
+        .and_then(|field| field.value.get_uint(0));
+
+    match maybe_orientation {
+        Some(1) => Some(ImageOrientation { rotation: 0, mirror_vertically: false }),
+        Some(2) => Some(ImageOrientation { rotation: 0, mirror_vertically: true }),
+        Some(3) => Some(ImageOrientation { rotation: 180, mirror_vertically: false }),
+        Some(4) => Some(ImageOrientation { rotation: 180, mirror_vertically: true }),
+        Some(5) => Some(ImageOrientation { rotation: 90, mirror_vertically: true }),
+        Some(6) => Some(ImageOrientation { rotation: 90, mirror_vertically: false }),
+        Some(7) => Some(ImageOrientation { rotation: 270, mirror_vertically: true }),
+        Some(8) => Some(ImageOrientation { rotation: 270, mirror_vertically: false }),
+        _ => None,
+    }
+}
+
 fn detect_date_by_name(resource_path: &str) -> Option<NaiveDateTime> {
     let parsed: Vec<NaiveDate> = resource_path
         .replace('/', "_")

src/image_processor.rs

@@ -3,20 +3,61 @@ use std::time::Instant;
 
 use image::imageops::FilterType;
 use image::io::Reader as ImageReader;
+use serde::{Deserialize, Serialize};
 
-pub fn scale(resource_data: Vec<u8>, display_width: u32, display_height: u32) -> Vec<u8> {
-    let img = ImageReader::new(Cursor::new(resource_data))
+#[derive(Serialize, Deserialize, Debug, Copy, Clone)]
+pub struct ImageOrientation {
+    pub rotation: u16,
+    pub mirror_vertically: bool,
+}
+
+/// Adjusts the image to fit optimal to the browser resolution
+/// Also fixes the orientation delivered by the exif image rotation
+/// src: https://sirv.com/help/articles/rotate-photos-to-be-upright/
+pub fn optimize_image(resource_data: Vec<u8>, display_width: u32, display_height: u32, image_orientation: Option<ImageOrientation>) -> Vec<u8> {
+    let mut s = Instant::now();
+
+    let original_image = ImageReader::new(Cursor::new(resource_data))
         .with_guessed_format().unwrap()
         .decode().unwrap();
+    println!("loading from memory {}s!", s.elapsed().as_millis());
+    s = Instant::now();
 
-    let resize = img.resize(
+    let resized = original_image.resize(
         display_width,
         display_height,
-        FilterType::Nearest
+        FilterType::Nearest,
     );
+    println!("Resize {}s!", s.elapsed().as_millis());
+    s = Instant::now();
+
+    let fixed_orientation = if let Some(orientation) = image_orientation {
+        let rotated = match orientation.rotation {
+            90 => resized.rotate90(),
+            180 => resized.rotate180(),
+            270 => resized.rotate270(),
+            _ => resized,
+        };
+        println!("rotation {:?}: {}s!", orientation.rotation, s.elapsed().as_millis());
+        s = Instant::now();
+
+        let mirrored = if orientation.mirror_vertically {
+            rotated.flipv()
+        } else {
+            rotated
+        };
+        println!("mirroring {}s!", s.elapsed().as_millis());
+        s = Instant::now();
+
+        mirrored
+    } else {
+        resized
+    };
 
     let mut bytes: Vec<u8> = Vec::new();
-    resize.write_to(&mut bytes, image::ImageOutputFormat::Png).unwrap();
+    fixed_orientation.write_to(&mut bytes, image::ImageOutputFormat::Png).unwrap();
+    println!("writing bytes {}s!", s.elapsed().as_millis());
+    println!("====!");
 
     bytes
 }

src/image_processor_test.rs

@@ -14,7 +14,12 @@ fn scale_image() {
     ).unwrap().bytes().unwrap().to_vec();
 
     // WHEN resolving the city name
-    let scaled_image_buf = image_processor::scale(image_data, 1024, 786);
+    let scaled_image_buf = image_processor::optimize_image(
+        image_data,
+        1024,
+        786,
+        None
+    );
 
     // THEN the resolved city name should be Koblenz
     let scaled_image = ImageReader::new(Cursor::new(scaled_image_buf))

src/main.rs

@@ -72,6 +72,7 @@ async fn main() -> std::io::Result<()> {
     println!("Stopping Scheduler 🕐️");
     scheduler_handle.stop();
 
+    println!("Stopping Application 😵️");
     // Done, let's get out here
     http_server_result
 }

src/resource_endpoint.rs

@@ -2,7 +2,7 @@ use actix_http::Response as HttpResponse;
 use actix_web::web;
 use evmap::ReadHandle;
 
-use crate::{get, image_processor, resource_processor, WebDavClient};
+use crate::{get, image_processor, resource_processor, WebDavClient, WebDavResource};
 
 #[get("")]
 pub async fn list_resources(kv_reader: web::Data<ReadHandle<String, String>>) -> HttpResponse {
@@ -29,12 +29,20 @@ pub async fn get_resource(resources_id: web::Path<(String, u32, u32)>, kv_reader
     let display_width = path_params.1;
     let display_height = path_params.2;
 
-    let resource_data = kv_reader.get_one(resource_id)
+    let web_dav_resource = kv_reader.get_one(resource_id)
         .map(|value| value.to_string())
-        .and_then(|resource_json_string| serde_json::from_str(resource_json_string.as_str()).ok())
+        .and_then(|resource_json_string| serde_json::from_str(resource_json_string.as_str()).ok());
+    let orientation = web_dav_resource.clone().and_then(|web_dav_resource: WebDavResource| web_dav_resource.orientation);
+
+    let resource_data = web_dav_resource
         .map(|web_dav_resource| web_dav_client.request_resource_data(&web_dav_resource))
         .and_then(|web_response| web_response.bytes().ok())
-        .map(|resource_data| image_processor::scale(resource_data.to_vec(), display_width, display_height));
+        .map(|resource_data| image_processor::optimize_image(
+            resource_data.to_vec(),
+            display_width,
+            display_height,
+            orientation,
+        ));
 
     if let Some(resource_data) = resource_data {
         HttpResponse::Ok()
@@ -47,17 +55,22 @@ pub async fn get_resource(resources_id: web::Path<(String, u32, u32)>, kv_reader
 
 #[get("{resource_id}/{display_width}/{display_height}/base64")]
 pub async fn get_resource_base64(resources_id: web::Path<(String, u32, u32)>, kv_reader: web::Data<ReadHandle<String, String>>, web_dav_client: web::Data<WebDavClient>) -> HttpResponse {
+    // TODO request caching
+
     let path_params = resources_id.0;
     let resource_id = path_params.0.as_str();
     let display_width = path_params.1;
     let display_height = path_params.2;
 
-    let base64_image = kv_reader.get_one(resource_id)
+    let web_dav_resource = kv_reader.get_one(resource_id)
         .map(|value| value.to_string())
-        .and_then(|resource_json_string| serde_json::from_str(resource_json_string.as_str()).ok())
+        .and_then(|resource_json_string| serde_json::from_str(resource_json_string.as_str()).ok());
+    let orientation = web_dav_resource.clone().and_then(|web_dav_resource: WebDavResource| web_dav_resource.orientation);
+
+    let base64_image = web_dav_resource
         .map(|web_dav_resource| web_dav_client.request_resource_data(&web_dav_resource))
         .and_then(|web_response| web_response.bytes().ok())
-        .map(|resource_data| image_processor::scale(resource_data.to_vec(), display_width, display_height))
+        .map(|resource_data| image_processor::optimize_image(resource_data.to_vec(), display_width, display_height, orientation))
         .map(|scaled_image| base64::encode(&scaled_image))
         .map(|base64_string| format!("data:image/png;base64,{}", base64_string));
 

src/web_dav_client.rs

@@ -12,6 +12,7 @@ use serde::{Deserialize, Serialize};
 
 use crate::{exif_reader, resource_processor};
 use crate::geo_location::GeoLocation;
+use crate::image_processor::ImageOrientation;
 
 #[derive(Clone)]
 pub struct WebDavClient {
@@ -31,6 +32,7 @@ pub struct WebDavResource {
     pub last_modified: NaiveDateTime,
     pub taken: Option<NaiveDateTime>,
     pub location: Option<GeoLocation>,
+    pub orientation: Option<ImageOrientation>,
 }
 
 impl WebDavResource {
@@ -125,8 +127,7 @@ fn parse_propfind_result(web_dav_client: &WebDavClient, xml: String) -> Vec<WebD
         .collect();
 
     xml_nodes.par_iter()
-        // TODO: allow all type of media and convert on get, to an image
-        .filter(|resource| resource.content_type.eq("image/jpeg"))
+        .filter(|resource| resource.content_type.starts_with("image/"))
         .filter(|resource| !resource.path.contains("thumbnail"))
         .map(|resource| exif_reader::fill_exif_data(web_dav_client, resource))
         .collect()
@@ -173,5 +174,6 @@ fn parse_resource_node(response_node: Node) -> Option<WebDavResource> {
         ).unwrap(),
         taken: None,
         location: None,
+        orientation: None,
     })
 }