Decent object size adjuster

Author: dec4234

backgrounds/field3.jpg renamed to backgrounds/archive/field3.jpg

@@ -2,7 +2,8 @@ use std::ops::RangeTo;
 use std::path::{Path, PathBuf};
 use std::time::Instant;
 use anyhow::Result;
-use image::{ImageBuffer, Rgba, RgbaImage};
+use image::{GenericImage, ImageBuffer, Rgba, RgbaImage};
+use image::imageops::FilterType;
 use imageproc::drawing::draw_text_mut;
 use log::{debug, trace};
 use rand::{Rng, thread_rng};
@@ -13,33 +14,59 @@ use crate::objects::ObjectManager;
 pub struct TargetGenerator {
 	output: PathBuf,
 	backgrounds_path: PathBuf,
-	pub shape_manager: ObjectManager,
+	pub object_manager: ObjectManager,
 	background_loader: BackgroundLoader,
 }
 
 impl TargetGenerator {
 	pub fn new<Q: AsRef<Path>>(output: Q, background_path: Q, objects_path: Q) -> Result<Self> {
 
+		let mut object_manager = ObjectManager::new(objects_path);
+		object_manager.load_objects()?;
+		
 		Ok(Self {
 			output: output.as_ref().to_path_buf(),
 			backgrounds_path: background_path.as_ref().to_path_buf(),
-			shape_manager: ObjectManager::new(objects_path),
+			object_manager,
 			background_loader: BackgroundLoader::new(background_path)?,
 		})
 	}
 
-	pub fn generate_target(&self, altitude: f32) -> Result<()> {
-
-		debug!("Beginning to generate a target...");
+	pub fn generate_target(&self, altitude: f32, fov: f32, iteration: u32) -> Result<()> {
+		trace!("Beginning to generate a target...");
 
 		let mut background = self.background_loader.random().unwrap().clone();
 		let (w, h) = (background.width(), background.height());
-
-
-
-
-
-		background.save("output.png")?;
+		let set = self.object_manager.generate_set(1)?;
+		
+		let ground_width = calculate_ground_width(altitude, fov);
+		let meters_per_pixel = meters_per_pixel(w, ground_width);
+		
+		for obj in set {
+			let clone = &obj.dynamic_image.clone();
+			let (obj_w, obj_h) = (obj.dynamic_image.width(), obj.dynamic_image.height());
+			let (x, y) = (thread_rng().gen_range(0..w - obj_w), thread_rng().gen_range(0..h - obj_h));
+			trace!("Placing object at {}, {}", x, y);
+			/*let expected_size = expected_object_size_pixels(obj.object_width_meters, meters_per_pixel);
+			
+			let aspect_ratio = obj_w as f32 / obj_h as f32;
+			
+			debug!("Resizing object to {}x{}", expected_size as u32, (expected_size / aspect_ratio) as u32); //TODO: too big
+			
+			background.copy_from(&clone.resize(expected_size as u32, (expected_size / aspect_ratio) as u32, FilterType::Gaussian), x, y)?;*/
+			
+			let adjusted = resize_ratio(obj.object_width_meters, METER_CONST);
+			debug!("Width: {}, Height: {}", obj_w, obj_h);
+			let aspect_ratio = obj_w as f32 / obj_h as f32;
+			let (obj_w, obj_h) = (adjusted as u32, (adjusted / aspect_ratio) as u32);
+
+			debug!("Resizing object to {}x{}", obj_w, obj_h); //TODO: too big
+
+			background.copy_from(&clone.resize(obj_w, obj_h, FilterType::Gaussian), x, y)?;
+		}
+		
+		background.save(format!("output_{iteration}.png"))?;
+		debug!("Saved generated target to output_{iteration}.png");
 
 		Ok(())
 	}
@@ -55,6 +82,26 @@ impl TargetGenerator {
 	}
 }
 
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
+pub struct BoundingBox {
+	pub x: u32,
+	pub y: u32,
+	pub width: u32,
+	pub height: u32,
+}
+
+const METER_CONST: f32 = 35.0;
+
+fn resize_ratio(object_real_size: f32, pixels_per_meter: f32) -> f32 {
+	debug!("Real size: {}, Pixels per meter: {}", object_real_size, pixels_per_meter);
+	object_real_size * pixels_per_meter
+}
+
+fn degrees_to_radians(degrees: f32) -> f32 {
+	degrees * std::f32::consts::PI / 180.0
+}
+
+// Calculate the fov in radians based on the image width, height and focal length
 fn calculate_fov(image_width: u32, image_height: u32, focal_length: f32) -> f32 {
 	2.0 * (0.5 * image_width as f32 / focal_length).atan()
 }
@@ -79,6 +126,6 @@ fn expected_object_size_pixels(real_size: f32, meters_per_pixel: f32) -> f32 {
 pub fn test_generate_target() {
 	SimpleLogger::new().init().unwrap();
 
-	let tg = TargetGenerator::new("output", "backgrounds", "shapes").unwrap();
-	tg.generate_target( 22.8).unwrap();
+	let tg = TargetGenerator::new("output", "backgrounds", "objects").unwrap();
+	tg.generate_target( 22.8, degrees_to_radians(35.0), 1).unwrap();
 }

src/generator/mod.rs

@@ -10,7 +10,6 @@ use serde::{Deserialize, Serialize};
 pub struct ObjectManager {
 	path_buf: PathBuf,
 	objects: Vec<Object>,
-	
 }
 
 impl ObjectManager {
@@ -21,9 +20,11 @@ impl ObjectManager {
 		}
 	}
 
+	/// Load training objects into the buffer
 	pub fn load_objects(&mut self) -> Result<()> {
 		let mut entries = std::fs::read_dir(&self.path_buf)?;
 
+		// retrieve objects.json file that holds all info about our training objects
 		let out = entries.find(|entry| {
 			let entry = entry.as_ref().unwrap().path();
 
@@ -66,6 +67,9 @@ impl ObjectManager {
 		Ok(())
 	}
 
+	/// Generate a set of training objects a random that could be used to generate a target
+	/// [amount] is the maximum number of objects to return
+	/// Returns a set of objects that will contain no duplicates
 	pub fn generate_set(&self, amount: u32) -> Result<HashSet<&Object>> {
 		let mut rng = rand::thread_rng();
 		let mut set = HashSet::new();
@@ -74,21 +78,26 @@ impl ObjectManager {
 			return Err(anyhow!("Amount of objects requested is greater than the amount of objects available"));
 		}
 
-		while set.len() < amount as usize {
-			let object = self.objects.choose(&mut rng).unwrap();
+		self.objects.choose_multiple(&mut rng, amount as usize).for_each(|object| {
 			set.insert(object);
-		}
+		});
 
 		Ok(set)
 	}
 }
 
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub struct Object {
 	object_class: ObjectClass,
 	id: u16,
-	dynamic_image: DynamicImage,
-	object_width_meters: f32,
+	pub(crate) dynamic_image: DynamicImage,
+	pub(crate) object_width_meters: f32,
+}
+
+impl Object {
+	pub fn to_rgba_image(&self) -> RgbaImage {
+		self.dynamic_image.to_rgba8()
+	}
 }
 
 impl PartialEq for Object {
@@ -122,11 +131,13 @@ impl ObjectClass {
 	}
 }
 
+/// Represents the object details file that holds all the information about the training objects
 #[derive(Debug, PartialEq, Serialize, Deserialize)]
 pub struct ObjectDetailsFile {
 	map: HashMap<String, ObjectDetails>
 }
 
+/// All details about a training object
 #[derive(Debug, PartialEq, Copy, Clone, Serialize, Deserialize)]
 pub struct ObjectDetails {
 	ground_width: f32