Update architecture

src/main/java/presenters/FilteringPresenter.java

@@ -1,55 +0,0 @@
-package presenters;
-
-import app.state.FilteringState;
-import com.google.common.eventbus.Subscribe;
-import com.google.inject.Inject;
-import domain.events.filtering.HighPassChangedEvent;
-import domain.events.filtering.LowPassChangedEvent;
-import domain.image.GrayScaleMatrix;
-import domain.image.Image;
-import services.FilteringService;
-import services.ImageService;
-import ui.abstractions.IFilteringView;
-
-public class FilteringPresenter {
-
-    private final FilteringState state;
-    private final ImageService imageService;
-    private final FilteringService filteringService;
-    private IFilteringView view;
-
-    @Inject
-    public FilteringPresenter(FilteringState state, ImageService imageService, FilteringService filteringService) {
-        this.state = state;
-        this.state.register(this);
-
-        this.imageService = imageService;
-        this.filteringService = filteringService;
-    }
-
-    public void setView(IFilteringView view){
-        this.view = view;
-    }
-
-    public void computeLowPassFiltering(int percentage){
-        GrayScaleMatrix matrix = imageService.getGrayScale();
-        Image image = filteringService.lowPassFiltering(matrix, (double) percentage /100);
-        this.state.setLowPass(image);
-    }
-
-    public void computeHighPassFiltering(int percentage){
-        GrayScaleMatrix matrix = imageService.getGrayScale();
-        Image image = filteringService.highPassFiltering(matrix, (double) percentage /100);
-        this.state.setHighPass(image);
-    }
-
-    @Subscribe
-    public void onLowPassUpdate(LowPassChangedEvent event){
-        view.updateLowPassFiltering(event.image());
-    }
-
-    @Subscribe
-    public void onHighPassUpdate(HighPassChangedEvent event){
-        view.updateHighPassFiltering(event.image());
-    }
-}

src/main/java/presenters/MainPresenter.java

@@ -1,67 +1,63 @@
 package presenters;
 
-import com.google.common.eventbus.EventBus;
-import com.google.common.eventbus.Subscribe;
+import app.state.AppState;
+import app.state.AppStateListener;
 import com.google.inject.Inject;
 import domain.common.Mode;
-import domain.events.ImageChangedEvent;
-import domain.events.ModeChangedEvent;
 import domain.image.Image;
 import services.ImageService;
 import services.ModeService;
 import ui.abstractions.IMainView;
 
-/**
- * @author Laurent Crema
- */
-public class MainPresenter {
-
+public class MainPresenter implements AppStateListener {
     private IMainView view;
+    private final AppState appState;
     private final ModeService modeService;
     private final ImageService imageService;
 
     @Inject
-    public MainPresenter(ModeService modeService, ImageService imageService, EventBus eventBus) {
+    public MainPresenter(AppState appState, ModeService modeService, ImageService imageService) {
+        this.appState = appState;
         this.modeService = modeService;
         this.imageService = imageService;
-        eventBus.register(this);
+        this.appState.subscribe(this);
     }
 
     public void setView(IMainView view) {
         this.view = view;
     }
 
-    @Subscribe
-    public void onImageChanged(ImageChangedEvent e){
-        view.displayImage(e.image());
+    @Override
+    public void onImageChanged(Image image) {
+        view.displayImage(image);
     }
 
-    @Subscribe
-    public void onModeChanged(ModeChangedEvent e){
-        view.changeMode(e.mode());
+    @Override
+    public void onModeChanged(Mode mode) {
+        view.changeMode(mode);
     }
 
-    public void drawPixel(int x, int y, int red, int green, int blue){
-        if(modeService.getMode() != Mode.DRAW_PIXEL) return;
-        Image image = imageService.getImage();
+    public void drawPixel(int x, int y, int red, int green, int blue) {
+        if (modeService.getMode() != Mode.DRAW_PIXEL) return;
+
+        Image image = appState.getImage();
         image.setPixelColor(x, y, red, green, blue);
-        imageService.setImage(image);
+        appState.setImage(image);
     }
 
-    public void drawShape(int x1, int x2, int y1, int y2, int red, int green, int blue){
-        Image image = imageService.getImage();
+    public void drawShape(int x1, int x2, int y1, int y2, int red, int green, int blue) {
+        Image image = appState.getImage();
+
         switch (modeService.getMode()) {
-            case DRAW_RECTANGLE:
-                image.setRectangleColor(x1, x2, y1, y2, red, green, blue);
-                break;
-            case DRAW_LINE:
-                image.setLineColor(x1, x2, y1, y2, red, green, blue);
-                break;
-            case DRAW_CIRCLE:
-                break;
+            case DRAW_RECTANGLE -> image.setRectangleColor(x1, x2, y1, y2, red, green, blue);
+            case DRAW_LINE -> image.setLineColor(x1, x2, y1, y2, red, green, blue);
+            case DRAW_CIRCLE -> {}
         }
-        imageService.setImage(image);
+
+        appState.setImage(image);
     }
 
-
-}
+    public void dispose() {
+        appState.unsubscribe(this);
+    }
+}

src/main/java/presenters/NavPresenter.java

@@ -1,9 +1,11 @@
 package presenters;
 
 import app.INavigator;
+import app.state.AppState;
 import com.google.inject.Inject;
 import domain.common.Mode;
 import domain.image.GrayScaleMatrix;
+import domain.image.Image;
 import services.ImageService;
 import services.ModeService;
 import ui.abstractions.INavBar;
@@ -11,19 +13,17 @@ import ui.abstractions.INavBar;
 import java.io.File;
 import java.io.IOException;
 
-/**
- * @author Laurent Crema
- */
 public class NavPresenter {
-
     private INavBar navBar;
-    private INavigator navigator;
+    private final INavigator navigator;
+    private final AppState appState;
     private final ImageService imageService;
     private final ModeService modeService;
 
     @Inject
-    public NavPresenter(INavigator navigator, ImageService imageService, ModeService modeService) {
+    public NavPresenter(INavigator navigator, AppState appState, ImageService imageService, ModeService modeService) {
         this.navigator = navigator;
+        this.appState = appState;
         this.imageService = imageService;
         this.modeService = modeService;
     }
@@ -33,27 +33,28 @@ public class NavPresenter {
     }
 
     public void createImage(int red, int green, int blue, int height, int width) {
-        imageService.createImage(red, green, blue, height, width);
+        Image image = imageService.createImage(red, green, blue, height, width);
+        appState.setImage(image);
     }
 
-    public void loadImage(File f) throws IOException {
-        imageService.loadImage(f);
+    public void loadImage(File file) throws IOException {
+        Image image = imageService.loadImage(file);
+        appState.setImage(image);
     }
 
-    public void goToFourier(){
+    public void goToFourier() {
         navigator.showFourier();
     }
 
-    public void goToFiltering(){
+    public void goToFiltering() {
         navigator.showFiltering();
     }
 
     public GrayScaleMatrix getImageGrayMatrix() {
-        //return ((CImageNG)appState.getImage()).getMatrice();
-        return imageService.getImage().toGrayScale();
+        return appState.getImage().toGrayScale();
     }
 
     public void setMode(Mode mode) {
         modeService.setMode(mode);
     }
-}
+}

src/main/java/presenters/doubleMatrix/DoubleMatrixListener.java

@@ -0,0 +1,12 @@
+package presenters.doubleMatrix;
+
+import domain.image.GrayScaleMatrix;
+import domain.image.processing.complex.ComplexMatrix;
+
+public interface DoubleMatrixListener {
+    void onFourierChanged(ComplexMatrix fourier);
+    void onModuleChanged(GrayScaleMatrix matrix);
+    void onPhaseChanged(GrayScaleMatrix matrix);
+    void onRealChanged(GrayScaleMatrix matrix);
+    void onImaginaryChanged(GrayScaleMatrix matrix);
+}

src/main/java/presenters/doubleMatrix/DoubleMatrixPresenter.java

@@ -1,5 +1,6 @@
-package presenters;
+package presenters.doubleMatrix;
 
+import app.state.AppState;
 import app.state.DoubleMatrixState;
 import com.google.common.eventbus.Subscribe;
 import com.google.inject.Inject;
@@ -18,25 +19,26 @@ import java.io.IOException;
 /**
  * @author Laurent Crema
  */
-public class DoubleMatrixPresenter {
-
+public class DoubleMatrixPresenter implements DoubleMatrixListener {
     private IDoubleMatrix view;
+    private final AppState appState;
     private final DoubleMatrixState state;
     private final ImageService imageService;
 
     @Inject
-    public DoubleMatrixPresenter(ImageService imageService, DoubleMatrixState state) {
+    public DoubleMatrixPresenter(AppState appState, ImageService imageService, DoubleMatrixState state) {
+        this.appState = appState;
         this.imageService = imageService;
         this.state = state;
-        this.state.register(this);
+        this.state.subscribe(this);
     }
 
-    public void setView(IDoubleMatrix view){
+    public void setView(IDoubleMatrix view) {
         this.view = view;
     }
 
     public void saveImage(Image image) throws IOException {
-        this.imageService.saveImage(image);
+        imageService.saveImage(image);
     }
 
     public void loadModule(){
@@ -87,28 +89,32 @@ public class DoubleMatrixPresenter {
         state.setImaginary(matrix);
     }
 
-    @Subscribe
-    public void onModuleUpdate(ModuleChangedEvent event) {
+    @Override
+    public void onModuleChanged(GrayScaleMatrix matrix) {
         GrayScaleMatrix module = new GrayScaleMatrix(getFourier().getModule());
-        view.updateModule(module, event.matrix());
+        view.updateModule(module, matrix);
     }
 
-    @Subscribe
-    public void onPhaseUpdate(PhaseChangedEvent event) {
+    @Override
+    public void onPhaseChanged(GrayScaleMatrix matrix) {
         GrayScaleMatrix phase = new GrayScaleMatrix(getFourier().getPhase());
-        view.updatePhase(phase, event.matrix());
+        view.updatePhase(phase, matrix);
     }
 
-    @Subscribe
-    public void onRealUpdate(RealChangedEvent event) {
+    @Override
+    public void onRealChanged(GrayScaleMatrix matrix) {
         GrayScaleMatrix real = new GrayScaleMatrix(getFourier().getPartieReelle());
-        view.updateReal(real, event.matrix());
+        view.updateReal(real, matrix);
     }
 
-    @Subscribe
-    public void onImaginaryUpdate(ImaginaryChangedEvent event) {
+    @Override
+    public void onFourierChanged(ComplexMatrix fourier) {
+    }
+
+    @Override
+    public void onImaginaryChanged(GrayScaleMatrix matrix) {
         GrayScaleMatrix imaginary = new GrayScaleMatrix(getFourier().getPartieImaginaire());
-        view.updateImaginary(imaginary, event.matrix());
+        view.updateImaginary(imaginary, matrix);
     }
 
     private GrayScaleMatrix clip(GrayScaleMatrix matrix, double black, double white){
@@ -119,7 +125,7 @@ public class DoubleMatrixPresenter {
 
     private ComplexMatrix getFourier() {
         if (state.getFourier() == null) {
-            state.setFourier(imageService.computeFourier());
+            state.setFourier(imageService.computeFourier(appState.getImage()));
         }
         return state.getFourier();
     }

src/main/java/presenters/filtering/FilteringListener.java

@@ -0,0 +1,11 @@
+package presenters.filtering;
+
+import domain.events.listeners.Listener;
+import domain.image.Image;
+
+public interface FilteringListener extends Listener {
+    void onLowPassChanged(Image image);
+    void onHighPassChanged(Image image);
+    void onButterworthLowPassChanged(Image image);
+    void onButterworthHighPassChanged(Image image);
+}

src/main/java/presenters/filtering/FilteringPresenter.java

@@ -0,0 +1,79 @@
+package presenters.filtering;
+
+import app.state.AppState;
+import app.state.FilteringState;
+import com.google.inject.Inject;
+import domain.image.GrayScaleMatrix;
+import domain.image.Image;
+import services.FilteringService;
+import services.ImageService;
+import ui.abstractions.IFilteringView;
+
+public class FilteringPresenter implements FilteringListener {
+    private final AppState appState;
+    private final FilteringState state;
+    private final ImageService imageService;
+    private final FilteringService filteringService;
+    private IFilteringView view;
+
+    @Inject
+    public FilteringPresenter(AppState appState, FilteringState state, ImageService imageService, FilteringService filteringService) {
+        this.appState = appState;
+        this.state = state;
+        this.imageService = imageService;
+        this.filteringService = filteringService;
+        this.state.subscribe(this);
+    }
+
+    public void setView(IFilteringView view) {
+        this.view = view;
+    }
+
+    public void computeLowPassFiltering(float percentage) {
+        GrayScaleMatrix matrix = imageService.getGrayScale(appState.getImage());
+        Image image = filteringService.lowPassFiltering(matrix, percentage / 100);
+        state.setLowPass(image);
+    }
+
+    public void computeHighPassFiltering(float percentage) {
+        GrayScaleMatrix matrix = imageService.getGrayScale(appState.getImage());
+        Image image = filteringService.highPassFiltering(matrix, percentage / 100);
+        state.setHighPass(image);
+    }
+
+    public void computeButterworthLowPassFiltering(float percentage) {
+        GrayScaleMatrix matrix = imageService.getGrayScale(appState.getImage());
+        Image image = filteringService.butterworthLowPassFiltering(matrix, percentage / 100);
+        state.setButterworthLowPass(image);
+    }
+
+    public void computeButterworthHighPassFiltering(float percentage) {
+        GrayScaleMatrix matrix = imageService.getGrayScale(appState.getImage());
+        Image image = filteringService.butterworthHighPassFiltering(matrix, percentage / 100);
+        state.setButterworthHighPass(image);
+    }
+
+    @Override
+    public void onLowPassChanged(Image image) {
+        view.updateLowPassFiltering(image);
+    }
+
+    @Override
+    public void onHighPassChanged(Image image) {
+        view.updateHighPassFiltering(image);
+    }
+
+    @Override
+    public void onButterworthLowPassChanged(Image image) {
+        view.updateButterworthLowPassFiltering(image);
+    }
+
+    @Override
+    public void onButterworthHighPassChanged(Image image) {
+        view.updateButterworthHighPassFiltering(image);
+    }
+
+    public void dispose() {
+        state.unsubscribe(this);
+    }
+}