Updating photometric filters

- Updating photometric filters in android project

Author: DiegoCatalano

Catalano.Android.Image/src/Catalano/Imaging/Filters/Photometric/DifferenceOfGaussian.java

@@ -49,6 +49,8 @@
 
 import Catalano.Imaging.Filters.*;
 import Catalano.Imaging.FastBitmap;
+import Catalano.Imaging.Tools.ImageUtils;
+import Catalano.Imaging.Tools.Kernel;
 import Catalano.Math.Functions.Gaussian;
 import Catalano.Math.Matrix;
 
@@ -62,11 +64,51 @@
  */
 public class DifferenceOfGaussian implements IPhotometricFilter{
 
-    private double sigma1 = 1.4D, sigma2 = 1.4D;
-    private boolean normalize = true;
+    private double sigma1;
+    private double sigma2;
+    private double[][] gv1;
+    private double[][] gv2;
+
+    /**
+     * Get sigma 1.
+     * @return Sigma value.
+     */
+    public double getSigma1() {
+        return sigma1;
+    }
+
+    /**
+     * Set sigma 1.
+     * @param sigma1 Sigma value.
+     */
+    public void setSigma1(double sigma1) {
+        this.sigma1 = sigma1;
+        BuildKernels();
+    }
+
+    /**
+     * Get sigma 2.
+     * @return Sigma value.
+     */
+    public double getSigma2() {
+        return sigma2;
+    }
+
+    /**
+     * Set sigma 2.
+     * @param sigma2 Sigma value.
+     */
+    public void setSigma2(double sigma2) {
+        this.sigma2 = sigma2;
+        BuildKernels();
+    }
 
     /**
      * Initialize a new instance of the DifferenceOfGaussian class.
+     * <br> 
+     * <br> Default:
+     * <br> Sigma 1: 1
+     * <br> Sigma 2: 2
      */
     public DifferenceOfGaussian() {
         this(1,2);
@@ -80,18 +122,12 @@ public DifferenceOfGaussian() {
      * @param sigma2 Second sigma value.
      */
     public DifferenceOfGaussian(double sigma1, double sigma2) {
-        this(sigma1,sigma2,true);
-    }
-    
-    public DifferenceOfGaussian(double sigma1, double sigma2, boolean normalize){
         this.sigma1 = sigma1;
         this.sigma2 = sigma2;
-        this.normalize = normalize;
+        BuildKernels();
     }
-
-    @Override
-    public void applyInPlace(FastBitmap fastBitmap) {
-        
+    
+    private void BuildKernels(){
         int size1 = 2 * (int)Math.ceil(3*sigma1) + 1;
         Gaussian ga = new Gaussian(sigma1);
         double[][] g1 = ga.Kernel2D(size1);
@@ -100,9 +136,21 @@ public void applyInPlace(FastBitmap fastBitmap) {
         ga.setSigma(sigma2);
         double[][] g2 = ga.Kernel2D(size2);
 
+        //Decompose kernels
+        gv1 = Kernel.Decompose(g1);
+        gv2 = Kernel.Decompose(g2);
+    }
+
+    @Override
+    public void applyInPlace(FastBitmap fastBitmap) {
+        
         if(fastBitmap.isGrayscale()){
-            double[][] im1 = operateGray(fastBitmap, g1);
-            double[][] im2 = operateGray(fastBitmap, g2);
+            
+            double[][] image = fastBitmap.toMatrixGrayAsDouble();
+            ImageUtils.Normalize(image);
+            
+            double[][] im1 = ImageUtils.Convolution(image, gv1[0], gv1[1], true);
+            double[][] im2 = ImageUtils.Convolution(image, gv2[0], gv2[1], true);
 
             im1 = Matrix.Subtract(im1, im2);
 
@@ -121,15 +169,14 @@ public void applyInPlace(FastBitmap fastBitmap) {
                     fastBitmap.setGray(i, j, (int)Catalano.Math.Tools.Scale(min, max, 0, 255, im1[i][j]));
                 }
             }
-            
-            if(normalize){
-                HistogramAdjust ha = new HistogramAdjust();
-                ha.applyInPlace(fastBitmap);
-            }
+                
         }
         else if(fastBitmap.isRGB()){
-            double[][][] im1 = operateRGB(fastBitmap, g1);
-            double[][][] im2 = operateRGB(fastBitmap, g2);
+            
+            double[][][] image = fastBitmap.toMatrixRGBAsDouble();
+            
+            double[][][] im1 = ImageUtils.Convolution(image, gv1[0], gv1[1], true);
+            double[][][] im2 = ImageUtils.Convolution(image, gv2[0], gv2[1], true);
 
             //Subtract operation
             for (int i = 0; i < im1.length; i++) {
@@ -168,100 +215,33 @@ else if(fastBitmap.isRGB()){
                 }
             }
 
-            if(normalize){
-                HistogramAdjust ha = new HistogramAdjust();
-                ha.applyInPlace(fastBitmap);
-            }
-        }
-    }
-    
-    private double[][] operateGray(FastBitmap fastBitmap, double[][] kernel){
-        //Perform the convolution
-        int width = fastBitmap.getWidth();
-        int height = fastBitmap.getHeight();
-        double[][] response = new double[height][width];
-        
-        int Xline,Yline;
-        int lines = (kernel.length - 1)/2;
-        double gray;
-        
-        for (int x = 0; x < height; x++) {
-            for (int y = 0; y < width; y++) {
-                gray = 0;
-                for (int i = 0; i < kernel.length; i++) {
-                    Xline = x + (i-lines);
-                    for (int j = 0; j < kernel[0].length; j++) {
-                        Yline = y + (j-lines);
-                        if ((Xline >= 0) && (Xline < height) && (Yline >=0) && (Yline < width)) {
-                            gray += kernel[i][j] * fastBitmap.getGray(Xline, Yline);
-                        }
-                        else {
-
-                            int r = x + i - lines;
-                            int c = y + j - lines;
+            HistogramAdjust ha = new HistogramAdjust();
+            ha.applyInPlace(fastBitmap);
 
-                            if (r < 0) r = 0;
-                            if (r >= height) r = height - 1;
-
-                            if (c < 0) c = 0;
-                            if (c >= width) c = width - 1;
-
-                            gray += kernel[i][j] * fastBitmap.getGray(r, c);
-                        }
-                    }
-                }
-                response[x][y] = gray;
-            }
         }
-        
-        return response;
     }
 
-    private double[][][] operateRGB(FastBitmap fastBitmap, double[][] kernel){
-        //Perform the convolution
-        int width = fastBitmap.getWidth();
-        int height = fastBitmap.getHeight();
-        double[][][] response = new double[height][width][3];
+    /**
+     * Process the image as matrix.
+     * @param image Image.
+     * @param normalize True if the image needs to be normalized.
+     * @return DoG of the image.
+     */
+    public double[][] Process(double[][] image, boolean normalize){
 
-        int Xline,Yline;
-        int lines = (kernel.length - 1)/2;
-        double red,green,blue;
+        double[][] copy = Matrix.Copy(image);
 
-        for (int x = 0; x < height; x++) {
-            for (int y = 0; y < width; y++) {
-                red = green = blue = 0;
-                for (int i = 0; i < kernel.length; i++) {
-                    Xline = x + (i-lines);
-                    for (int j = 0; j < kernel[0].length; j++) {
-                        Yline = y + (j-lines);
-                        if ((Xline >= 0) && (Xline < height) && (Yline >=0) && (Yline < width)) {
-                            red += kernel[i][j] * fastBitmap.getRed(Xline, Yline);
-                            green += kernel[i][j] * fastBitmap.getGreen(Xline, Yline);
-                            blue += kernel[i][j] * fastBitmap.getBlue(Xline, Yline);
-                        }
-                        else {
-
-                            int r = x + i - lines;
-                            int c = y + j - lines;
-
-                            if (r < 0) r = 0;
-                            if (r >= height) r = height - 1;
-
-                            if (c < 0) c = 0;
-                            if (c >= width) c = width - 1;
+        ImageUtils.Normalize(copy);
+        
+        double[][] im1 = ImageUtils.Convolution(copy, gv1[0], gv1[1]);
+        double[][] im2 = ImageUtils.Convolution(copy, gv2[0], gv2[1]);
 
-                            red += kernel[i][j] * fastBitmap.getRed(r, c);
-                            green += kernel[i][j] * fastBitmap.getGreen(r, c);
-                            blue += kernel[i][j] * fastBitmap.getBlue(r, c);
-                        }
-                    }
-                }
-                response[x][y][0] = red;
-                response[x][y][1] = green;
-                response[x][y][2] = blue;
-            }
+        im1 = Matrix.Subtract(im1, im2);
+        
+        if(normalize){
+            ImageUtils.Normalize(im1);
         }
 
-        return response;
+        return im1;
     }
-}
+}

Catalano.Android.Image/src/Catalano/Imaging/Filters/Photometric/MultiscaleRetinex.java

@@ -0,0 +1,131 @@
+// Catalano Imaging Library
+// The Catalano Framework
+//
+// Copyright © Diego Catalano, 2012-2016
+// diego.catalano at live.com
+//
+// Copyright (c) 2011, Vitomir Struc
+// Copyright (c) 2009, Gabriel Peyre
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without 
+// modification, are permitted provided that the following conditions are 
+// met:
+//
+//    * Redistributions of source code must retain the above copyright 
+//      notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above copyright 
+//      notice, this list of conditions and the following disclaimer in 
+//      the documentation and/or other materials provided with the distribution
+//      
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 
+// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE 
+// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 
+// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 
+// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 
+// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 
+// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 
+// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 
+// POSSIBILITY OF SUCH DAMAGE.
+//
+//    This library is free software; you can redistribute it and/or
+//    modify it under the terms of the GNU Lesser General Public
+//    License as published by the Free Software Foundation; either
+//    version 2.1 of the License, or (at your option) any later version.
+//
+//    This library is distributed in the hope that it will be useful,
+//    but WITHOUT ANY WARRANTY; without even the implied warranty of
+//    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+//    Lesser General Public License for more details.
+//
+//    You should have received a copy of the GNU Lesser General Public
+//    License along with this library; if not, write to the Free Software
+//    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+//
+
+package Catalano.Imaging.Filters.Photometric;
+
+import Catalano.Imaging.FastBitmap;
+import Catalano.Imaging.Tools.ImageUtils;
+import Catalano.Math.Matrix;
+
+/**
+ * Multi scale retinex.
+ * @author Diego Catalano
+ */
+public class MultiscaleRetinex implements IPhotometricFilter{
+    
+    private int[] scales;
+
+    /**
+     * Get scales.
+     * @return scales.
+     */
+    public int[] getScales() {
+        return scales;
+    }
+
+    /**
+     * Set scales.
+     * @param scales scales.
+     */
+    public void setScales(int[] scales) {
+        this.scales = scales;
+    }
+
+    /**
+     * Initializes a new instance of the MultiScaleRetinex class.
+     * <br>
+     * <br> Default:
+     * <br> Scales = 7, 15, 21
+     */
+    public MultiscaleRetinex() {
+        this(new int[] {7,15,21});
+    }
+
+    /**
+     * Initializes a new instance of the MultiScaleRetinex class.
+     * @param scales Scales.
+     */
+    public MultiscaleRetinex(int[] scales) {
+        this.scales = scales;
+    }
+
+    @Override
+    public void applyInPlace(FastBitmap fastBitmap) {
+        
+        //Convert to matrix
+        double[][] image = fastBitmap.toMatrixGrayAsDouble();
+        
+        //Process the filter
+        double[][] r = Process(image,true);
+        
+        //Convert to the image.
+        fastBitmap.matrixToImage(r);
+        
+    }
+    
+    /**
+     * Process the image.
+     * @param image Image to be processed.
+     * @param normalize Normalize the image [0..255].
+     * @return Response of the filter.
+     */
+    public double[][] Process(double[][] image, boolean normalize){
+        
+        SingleScaleRetinex ssr =  new SingleScaleRetinex(scales[0]);
+        double[][] r = ssr.Process(image, normalize);
+        
+        for (int i = 1; i < scales.length; i++) {
+            ssr.setScale(scales[i]);
+            Matrix.Add(r, ssr.Process(image, normalize));
+        }
+        
+        if(normalize)
+            ImageUtils.Normalize(r);
+        
+        return r;
+    }
+}