works

1 files changed, 47 insertions, 31 deletions

diff --git a/vgcodec/src/approximate.rs b/vgcodec/src/approximate.rs
index fc2b4ba..c4dc629 100644
--- a/vgcodec/src/approximate.rs
+++ b/vgcodec/src/approximate.rs
@@ -1,17 +1,13 @@
-use std::sync::Arc;
-
-use image::EncodableLayout;
-use log::info;
-use rand::Rng;
-use wgpu::{Extent3d, Texture, TextureUsages};
-
 use crate::{
     app::App,
     diff::Differ,
     export::Exporter,
-    helper::write_texture,
     paint::{PaintUniforms, Painter},
 };
+use log::{debug, info};
+use rand::Rng;
+use std::sync::Arc;
+use wgpu::{Extent3d, Texture, TextureUsages};
 
 #[allow(unused)]
 pub struct Approximator {
@@ -28,7 +24,7 @@ pub struct Approximator {
 
 impl Approximator {
     pub fn new(app: &Arc<App>, tex_target: Texture, size: Extent3d) -> Self {
-        let App { device, queue, .. } = app.as_ref();
+        let App { device, .. } = app.as_ref();
         let tex_approx = device.create_texture(&wgpu::TextureDescriptor {
             size,
             mip_level_count: 1,
@@ -51,8 +47,8 @@ impl Approximator {
             label: None,
         });
 
-        let img_initial = image::open("a/initial.png").unwrap().into_rgba8();
-        write_texture(queue, &tex_approx, img_initial.as_bytes(), size);
+        // let initial_init = (0..)
+        // write_texture(queue, &tex_approx, initial_init, size);
 
         let differ = Differ::new(&app, size, &tex_approx, &tex_target);
         let painter = Painter::new(&app, size, &tex_approx);
@@ -79,44 +75,62 @@ impl Approximator {
             .copy_texture(&self.tex_savestate, &self.tex_approx, self.size);
     }
 
-    pub async fn run(&mut self) {
-        for _ in 0..10 {
+    pub async fn run(&mut self, iters: usize) {
+        let rscale = self.size.width as f32 * 0.1;
+        for i in 0..iters {
             let mut p = PaintUniforms {
-                x: rand::thread_rng().gen_range(0.0..256.0),
-                y: rand::thread_rng().gen_range(0.0..256.0),
+                x: rand::thread_rng().gen_range(0.0..self.size.width as f32),
+                y: rand::thread_rng().gen_range(0.0..self.size.height as f32),
+                rx: rscale,
+                ry: rscale,
                 r: rand::thread_rng().gen_range(0.0..1.0),
                 g: rand::thread_rng().gen_range(0.0..1.0),
                 b: rand::thread_rng().gen_range(0.0..1.0),
-                radius: rand::thread_rng().gen_range(5.0..10.0),
             };
 
             // Find initial diff
             self.save();
             self.painter.run(p);
-            let mut cd = pollster::block_on(self.differ.run());
-            info!("initial diff={cd}");
+            let initial_diff = pollster::block_on(self.differ.run());
+            debug!("initial diff={initial_diff}");
             self.restore();
 
+            let mut cd = initial_diff;
             self.save();
             loop {
                 let mut q = 0;
-                q += self.optimize_param(&mut cd, &mut p, "more red", |p| p.r += 0.1);
-                q += self.optimize_param(&mut cd, &mut p, "less red", |p| p.r -= 0.1);
-                q += self.optimize_param(&mut cd, &mut p, "more green", |p| p.g += 0.1);
-                q += self.optimize_param(&mut cd, &mut p, "less green", |p| p.g -= 0.1);
-                q += self.optimize_param(&mut cd, &mut p, "more blue", |p| p.b += 0.1);
-                q += self.optimize_param(&mut cd, &mut p, "less blue", |p| p.b -= 0.1);
-                q += self.optimize_param(&mut cd, &mut p, "increase radius", |p| p.radius *= 1.5);
-                q += self.optimize_param(&mut cd, &mut p, "decrease radius", |p| p.radius *= 1.5);
-                q += self.optimize_param(&mut cd, &mut p, "move right", |p| p.x += 5.0);
-                q += self.optimize_param(&mut cd, &mut p, "move left", |p| p.x -= 5.0);
-                q += self.optimize_param(&mut cd, &mut p, "move down", |p| p.y += 5.0);
-                q += self.optimize_param(&mut cd, &mut p, "move up", |p| p.y -= 5.0);
+                let mut k = |k: usize| {
+                    q += k;
+                    q == 0
+                };
+                if k(self.optimize_param(&mut cd, &mut p, "more red", |p| p.r += 0.1)) {
+                    k(self.optimize_param(&mut cd, &mut p, "less red", |p| p.r -= 0.1));
+                }
+                if k(self.optimize_param(&mut cd, &mut p, "more green", |p| p.g += 0.1)) {
+                    k(self.optimize_param(&mut cd, &mut p, "less green", |p| p.g -= 0.1));
+                }
+                if k(self.optimize_param(&mut cd, &mut p, "more blue", |p| p.b += 0.1)) {
+                    k(self.optimize_param(&mut cd, &mut p, "less blue", |p| p.b -= 0.1));
+                }
+                if k(self.optimize_param(&mut cd, &mut p, "increase rx", |p| p.rx *= 1.5)) {
+                    k(self.optimize_param(&mut cd, &mut p, "decrease rx", |p| p.rx /= 1.5));
+                }
+                if k(self.optimize_param(&mut cd, &mut p, "increase ry", |p| p.ry *= 1.5)) {
+                    k(self.optimize_param(&mut cd, &mut p, "decrease ry", |p| p.ry /= 1.5));
+                }
+                if k(self.optimize_param(&mut cd, &mut p, "move right", |p| p.x += 5.0)) {
+                    k(self.optimize_param(&mut cd, &mut p, "move left", |p| p.x -= 5.0));
+                }
+                if k(self.optimize_param(&mut cd, &mut p, "move down", |p| p.y += 5.0)) {
+                    k(self.optimize_param(&mut cd, &mut p, "move up", |p| p.y -= 5.0));
+                }
                 if q == 0 {
                     break;
                 }
             }
             self.painter.run(p);
+
+            info!("{i} (improvement={})", initial_diff - cd);
         }
 
         self.exporter.run(&self.tex_approx, "a/approx.png").await;
@@ -139,13 +153,15 @@ impl Approximator {
             self.painter.run(p);
             let diff = pollster::block_on(self.differ.run());
             // pollster::block_on(self.exporter.run(&self.tex_approx, &format!("a/snap.png")));
+            debug!("try {label:?} ({})", diff as i64 - *current_diff as i64);
             self.restore();
             if diff >= *current_diff {
                 break i;
             }
-            info!("applied {label:?} (before={current_diff} after={diff})");
+            debug!("applied {label:?}");
             i += 1;
             *current_diff = diff;
+            *params = p
         }
     }
 }