S5-OBJ_Lang Labo_3 — Collaborations : dépendance et compositionLoading s5obj_lang_labo_3...
S5-OBJ_Lang Labo_3 — Collaborations : dépendance et compositionimg.ToGray();
public Image Apply(Image input) { }
static void TestGrayFilter( Image image, GrayFilter filter) { Image result = filter.Apply(image); string path = "results/" + image.GetName() + "_gray.ppm"; result.Save(path); }
Une dépendance apparaît lorsqu'un objet a besoin d'un autre objet pour réaliser
une tâche.GrayFilter filter = new GrayFilter(); Image imgGray = filter.Apply(img);
Cette classe représente un objet chargé d'organiser les traitements appliqués à une image.
La composition permet de construire des objets complexes à partir d'objets plus simples.use crate::image::{Color, Image};
pub struct GrayFilter;
impl GrayFilter { pub fn apply( &self, input: &Image, ) -> Image { let width = input.width(); let height = input.height(); let name = input.name().to_string();
let mut result = Image::new(width, height, name);
for y in 0..height { for x in 0..width { let c = input.pixel(x, y); let g = c.gray();
result.set_pixel(x, y, Color::new(g, g, g)); } }
result } }
use crate::filtres::GrayFilter; use crate::image::Image;
pub struct ImageProcessor { name: String, filter: GrayFilter, }
impl ImageProcessor { pub fn new(name: String) -> Self { Self { name, filter: GrayFilter::new(), } }
pub fn name(&self) -> &str { &self.name }
pub fn process( &self, input: &Image, ) -> Image { self.filter.apply(input) } }
pub mod filtres; pub mod image; pub mod image_processor;
use filtres::GrayFilter; use image::{Color, Image}; use image_processor::ImageProcessor;
fn test_gray_filter( image: &Image, filter: &GrayFilter, ) { let result = filter.apply(image);
let path = format!("results/{}_gray.ppm", image.name());
result.save(&path); }
fn test_image_processor(image: &Image) { let processor = ImageProcessor::new("IP1".to_string());
let result = processor.process(image);
let path = format!("results/{}_{}.ppm", image.name(), processor.name());
result.save(&path); }
fn main() { let image = Image::from_file("data/Lena.ppm");
let filter = GrayFilter; test_gray_filter(&image, &filter);
test_image_processor(&image); }
public Image Apply(Image input)
pub fn apply( &self, input: &Image, ) -> Image
private GrayFilter filter;
filter: GrayFilter,
filter: GrayFilter,
En Java et en C#, les objets étant manipulés par référence, la dépendance est implicite.
En Java et en C#, ces propriétés doivent être assurées par le concepteur de la classe.using ImageProcessing;
class Program { static void TestGrayFilter( Image image, GrayFilter filter) { Image result = filter.Apply(image); string path = "results/" + image.GetName() + "_gray.ppm"; result.Save(path); }
static void TestImageProcessor(Image image) { ImageProcessor processor = new ImageProcessor("IP1"); Image result = processor.Process(image); string path = "results/" + image.GetName() + "_" + processor.GetName() + ".ppm"; result.Save(path); }
static void Main() { Image image = new Image("data/Lena.ppm");
GrayFilter filter = new GrayFilter(); TestGrayFilter(image, filter);
TestImageProcessor(image); } }
namespace ImageProcessing;
public class GrayFilter { public Image Apply(Image input) { int width = input.GetWidth(); int height = input.GetHeight(); string name = input.GetName();
Image result = new Image(width, height, name);
for (int y = 0; y < height; y++) { for (int x = 0; x < width; x++) { Color c = input.GetPixel(x, y); float g = c.Gray(); result.SetPixel(x, y, new Color(g, g, g)); } }
return result; } }
namespace ImageProcessing;
public class ImageProcessor { private string name; private GrayFilter filter;
public ImageProcessor(string name) { this.name = name; filter = new GrayFilter(); }
public string GetName() { return name; }
public Image Process(Image input) { return filter.Apply(input); } }