add: new functions, gui

Author: electricalgorithm

README.md

@@ -1,15 +1,24 @@
 # vectofil+
-A program to perform Basic Vector Directional Filtering for the noisy color images. This a project of Computer Vision and Image Processing course in West Pomeranian University of Technology.
+A program to perform Basic Vector Directional Filtering for the noisy colour images. This a project of Computer Vision and Image Processing course in West Pomeranian University of Technology.
 
-For the demostration, check out Results directory, or [see the GUI on YouTube](https://www.youtube.com/watch?v=pXBCrB0VlLY).
+For the demonstration, check out Results directory, or [see the GUI on YouTube](https://www.youtube.com/watch?v=pXBCrB0VlLY).
 
 ### What we will add?
-- Save the output functionality.
-- Save the process as a PDF and PNGs functionality
-- Choosing the Vector Median Filtering or Basic Vector Directional Filtering process. Comperasion between two filters.
-- Percentage addition between VMF and BVDF.
-- Much more pretty UI!
-- Documentation for every function. Especially lots of comments on the file of BVDF_FILTER.
+
+- [ ] Save the output functionality.
+
+- [ ] Save the process as a PDF and PNGs functionality.
+
+- [x] Choosing the Vector Median Filtering or Basic Vector Directional Filtering process. Comperasion between two filters.
+
+- [x] Percentage addition between VMF and BVDF.
+
+- [x] Much more pretty UI!
+
+- [ ] Documentation for every function. Especially lots of comments on the file of BVDF_FILTER.
 
 ### License
 This is a art of open source. Please make sure that you also create an open source for the public good.
+
+License: GNU v2
+

results/Lenna-60Noise-3x3-BVDF-VMF-DDF-alsoDiff.fig

@@ -1,5 +1,5 @@
-function bvdf_plot_vectors(vectors, origin, ColorScheme)
-% BVDF_PLOT_VECTORS The function plots the 3D vectors in space.
+function 3DVectorPlot(vectors, origin, ColorScheme)
+% 3DVectorPlot The function plots the 3D vectors in space.
 % Only and first parameter is the matrix which every column is a vector.
 
     % Control if the optional arguments are given.
@@ -34,4 +34,4 @@ function bvdf_plot_vectors(vectors, origin, ColorScheme)
     end
 
     hold off;
-end
+end

results/Lenna-60Noise-3x3-BVDF-VMF-DDF-alsoDiff.pdf

@@ -1,4 +1,4 @@
-function noisy_img = bvdf_add_noise(image, perc, channel_size, assigned)
+function noisy_img = AddPseudoNoise(image, perc, channel_size, assigned)
     noisy_img = image;
 
     % Travel throught every pixel.
@@ -27,4 +27,4 @@
             end
         end
     end
-end
+end

results/Lenna-VMF-BVDF-60.pdf

@@ -1,4 +1,4 @@
-function filtered_image = bvdf_filter(image, sample_dims)
+function filtered_image = BasicVectorDirectionalFilter(image, sample_dims)
 % BVDF_FILTER Function to filter the image according the BVDF rule.
     if nargin < 2
         error("You have to give the image as uint8 matrix, and dimensions of the vectoral process.");
@@ -21,7 +21,7 @@
             area2filter = im2double(area2filter).*255;
 
             vectors_list = reshape(area2filter , [], 3)';
-            sorted_vectors = bvdf_sort_vectors(vectors_list);
+            sorted_vectors = SortVectorsbyAngle(vectors_list);
             filtered_image(x_index, y_index, :) = sorted_vectors(:, 1);
         end
     end

src/API/bvdf_plot_vectors.m renamed to src/API/3DVectorPlot.m

@@ -0,0 +1,25 @@
+% COLORIMAGEDIFFERENCE
+
+function [resultedImage, differentPixelCount] = ColorImageDifference(image1, image2)
+    sizeImg1 = size(image1);
+    sizeImg2 = size(image2);
+    differentPixelCount = 0;
+    
+    if (sizeImg1 - sizeImg2) ~= zeros(1, 3)
+        error("Given input images' sizes are not matched.");
+    end
+    
+    resultedImage = zeros(sizeImg1);
+    
+    for rowPixel = 1:sizeImg1(1)
+        for colPixel = 1:sizeImg1(2)
+            if min(...
+                image1(rowPixel, colPixel, :) == image2(rowPixel, colPixel, :)...
+                ) == 0
+                
+                resultedImage(rowPixel, colPixel, :) = [255, 255, 255]';
+                differentPixelCount = differentPixelCount + 1;
+            end
+        end
+    end
+end

src/API/bvdf_add_noise.m renamed to src/API/AddPseudoNoise.m

@@ -0,0 +1,73 @@
+function filtered_image = DistanceDirectionalFilter(corrupted_image, window_size, BVDFratio, yValueVMF)
+    image_X = size(corrupted_image, 1);
+    image_Y = size(corrupted_image, 2);
+
+    filtered_image = zeros(size(corrupted_image));
+    starting_points = [ceil(window_size/2), ceil(window_size/2)];
+    choosing_distance = [floor(window_size/2), floor(window_size/2)];
+    
+    for x_index = starting_points(1):(image_X-starting_points(1))
+        for y_index = starting_points(2):(image_Y-starting_points(2))
+            
+            area2filter = corrupted_image(x_index-choosing_distance(1):x_index+choosing_distance(2),...
+                                y_index-choosing_distance(2):y_index+choosing_distance(2), :);                
+            area2filter = im2double(area2filter).*255;
+            vectors_list = reshape(area2filter , [], 3)';
+            
+            % Sorting Process
+            % In here, one array of vectors is created. First row will give
+            % us the distances calculated with VMF, second row will give us
+            % the angles calculated with BVDF. That's why there is "+2".
+            calculations = zeros(size(vectors_list, 1) + 3, size(vectors_list, 2));
+            calculations(4:end, :) = vectors_list;
+            
+            for index = 1:size(vectors_list, 2)
+                for jndex = 1:size(vectors_list, 2)
+                    
+                    % For each pixel, we are choosing the window-size of
+                    % pixels, and calculate the angles and distances from
+                    % them.
+
+                    vectA = vectors_list(:, index);
+                    vectB = vectors_list(:, jndex);
+
+                    if vectA == vectB
+                        continue;
+                    end
+                    
+                    % BVDF method for window-sized vectors.
+                    calculations(3, index) = calculations(2, index) + ...
+                        acosd(dot(vectA, vectB) / (norm(vectA) * norm(vectB)));
+                    
+                    % VMF method for window-sized vectors with Euclodien distances.
+                    colorRed = (vectA(1) - vectB(1)).^(yValueVMF);
+                    colorGreen = (vectA(2) - vectB(2)).^(yValueVMF);
+                    colorBlue = (vectA(3) - vectB(3)).^(yValueVMF);
+                    VMF_distance = (colorRed + colorGreen + colorBlue).^(1/yValueVMF);
+                    calculations(2, index) = calculations(2, index) + VMF_distance;
+                    
+                end
+            end
+            
+            % Combination of VMF and BVDF: Distance Directional Filter
+            calculations(1, :) = (calculations(3, :).^(BVDFratio)) .* (calculations(2, :).^(1-BVDFratio));
+            
+            % Sorting the vectors inside the window, with the rules of BVDF
+            % and VMF.
+            % [~, VMForder] = sort(calculations(2, :));
+            % [~, BVDForder] = sort(calculations(3, :));
+            % VMFSortedVects = calculations(3:end, VMForder);
+            % BVDFSortedVects = calculations(3:end, BVDForder);
+            % VMF_Vector = VMFSortedVects(:, 1);
+            % BVDF_Vector = BVDFSortedVects(:, 1);
+            [~, DDForder] = sort(calculations(1, :));
+            DDFSortedVects = calculations(4:end, DDForder);
+            DDF_Vector = DDFSortedVects(:, 1);
+            
+            filtered_image(x_index, y_index, :) = DDF_Vector;
+            
+        end
+    end
+    
+    filtered_image = cast(filtered_image, 'uint8');
+end