move layout code to layout

frontend/src/gallery/layout.rs

@@ -0,0 +1,90 @@
+use common::OutputPicture;
+use pathfinding::prelude::dijkstra;
+use weblog::console_log;
+
+
+pub fn get_common_height(row: &[OutputPicture], container_width: u32, margin: u32) -> f32 {
+    let row_width: u32 = container_width - row.len() as u32 * (margin * 2);
+    let total_aspect_ratio: f32 = row
+        .iter()
+        .map(|p| (p.width as f32) / (p.height as f32))
+        .sum();
+    row_width as f32 / total_aspect_ratio
+}
+
+pub fn cost(
+    photos: &[OutputPicture],
+    i: usize,
+    j: usize,
+    width: u32,
+    target_height: u32,
+    margin: u32,
+) -> u32 {
+    let common_height = get_common_height(&photos[i..j], width, margin);
+    (common_height - target_height as f32).powi(2) as u32
+}
+
+pub fn make_successors(
+    target_height: u32,
+    container_width: u32,
+    photos: &Vec<OutputPicture>,
+    limit_node_search: usize,
+    margin: u32,
+) -> Vec<Vec<(usize, u32)>> {
+    let mut results = vec![Vec::new(); photos.len()];
+    (0..photos.len()).for_each(|start| {
+        for j in start + 1..photos.len() + 1 {
+            if j - start > limit_node_search {
+                break;
+            }
+            results[start].push((
+                j,
+                cost(photos, start, j, container_width, target_height, margin),
+            ));
+        }
+    });
+    results
+}
+
+pub fn find_ideal_node_search(target_row_height: u32, container_width: u32) -> usize {
+    let row_aspect_ratio = container_width as f32 / target_row_height as f32;
+    (row_aspect_ratio / 1.5) as usize + 8
+}
+
+pub fn compute_row_layout(
+    container_width: u32,
+    limit_node_search: usize,
+    target_height: u32,
+    margin: u32,
+    photos: &Vec<OutputPicture>,
+) -> Option<Vec<(u32, u32)>> {
+    console_log!("compute row layout for width: {}", container_width);
+
+    if photos.is_empty() {
+        return None;
+    }
+
+    let successors = make_successors(
+        target_height,
+        container_width,
+        photos,
+        limit_node_search,
+        margin,
+    );
+    let path = dijkstra(&0, |p| successors[*p].clone(), |p| *p == photos.len());
+    let (path, _cost) = if let Some(p) = path {
+        p
+    } else {
+        (Vec::new(), 0)
+    };
+    let mut dimensions: Vec<(u32, u32)> = Vec::with_capacity(photos.len());
+    for i in 1..path.len() {
+        let row = &photos[path[i - 1]..path[i]];
+        let height = get_common_height(row, container_width, margin) as u32;
+        (path[i - 1]..path[i]).for_each(|j| {
+            let ratio = photos[j].width as f32 / photos[j].height as f32;
+            dimensions.push(((height as f32 * ratio) as u32, height));
+        });
+    }
+    Some(dimensions)
+}