S5-OBJ_Lang Labo_4 — Interfaces et Polymorphisme dynamiqueLoading s5obj_lang_labo_4...
S5-OBJ_Lang Labo_4 — Interfaces et Polymorphisme dynamique
L'implémentation de la méthode Apply() de
ce filtre est très proche de celle de GrayFilter.string path = "results/" + image.GetName() + "_invert.ppm";
Image ↓ GrayFilter ↓ InvertFilter ↓ Résultat
Cette relation était une composition.
Une première idée pour ajouter plusieurs filtres à l'ImageProcessor
consiste à généraliser cette solution.
Pour représenter cet ensemble, nous avons utilisé un tableau :
Color[] pixels;
???[] filters;
Filter[] filters;
public interface IImageFilter { Image Apply(Image input); }
class GrayFilter : IImageFilter { ... }
Cette solution n'était pas possible car les filtres n'avaient pas le même type.List<IImageFilter> filters;
filters.Add(filter);
int[] values = {1, 2, 3, 4};
foreach (int value in values) { Console.WriteLine(value); }
IImageFilter filter = new GrayFilter();
processor1.AddFilter(filter); processor2.AddFilter(filter);
processor.AddFilter(filter);
processor.AddFilter(new GrayFilter()); processor.AddFilter(new InvertFilter());
IImageFilter filter = new GrayFilter();
processor1.AddFilter(filter); processor2.AddFilter(filter);
IImageFilter filter;
filter = new GrayFilter(); filter.Apply(image);
filter = new InvertFilter(); filter.Apply(image);
Ce mécanisme présente toutefois un coût.class A { protected float attr1; protected String attr2;
public virtual void f() { } }
class B : A { ... }
class C : A { ... }
A value = new B(); value = new C();
use crate::image::{Color, Image};
pub trait IImageFilter { fn apply( &self, input: &Image, ) -> Image; }
pub struct GrayFilter;
impl IImageFilter for GrayFilter { fn apply( &self, input: &Image, ) -> Image { ... } }
pub struct InvertFilter;
impl IImageFilter for InvertFilter { fn apply( &self, input: &Image, ) -> Image { let width = input.width(); let height = input.height();
let mut result = Image::new(width, height, input.name().to_string());
for y in 0..height { for x in 0..width { let c = input.pixel(x, y);
result.set_pixel( x, y, Color::new(1.0 - c.r(), 1.0 - c.g(), 1.0 - c.b()), ); } }
result } }
use crate::filtres::IImageFilter; use crate::image::Image;
pub struct ImageProcessor { name: String, filters: Vec<Box<dyn IImageFilter>>, }
impl ImageProcessor { pub fn new(name: String) -> Self { Self { name, filters: Vec::new(), } }
pub fn name(&self) -> &str { &self.name }
pub fn add_filter( &mut self, filter: Box<dyn IImageFilter>, ) { self.filters.push(filter); }
pub fn process( &self, input: &Image, ) -> Image { let mut current = input.clone();
for filter in &self.filters { current = filter.apply(¤t); }
current } }
fn test_invert_filter( image: &Image, filter: &InvertFilter, ) { let result = filter.apply(image);
let path = format!("results/{}_invert.ppm", image.name());
result.save(&path); }
fn test_image_processor(image: &Image) { let mut processor = ImageProcessor::new("Gray_Invert".to_string());
processor.add_filter(Box::new(GrayFilter)); processor.add_filter(Box::new(InvertFilter));
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 invert_filter = InvertFilter; test_invert_filter(&image, &invert_filter);
test_image_processor(&image); }
pub trait IImageFilter { fn apply(&self, input: &Image) -> Image; }
pub struct GrayFilter;
impl IImageFilter for GrayFilter { ... }
private List<IImageFilter> filters;
filters: Vec<...>
filters: Vec<dyn IImageFilter>,
filters: Vec<Box<dyn IImageFilter>>,
pub fn add_filter( &mut self, filter: Box<dyn IImageFilter>, ) { self.filters.push(filter); }
processor.AddFilter(new GrayFilter()); processor.AddFilter(new InvertFilter());
processor.add_filter(Box::new(GrayFilter)); processor.add_filter(Box::new(InvertFilter));
Dans les quatre langages, ces mécanismes permettent de manipuler des objets
différents à travers une même abstraction (polymorphisme).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 TestInvertFilter( Image image, InvertFilter filter) { Image result = filter.Apply(image); string path = "results/" + image.GetName() + "_invert.ppm"; result.Save(path); }
static void TestImageProcessor(Image image) { ImageProcessor processor1 = new ImageProcessor("Gray_Invert"); processor1.AddFilter(new GrayFilter()); processor1.AddFilter(new InvertFilter()); Image result1 = processor1.Process(image); string path1 = "results/" + image.GetName() + "_" + processor1.GetName() + ".ppm"; result1.Save(path1);
ImageProcessor processor2 = new ImageProcessor("Invert_Gray"); processor2.AddFilter(new GrayFilter()); processor2.AddFilter(new InvertFilter()); Image result2 = processor2.Process(image); string path2 = "results/" + image.GetName() + "_" + processor2.GetName() + ".ppm"; result2.Save(path2); }
static void Main() { Image image = new Image("data/Lena.ppm");
InvertFilter invertFilter = new InvertFilter(); TestInvertFilter(image, invertFilter);
TestImageProcessor(image); } }
namespace ImageProcessing;
public interface IImageFilter { Image Apply(Image input); }
public class GrayFilter : IImageFilter { 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; } }
public class InvertFilter : IImageFilter { public Image Apply(Image input) { int width = input.GetWidth(); int height = input.GetHeight();
Image result = new Image(width, height);
for (int y = 0; y < height; y++) { for (int x = 0; x < width; x++) { Color c = input.GetPixel(x, y);
result.SetPixel(x, y, new Color( 1f - c.GetR(), 1f - c.GetG(), 1f - c.GetB() )); } }
return result; } }
namespace ImageProcessing;
public class ImageProcessor { private string name; private List<IImageFilter> filters;
public ImageProcessor(string name) { this.name = name; this.filters = new List<IImageFilter>(); }
public string GetName() { return name; }
public void AddFilter(IImageFilter filter) { filters.Add(filter); }
public Image Process(Image input) { Image current = input;
foreach (var f in filters) { current = f.Apply(current); }
return current; } }