From: Greg Burri Date: Mon, 23 Nov 2015 10:33:25 +0000 (+0100) Subject: Add some tests on different variations of Hough algorithm. X-Git-Tag: 1.0.11~87 X-Git-Url: http://git.euphorik.ch/?a=commitdiff_plain;h=0ff8fb82457bd5a858b2218ab07f69c81323537e;p=master-thesis.git Add some tests on different variations of Hough algorithm. --- diff --git a/Documentation/ma_autocount/plasmodium-autocount-0.1.py b/Documentation/ma_autocount/plasmodium-autocount-0.1.py index b2fa3d2..d97e059 100644 --- a/Documentation/ma_autocount/plasmodium-autocount-0.1.py +++ b/Documentation/ma_autocount/plasmodium-autocount-0.1.py @@ -1,3 +1,4 @@ +# -*- coding: utf-8 -*- #!/usr/bin/env python # Copyright (C) 2010 Monash University @@ -23,7 +24,6 @@ Identify red blood cells and red blood cells infected with plasmodium in a set o """ from PIL import Image - import sys, numpy, os, random from scipy import ndimage @@ -58,20 +58,32 @@ N_processors = 1 # # What to show in diagnostic output images -Show_edges = False +Show_edges = True Show_stain = False Show_infection = False -Show_hand_marks = True +Show_hand_marks = False Show_computer_marks = True -Show_cell_shapes = False +Show_cell_shapes = True # ================= # Image scaling -Resize_width = 680 -Resize_height = 512 +Resize = False + +# Tailles pour les images dans '08.10.2015' +Resize_width = 1296 #680 +Resize_height = 972 #512 + +# Tailles pour les images dans '22.05.2015' (50%) +#Resize_width = 1296 +#Resize_height = 972 + + +# [GB] Hemato +# Resize_width = 2864 +# Resize_height = 2885 # ========================================== @@ -109,7 +121,7 @@ Infection_pixels_required = 1 # Size of cells, for Hough transform Hough_min_radius = 5 -Hough_max_radius = 20 +Hough_max_radius = 32 # 20 # Portion of cell used for classification as infected/weird # (may be abutting an infected cell, so be cautious) @@ -117,7 +129,7 @@ Hough_max_radius = 20 Cell_inside_radius = 0.9 # Do not allow another cell center to be detected within this radius -Cell_suppression_radius = 1.25 +Cell_suppression_radius = 1.05 # 1.25 # ======================= @@ -127,17 +139,13 @@ Cell_suppression_radius = 1.25 Max_dark_stain_proportion = 0.728 # Minimum/maximum radius (as determined by Hough transform) -Min_cell_radius = 9 -Max_cell_radius = 20 +Min_cell_radius = 11 # 9 +Max_cell_radius = 32 # 20 # Proportion of radius that center of mass can be away from Hough determined center Max_offcenter = 0.5 - - - - _offset_cache = { } def offsets(inner_radius, outer_radius): """ @@ -244,14 +252,14 @@ def process(filename_in, filename_out, filename_coords, name): print 'Processing', filename_in, '->', filename_out # Resize (mostly done for speed increase) - i = i.resize((Resize_width,Resize_height), Image.ANTIALIAS) + i = i.resize((Resize_width,Resize_height), Image.ANTIALIAS) if Resize else i # Convert to numpy array - a = numpy.asarray(i).astype('float64') + a = numpy.asarray(i).astype('float64') # [GB] Shape: (512, 680, 3) height = a.shape[0] width = a.shape[1] - a_gray = numpy.sum(a, 2) + a_gray = numpy.sum(a, 2) # [GB] Somme de chaque composante RGB (non-normalisé) # Make a copy of the array to doodle various diagnostic markings on a_output = a.copy() @@ -262,33 +270,39 @@ def process(filename_in, filename_out, filename_coords, name): # Denoise/unsharp mask - a_enhanced = gaussian_blur(a, Enhance_a) - Enhance_b*gaussian_blur(a,Enhance_c) - + # [GB] (Concerne les trois channels RGB). + a_enhanced = gaussian_blur(a, Enhance_a) - Enhance_b * gaussian_blur(a, Enhance_c) # Split into foreground and background using k-medians status('fg/bg') + # [GB] Chaque canal de couleur est linéarisé dans un tableau. a_raveled = numpy.reshape(a_enhanced,(width*height,a_enhanced.shape[2])) - average = numpy.average(a_raveled, axis=0) - # Initial guess - color_bg = average*1.5 - color_fg = average*0.5 + # [GB] Moyenne de chaque canal. + average = numpy.average(a_raveled, axis=0) + + # Initial guess of the medians + color_bg = average * 1.5 # [GB] Plus clair + color_fg = average * 0.5 # [GB] Plus sombre + + # Fifty times: (0 to 4). for i in xrange(5): - d_bg = a_raveled-color_bg[None,:] + d_bg = a_raveled - color_bg[None,:] d_bg *= d_bg - d_bg = numpy.sum(d_bg,1) - d_fg = a_raveled-color_fg[None,:] + d_bg = numpy.sum(d_bg, 1) # [GB] Somme des carrés des couleurs + d_fg = a_raveled - color_fg[None,:] d_fg *= d_fg - d_fg = numpy.sum(d_fg,1) - fg = d_fg*Background_weight < d_bg - color_fg = numpy.median(a_raveled[fg,:],axis=0) + d_fg = numpy.sum(d_fg, 1) + fg = d_fg * Background_weight < d_bg + color_fg = numpy.median(a_raveled[fg,:],axis=0) # [GB] axis = 0 -> par colonne (ordonnées). Le résultat est alors 3 valeurs, une pour chaque couleur color_bg = numpy.median(a_raveled[~fg,:],axis=0) - - fg = numpy.reshape(fg, (height,width)) + + fg = numpy.reshape(fg, (height,width)) # [GB] Image binaire du premier plan. - edge = ndimage.maximum_filter(fg,size=3) != ndimage.minimum_filter(fg,size=3) + edge = ndimage.maximum_filter(fg,size=3) != ndimage.minimum_filter(fg,size=3) # [GB] image binaire des contours du premier plan. + # [GB] délinéarisation des tableaux résultant du k-median (niveau de gris). d_fg = numpy.sqrt(numpy.reshape(d_fg, (height,width))) d_bg = numpy.sqrt(numpy.reshape(d_bg, (height,width))) @@ -298,10 +312,15 @@ def process(filename_in, filename_out, filename_coords, name): # (should be invariant under changes in brightness) mag_bg = numpy.average(color_bg) + # [GB] Les "dark stain" : + # * sont d'une intensité plus élevée que la moyenne du bg multiplié par un facteur (Dark_stain_level) + # * les valeurs rouges sont plus petites que la mediane du premier-plan pour les rouges + # * les valeurs vertes sont plus petites que la médiane du premier-plan pour les verts + # * appartiennent au foreground dark_stain = ( (d_fg > mag_bg*Dark_stain_level) & - (a_enhanced[:,:,0] < color_fg[0]) & - (a_enhanced[:,:,1] < color_fg[1]) & + (a_enhanced[:,:,0] < color_fg[0]) & # [GB] Red channel + (a_enhanced[:,:,1] < color_fg[1]) & # [GB] Green channel fg ) @@ -332,6 +351,8 @@ def process(filename_in, filename_out, filename_coords, name): if Show_infection: a_output[infection,0] += 128 + #a_output[stain, 1] += 128 + # Hough transform status('hough') @@ -409,9 +430,11 @@ def process(filename_in, filename_out, filename_coords, name): candidates = [ ] for y in xrange(height): for x in xrange(width): - if hough[y,x] > thresh: - candidates.append((hough[y,x],y,x)) - candidates.sort(reverse=True) + if hough[y, x] > thresh: + candidates.append((hough[y,x], y, x)) + candidates.sort(reverse = True) + hough + status('classify') @@ -420,21 +443,20 @@ def process(filename_in, filename_out, filename_coords, name): suppress = numpy.zeros((height,width), 'bool') claim_strength = numpy.zeros((height,width), 'float64') + 1e30 - cells = [ ] # [(y,x)] + cells = [] # [(y,x)] n = 0 n_infected = 0 - n_late = 0 for _,y,x in candidates: radius = hough_radius[y,x] - + # Make sure candidate is not near a previously detected cell, # and does not abut the edge of the image if not suppress[y,x] and \ y >= radius and x >= radius and y < height-radius and x < width-radius: - coords = clipped_coordinates(0,radius*Cell_inside_radius, y,x,height,width) + coords = clipped_coordinates(0, radius * Cell_inside_radius, y, x, height, width) #Only include foreground - this_fg = fg[coords[:,0],coords[:,1]] + this_fg = fg[coords[:,0], coords[:,1]] # [GB] Booleans coords = coords[this_fg] this_strength = ((coords[:,0]-y)**2 + (coords[:,1]-x)**2) @@ -443,13 +465,12 @@ def process(filename_in, filename_out, filename_coords, name): this_strength ) - cells.append((y,x, coords,this_strength)) + cells.append((y, x, coords, this_strength)) - + # Suppress detection of cells too close to here - # (note: we do this irrespective of whether we treated this location as a hit) - - coords = clipped_coordinates(0,radius*Cell_suppression_radius, y,x,height,width) + # (note: we do this irrespective of whether we treated this location as a hit) + coords = clipped_coordinates(0,radius * Cell_suppression_radius, y,x,height,width) suppress[coords[:,0],coords[:,1]] = True #for oy, ox in offsets(0, radius*Cell_suppression_radius): #suppression_offsets: @@ -525,17 +546,18 @@ def process(filename_in, filename_out, filename_coords, name): color = (0,0,255) file_coords.write('%d,%d,Uninfected\n' % (x,y)) + if Show_cell_shapes: + a_output[coords[:,0],coords[:,1]] += [[ random.random()*64+32 for i in (0,1,2) ]] + # Mark detected cell on output image if Show_computer_marks: - set(a_output,y,x,color) + set(a_output, y, x, color) for i in xrange(1,3): set(a_output,y-i,x,color) set(a_output,y+i,x,color) set(a_output,y,x-i,color) set(a_output,y,x+i,color) - if Show_cell_shapes: - a_output[coords[:,0],coords[:,1]] += [[ random.random()*64+32 for i in (0,1,2) ]] diff --git a/src/Tests_hough/HTCircle.m b/src/Tests_hough/HTCircle.m new file mode 100644 index 0000000..3088c24 --- /dev/null +++ b/src/Tests_hough/HTCircle.m @@ -0,0 +1,42 @@ +% Hough Transform for circles. +% img : logical image, zeros are the circles edges +% radius_range is a vector : [min, max] +function [acc_votes, acc_radius] = HTCircle(img, radius_range) + + [rows, columns] = size(img); + + acc_votes = zeros(rows, columns); + acc_radius = zeros(rows, columns); + + phi_range = linspace(0, 2 * pi, 100); + phi_range(end) = []; + + indexes_non_zero = find(img)'; + s = size(img); + + for r = radius_range(1):radius_range(2) + acc = zeros(rows, columns); + for i = indexes_non_zero + [y, x] = ind2sub(s, i); + for phi = phi_range + x0 = round(x - r * cos(phi)); + y0 = round(y - r * sin(phi)); + if x0 < columns && x0 > 0 && y0 < rows && y0 > 0 + acc(y0, x0) = acc(y0, x0) + 1; + end + end + end + + for x = 1:columns + for y = 1:rows + if acc(y, x) > acc_votes(y, x) + acc_votes(y, x) = acc(y, x); + acc_radius(y, x) = r; + end + end + end + end + + acc_votes = imgaussfilt(acc_votes, 1.0); +end + diff --git a/src/Tests_hough/HTCircleGradient.m b/src/Tests_hough/HTCircleGradient.m new file mode 100644 index 0000000..fe20e20 --- /dev/null +++ b/src/Tests_hough/HTCircleGradient.m @@ -0,0 +1,42 @@ +% Hough Transform for circles with gradient. +% img : gradient image +% radius_range is a vector : [min, max] +function [acc_votes, acc_radius] = HTCircleGradient(img, radius_range) + + [rows, columns] = size(img); + + acc_votes = zeros(rows, columns); + acc_radius = zeros(rows, columns); + + phi_range = linspace(0, 2 * pi, 100); + phi_range(end) = []; + + indexes_non_zero = find(img)'; + s = size(img); + + for r = radius_range(1):radius_range(2) + acc = zeros(rows, columns); + for i = indexes_non_zero + [y, x] = ind2sub(s, i); + for phi = phi_range + x0 = round(x - r * cos(phi)); + y0 = round(y - r * sin(phi)); + if x0 < columns && x0 > 0 && y0 < rows && y0 > 0 + acc(y0, x0) = acc(y0, x0) + img(y, x); + end + end + end + + for x = 1:columns + for y = 1:rows + if acc(y, x) > acc_votes(y, x) + acc_votes(y, x) = acc(y, x); + acc_radius(y, x) = r; + end + end + end + end + + acc_votes = imgaussfilt(acc_votes, 1.0); +end + diff --git a/src/Tests_hough/HTCircleMa.m b/src/Tests_hough/HTCircleMa.m new file mode 100644 index 0000000..3afa97f --- /dev/null +++ b/src/Tests_hough/HTCircleMa.m @@ -0,0 +1,41 @@ +% Hough Transform for circles. +% x_dir : the x component of the normalized gradient +% y_dir : the y component of the normalized gradient +% edges : a binary image with edge = 1 +% radius_range is a vector : [min, max] +function [acc_votes, acc_radius] = HTCircleMa(x_dir, y_dir, edges, radius_range) + + [rows, columns] = size(edges); + + acc_votes = zeros(rows, columns); + acc_radius = zeros(rows, columns); + + indexes_edges = find(edges)'; + s = size(edges); + + for r = radius_range(1):radius_range(2) + acc = zeros(rows, columns); + for i = indexes_edges + [y, x] = ind2sub(s, i); + + x0 = round(x + x_dir(i) * r); + y0 = round(y + y_dir(i) * r); + + if x0 < columns && x0 > 0 && y0 < rows && y0 > 0 + acc(y0, x0) = acc(y0, x0) + 1; + end + end + + for x = 1:columns + for y = 1:rows + if acc(y, x) > acc_votes(y, x) + acc_votes(y, x) = acc(y, x); + acc_radius(y, x) = r; + end + end + end + end + + acc_votes = imgaussfilt(acc_votes, 1.0); +end + diff --git a/src/Tests_hough/HTEllipse.m b/src/Tests_hough/HTEllipse.m new file mode 100644 index 0000000..908f230 --- /dev/null +++ b/src/Tests_hough/HTEllipse.m @@ -0,0 +1,56 @@ +% Hough Transform for circles. +% img : logical image, zeros are the circles edges +% radius_range is a vector : [min, max] +function [acc_votes, acc_radius1, acc_radius2, acc_alpha] = HTEllipse(img, radius_range) + + [rows, columns] = size(img); + + acc_votes = zeros(rows, columns); + acc_radius1 = zeros(rows, columns); + acc_radius2 = zeros(rows, columns); + acc_alpha = zeros(rows, columns); + + alpha_range = linspace(0, pi / 2, 8); + alpha_range(end) = []; + + phi_range = linspace(0, 2 * pi, 32); + phi_range(end) = []; + + indexes_non_zero = find(img)'; + s = size(img); + + for alpha = alpha_range + transform_mat = [cos(alpha) -sin(alpha); sin(alpha) cos(alpha)]; + for r1 = radius_range(1):radius_range(2) + for r2 = radius_range(1):radius_range(2) + acc = zeros(rows, columns); + for i = indexes_non_zero + [y, x] = ind2sub(s, i); + for phi = phi_range + p0 = [x; y] - transform_mat * [r1 * cos(phi); r2 * sin(phi)]; + x0 = round(p0(1)); + y0 = round(p0(2)); + + if x0 < columns && x0 > 0 && y0 < rows && y0 > 0 + acc(y0, x0) = acc(y0, x0) + 1; + end + end + end + + for x = 1:columns + for y = 1:rows + if acc(y, x) > acc_votes(y, x) + acc_votes(y, x) = acc(y, x); + acc_radius1(y, x) = r1; + acc_radius2(y, x) = r2; + acc_alpha(y, x) = alpha; + end + end + end + end + end + end + + acc_votes = imgaussfilt(acc_votes, 1.0); +end + diff --git a/src/Tests_hough/HTEllipse2.m b/src/Tests_hough/HTEllipse2.m new file mode 100644 index 0000000..bea1243 --- /dev/null +++ b/src/Tests_hough/HTEllipse2.m @@ -0,0 +1,75 @@ +% Hough Transform for circles. +% img : logical image, zeros are the circles edges +% radius_range is a vector : [min, max] +function [acc_votes, acc_radius1, acc_radius2, acc_alpha] = HTEllipse2(x_dir, y_dir, edges, radius_range) + + [rows, columns] = size(edges); + + acc_votes = zeros(rows, columns); + acc_radius1 = zeros(rows, columns); + acc_radius2 = zeros(rows, columns); + acc_alpha = zeros(rows, columns); + + alpha_range = linspace(0, pi / 2, 8); + alpha_range(end) = []; +% alpha_range = pi/8; + + indexes_edges = find(edges)'; + s = size(edges); + + for alpha = alpha_range + rot_mat = [cos(alpha) -sin(alpha); sin(alpha) cos(alpha)]; + rot_mat_inv = [cos(-alpha) -sin(-alpha); sin(-alpha) cos(-alpha)]; + for r1 = radius_range(1):radius_range(2) + for r2 = radius_range(1):radius_range(2) + acc = zeros(rows, columns); + for i = indexes_edges + [y, x] = ind2sub(s, i); + v = [-x_dir(i); -y_dir(i)]; + u = rot_mat_inv * v; + if u(1) == 0 + if u(2) > 0 + theta = pi / 2.; + else + theta = 3. * pi / 2.; + end + elseif u(2) == 0 + if u(1) > 0 + theta = 0; + else + theta = pi; + end + elseif u(2) < 0 + t = u(2) / u(1); + theta = 2*pi + 2 * atan(... + (-r1 - r2*t*sqrt((r1^2+r2^2*t^2)/(r2^2*t^2)))... + /(r2*t)); + else + t = u(2) / u(1); + theta = 2 * atan(... + (-r1 + r2*t*sqrt((r1^2+r2^2*t^2)/(r2^2*t^2)))... + /(r2*t)); + end + C = round([x; y] - rot_mat * [r1*cos(theta); r2*sin(theta)]); + if C(1) < columns && C(1) > 0 && C(2) < rows && C(2) > 0 + acc(C(2),C(1)) = acc(C(2),C(1)) + 1; + end + end + + for x = 1:columns + for y = 1:rows + if acc(y, x) > acc_votes(y, x) + acc_votes(y, x) = acc(y, x); + acc_radius1(y, x) = r1; + acc_radius2(y, x) = r2; + acc_alpha(y, x) = alpha; + end + end + end + end + end + end + + acc_votes = imgaussfilt(acc_votes, 1.0); +end + diff --git a/src/Tests_hough/draw_ellipses.m b/src/Tests_hough/draw_ellipses.m new file mode 100644 index 0000000..d793f4d --- /dev/null +++ b/src/Tests_hough/draw_ellipses.m @@ -0,0 +1,44 @@ +% center : [x y] +function draw_ellipses(axe, ellipses, plot_3d, plot_center) + if ~exist('plot_3d', 'var') + plot_3d = false; + end + + if ~exist('plot_center', 'var') + plot_center = false; + end + + hold on; + + if plot_3d + z_space = [0 1]; + else + z_space = [0]; + end + + for i = 1:length(ellipses) + e = ellipses{i}; + transform_mat = [cos(e.alpha) -sin(e.alpha); sin(e.alpha) cos(e.alpha)]; + + p_previous = []; + for phi = linspace(0, 2 * pi, 36); + for z = z_space + p = [e.x0; e.y0] + transform_mat * [e.r1 * cos(phi); e.r2 * sin(phi)]; % p : [x y] + if ~isempty(p_previous) + line = plot3(axe, [p(1) p_previous(1)], [p(2) p_previous(2)], [z z], 'LineWidth', 1, 'Color', 'yellow'); + line.Color(4) = 0.5; + end + if z == 1 + line = plot3(axe, [p(1) p(1)], [p(2) p(2)], [0 1], 'LineWidth', 0.5, 'Color', 'yellow'); + line.Color(4) = 0.5; + end + end + p_previous = p; + end + + if plot_center + plot(e.x0, e.y0, 'r.', 'MarkerSize', 20); + end + end +end + diff --git a/src/Tests_hough/expand_matrix.m b/src/Tests_hough/expand_matrix.m new file mode 100644 index 0000000..b165902 --- /dev/null +++ b/src/Tests_hough/expand_matrix.m @@ -0,0 +1,4 @@ +function [m] = expand_matrix(m) + m = [m(:,1) m m(:,end)]; + m = [m(1,:); m; m(end,:)]; +end \ No newline at end of file diff --git a/src/Tests_hough/find_ellipses.m b/src/Tests_hough/find_ellipses.m new file mode 100644 index 0000000..4c5e7a0 --- /dev/null +++ b/src/Tests_hough/find_ellipses.m @@ -0,0 +1,60 @@ +function [ellipses] = find_ellipses(acc_votes, acc_radius_1, acc_radius_2, acc_alpha) + if ~exist('acc_radius_2', 'var') + acc_radius_2 = acc_radius_1; + end + + if ~exist('acc_alpha', 'var') + acc_alpha = zeros(size(acc_votes)); + end + + ellipses = {}; % struct('x0', 'y0', 'r1', 'r2', 'alpha') + max_votes = max(acc_votes(:)); + min_votes = min(acc_votes(:)); + threshold_votes = (max_votes - min_votes) * 0.7 + min_votes; + + acc_votes_suppressed = acc_votes; + while true + [votes, index_max] = max(acc_votes_suppressed(:)); + if votes <= threshold_votes + break; + end + + acc_votes_suppressed(index_max) = 0; % Suppress the vote. + + [y, x] = ind2sub(size(acc_votes_suppressed), index_max); + + % If the center ellipse isn't in a known ellipse then add it to 'ellipses'. + accept_ellipse = true; + for i = 1:length(ellipses) + ellipse = ellipses{i}; +% module = sqrt((x - ellipse.x)^2 + (y - ellipse.y)^2); +% phi = asin((y - ellipse.y) / module); +% +% p = [cos(a) -sin(a); sin(a) cos(a)] * [ellipse.r1 * cos(phi); ellipse.r2 * sin(phi)]; +% module_ellipse = sqrt(p(1)^2 + p(2)^2); + + a = ellipse.alpha; + x0 = ellipse.x0; + y0 = ellipse.y0; + r1 = ellipse.r1; + r2 = ellipse.r2; + n = ((x - x0) * cos(a) + (y - y0) * sin(a))^2 / r1^2 + ((x - x0) * sin(a) - (y - y0) * cos(a))^2 / r2^2; + if n <= 1 + accept_ellipse = false; + break; + end + end + + if accept_ellipse + e = struct(... + 'x0', x,... + 'y0', y,... + 'r1', acc_radius_1(index_max),... + 'r2', acc_radius_2(index_max),... + 'alpha', acc_alpha(index_max)); + ellipses{end+1} = e; + fprintf('Ellipse : (x0: %.1f, y0: %.1f, r1: %.1f, r2: %.1f, alpha: %.2f)\n', e.x0, e.y0, e.r1, e.r2, e.alpha); + end + end +end + diff --git a/src/Tests_hough/images/heap_1.png b/src/Tests_hough/images/heap_1.png new file mode 100644 index 0000000..beaea3c Binary files /dev/null and b/src/Tests_hough/images/heap_1.png differ diff --git a/src/Tests_hough/images/rbc_single.png b/src/Tests_hough/images/rbc_single.png new file mode 100644 index 0000000..dc9424a Binary files /dev/null and b/src/Tests_hough/images/rbc_single.png differ diff --git a/src/Tests_hough/images/rbc_single_blurred.png b/src/Tests_hough/images/rbc_single_blurred.png new file mode 100644 index 0000000..77afb77 Binary files /dev/null and b/src/Tests_hough/images/rbc_single_blurred.png differ diff --git a/src/Tests_hough/images/rbc_single_oblong_1.png b/src/Tests_hough/images/rbc_single_oblong_1.png new file mode 100644 index 0000000..549488a Binary files /dev/null and b/src/Tests_hough/images/rbc_single_oblong_1.png differ diff --git a/src/Tests_hough/images/rbc_single_oblong_2.png b/src/Tests_hough/images/rbc_single_oblong_2.png new file mode 100644 index 0000000..4fb2fb6 Binary files /dev/null and b/src/Tests_hough/images/rbc_single_oblong_2.png differ diff --git a/src/Tests_hough/images/rbc_single_oblong_3.png b/src/Tests_hough/images/rbc_single_oblong_3.png new file mode 100644 index 0000000..6e8abdb Binary files /dev/null and b/src/Tests_hough/images/rbc_single_oblong_3.png differ diff --git a/src/Tests_hough/images/two_rbc_1.png b/src/Tests_hough/images/two_rbc_1.png new file mode 100644 index 0000000..bb67d0d Binary files /dev/null and b/src/Tests_hough/images/two_rbc_1.png differ diff --git a/src/Tests_hough/images/two_rbc_2.png b/src/Tests_hough/images/two_rbc_2.png new file mode 100644 index 0000000..23f68b1 Binary files /dev/null and b/src/Tests_hough/images/two_rbc_2.png differ diff --git a/src/Tests_hough/images/two_rbc_3.png b/src/Tests_hough/images/two_rbc_3.png new file mode 100644 index 0000000..1148f53 Binary files /dev/null and b/src/Tests_hough/images/two_rbc_3.png differ diff --git a/src/Tests_hough/images/wbc_1.png b/src/Tests_hough/images/wbc_1.png new file mode 100644 index 0000000..947ad39 Binary files /dev/null and b/src/Tests_hough/images/wbc_1.png differ diff --git a/src/Tests_hough/images/wbc_2.png b/src/Tests_hough/images/wbc_2.png new file mode 100644 index 0000000..611bd3a Binary files /dev/null and b/src/Tests_hough/images/wbc_2.png differ diff --git a/src/Tests_hough/results/notes.txt b/src/Tests_hough/results/notes.txt new file mode 100644 index 0000000..e69de29 diff --git a/src/Tests_hough/show_figures.m b/src/Tests_hough/show_figures.m new file mode 100644 index 0000000..ed6de4e --- /dev/null +++ b/src/Tests_hough/show_figures.m @@ -0,0 +1,9 @@ +function [hlink] = show_figures(name, images, original, ellipses) + [hlink, axes] = show_votes_figure(name, images); + draw_ellipses(axes(4), ellipses, true); + savefig(['results/' name '.fig']); + + show_image_ellipses(name, original, ellipses); + savefig(['results/' name ' - output.fig']); +end + diff --git a/src/Tests_hough/show_image_ellipses.m b/src/Tests_hough/show_image_ellipses.m new file mode 100644 index 0000000..229d524 --- /dev/null +++ b/src/Tests_hough/show_image_ellipses.m @@ -0,0 +1,11 @@ +function show_image_ellipses(name, img, ellipses) + f = figure; + f.Position = [10 10 700 700]; + f.Name = name; + grayscale = linspace(0, 1, 255); + colormap([grayscale' grayscale' grayscale']); + image(img); + axis image; + draw_ellipses(f.CurrentAxes, ellipses, false, true); +end + diff --git a/src/Tests_hough/show_votes_figure.m b/src/Tests_hough/show_votes_figure.m new file mode 100644 index 0000000..f6856d4 --- /dev/null +++ b/src/Tests_hough/show_votes_figure.m @@ -0,0 +1,26 @@ +function [hlink, axes] = show_votes_figure(name, images) + f = figure; + f.Name = name; + f.Position = [100 100 1300 900]; + + norm = @(A) (A - min(A(:)))/(max(A(:)) - min(A(:))); + + for i = 1:size(images, 2) + axes(i) = subplot(2, 2, i); + %colormap(hsv); + surf(norm(double(images{i}{1})), 'FaceColor','interp', 'FaceLighting', 'gouraud', 'EdgeColor', 'none'); + camlight left; + shading interp; + colormap(jet(10)) + axis tight; + title(images{i}{2}); + view(axes(i), [-39.5 70]); + end + + hlink = linkprop(axes, {'CameraPosition', 'CameraUpVector'}); + + rotate3d on; +end + + + diff --git a/src/Tests_hough/test_all.m b/src/Tests_hough/test_all.m new file mode 100644 index 0000000..5348923 --- /dev/null +++ b/src/Tests_hough/test_all.m @@ -0,0 +1,38 @@ +clear; + +images_path = 'D:\Master Thesis\src\Tests_hough\images\'; +image_names = { +% 'heap_1.png' +% +% 'rbc_single.png' +% 'rbc_single_blurred.png' + +% 'rbc_single_oblong_1.png' + 'rbc_single_oblong_2.png' +% 'rbc_single_oblong_3.png' +% +% 'two_rbc_1.png' +% 'two_rbc_2.png' +% 'two_rbc_3.png' +% 'wbc_1.png' +% 'wbc_2.png' + }; + +for k = 1:length(image_names) + image_name = image_names{k}; + +% test_hough_simple(images_path, image_name); +% close all; + +% test_hough_gradient(images_path, image_name, false) +% close all; + +% test_hough_ma(images_path, image_name) +% close all; + +% test_hough_ellipses(images_path, image_name); +% close all; + + test_hough_ellipses2(images_path, image_name); +% close all; +end \ No newline at end of file diff --git a/src/Tests_hough/test_hough_ellipses.m b/src/Tests_hough/test_hough_ellipses.m new file mode 100644 index 0000000..490b67d --- /dev/null +++ b/src/Tests_hough/test_hough_ellipses.m @@ -0,0 +1,22 @@ +function test_hough_ellipses(images_path, image_name) + i = imread([images_path image_name]); + green = i(:,:,2); + green_filtered = imgaussfilt(double(green), 1.0); + edges = edge(green_filtered); + + disp('Applying Houg...'); + tic + [acc_votes, acc_radius1, acc_radius2, acc_alpha] = HTEllipse(edges, [20, 40]); + toc + + disp('Finding ellipses...'); + tic + ellipses = find_ellipses(acc_votes, acc_radius1, acc_radius2, acc_alpha); + toc + + show_figures(['Hough ellipses - ' image_name], {... + {green, 'original'},... + {green_filtered, 'original filtered with a gaussian, sigma=1'},... + {edges, 'edges (sobel)'},... + {expand_matrix(acc_votes), 'votes'}}, green, ellipses); +end \ No newline at end of file diff --git a/src/Tests_hough/test_hough_ellipses2.m b/src/Tests_hough/test_hough_ellipses2.m new file mode 100644 index 0000000..41be4a8 --- /dev/null +++ b/src/Tests_hough/test_hough_ellipses2.m @@ -0,0 +1,49 @@ +function test_hough_ellipses2(images_path, image_name) + i = imread([images_path image_name]); + + green = i(:,:,2); + green_filtered = imgaussfilt(green, 1.0); + otsu = ~im2bw(green_filtered, graythresh(green_filtered)); + + se = strel('rectangle', [3 3]); + edges = imdilate(otsu, se) - imerode(otsu, se); + + s = [-1 0 1; -2 0 2; -1 0 1]; + x_edge = conv2(double(green_filtered), s, 'valid'); + y_edge = conv2(double(green_filtered), s', 'valid'); + + magnitudes = sqrt(x_edge .^ 2 + y_edge .^ 2); + + % Unit gradient. + x_dir = x_edge ./ magnitudes; + y_dir = y_edge ./ magnitudes; + + disp('Applying Houg...'); + tic + [acc_votes, acc_radius1, acc_radius2, acc_alpha] = HTEllipse2(x_dir, y_dir, edges(2:end-1, 2:end-1), [20, 40]); + toc + + disp('Finding ellipses...'); + tic + ellipses = find_ellipses(acc_votes, acc_radius1, acc_radius2, acc_alpha); + toc + + name = ['Hough ellipses 2 - ' image_name]; + show_figures(name, {... + {green_filtered, 'original filtered with a gaussian, sigma=1'},... + {edges, 'edges (otsu -> dilate - erode)'},... + {expand_matrix(x_edge), 'composante x du gradient'},... + {expand_matrix(acc_votes), 'votes'}}, green, ellipses); + + f = figure; + img = green_filtered; + grayscale = linspace(0, 1, 255); + colormap([grayscale' grayscale' grayscale']); + img(~edges) = 0; + image(img); + axis image; + hold on; + [X, Y] = meshgrid(1:size(green, 2), 1:size(green, 1)); + quiver(X, Y, expand_matrix(x_dir), expand_matrix(y_dir), 'Color', 'yellow'); + savefig(['results/' name ' - gradient.fig']); +end \ No newline at end of file diff --git a/src/Tests_hough/test_hough_gradient.m b/src/Tests_hough/test_hough_gradient.m new file mode 100644 index 0000000..15ca92b --- /dev/null +++ b/src/Tests_hough/test_hough_gradient.m @@ -0,0 +1,45 @@ +function test_hough_gradient(images_path, image_name, use_edges_mask) + i = imread([images_path image_name]); + + green = i(:,:,2); + green_filtered = imgaussfilt(green, 1.0); + + edges = zeros(size(green)); + if use_edges_mask + otsu = ~im2bw(green_filtered, graythresh(green_filtered)); + se = strel('rectangle', [3 3]); + edges = imdilate(otsu, se) - imerode(otsu, se); + end + + s = [-1 0 1; -2 0 2; -1 0 1]; + x_edge = conv2(cast(green_filtered, 'double'), s , 'valid'); + y_edge = conv2(cast(green_filtered, 'double'), s', 'valid'); + + magnitudes = sqrt(x_edge .^ 2 + y_edge .^ 2); + + if use_edges_mask + magnitudes(~edges(2:end-1, 2:end-1)) = 0; + end + + disp('Applying Houg...'); + tic + [acc_votes, acc_radius] = HTCircleGradient(magnitudes, [25, 35]); + toc + + disp('Finding ellipses...'); + tic + ellipses = find_ellipses(acc_votes, acc_radius); + toc + + name = ['Hough gradient - ' image_name]; + if use_edges_mask + name = [name ' (with edges)']; + end + + show_figures(name, {... + {green_filtered, 'original filtered with a gaussian, sigma=1'},... + {edges, 'edges (otsu -> dilate - erode)'},... + {magnitudes, 'magnitudes'},... + {expand_matrix(acc_votes), 'votes'}}, green, ellipses); +end + diff --git a/src/Tests_hough/test_hough_ma.m b/src/Tests_hough/test_hough_ma.m new file mode 100644 index 0000000..690d3b2 --- /dev/null +++ b/src/Tests_hough/test_hough_ma.m @@ -0,0 +1,49 @@ +function test_hough_ma(images_path, image_name) + i = imread([images_path image_name]); + + green = i(:,:,2); + green_filtered = imgaussfilt(green, 1.0); + otsu = ~im2bw(green_filtered, graythresh(green_filtered)); + + se = strel('rectangle', [3 3]); + edges = imdilate(otsu, se) - imerode(otsu, se); + + s = [-1 0 1; -2 0 2; -1 0 1]; + x_edge = conv2(double(green_filtered), s, 'valid'); + y_edge = conv2(double(green_filtered), s', 'valid'); + + magnitudes = sqrt(x_edge .^ 2 + y_edge .^ 2); + + % Unit gradient. + x_dir = x_edge ./ magnitudes; + y_dir = y_edge ./ magnitudes; + + disp('Applying Houg...'); + tic + [acc_votes, acc_radius] = HTCircleMa(x_dir, y_dir, edges(2:end-1, 2:end-1), [25, 35]); + toc + + disp('Finding ellipses...'); + tic + ellipses = find_ellipses(acc_votes, acc_radius); + toc + + name = ['Hough Ma - ' image_name]; + show_figures(name,... + {{green_filtered, 'original filtered with a gaussian, sigma=1'},... + {edges, 'edges (otsu -> dilate - erode)'},... + {expand_matrix(x_edge), 'composante x du gradient'},... + {expand_matrix(acc_votes), 'votes'}}, green, ellipses); + + f = figure; + img = green_filtered; + grayscale = linspace(0, 1, 255); + colormap([grayscale' grayscale' grayscale']); + img(~edges) = 0; + image(img); + axis image; + hold on; + [X, Y] = meshgrid(1:size(green, 2), 1:size(green, 1)); + quiver(X, Y, expand_matrix(x_dir), expand_matrix(y_dir), 'Color', 'yellow'); + savefig(['results/' name ' - gradient.fig']); +end diff --git a/src/Tests_hough/test_hough_simple.m b/src/Tests_hough/test_hough_simple.m new file mode 100644 index 0000000..2725fc9 --- /dev/null +++ b/src/Tests_hough/test_hough_simple.m @@ -0,0 +1,22 @@ +function test_hough_simple(images_path, image_name) + i = imread([images_path image_name]); + green = i(:, :, 2); + green_filtered = imgaussfilt(cast(i(:, :, 2), 'double'), 1.0); + edges = edge(green_filtered); + + disp('Applying Houg...'); + tic + [acc_votes, acc_radius] = HTCircle(edges, [20, 40]); + toc + + disp('Finding ellipses...'); + tic + ellipses = find_ellipses(acc_votes, acc_radius); + toc + + show_figures(['Hough simple - ' image_name], {... + {green, 'original'},... + {green_filtered, 'original filtered with a gaussian, sigma=1'},... + {edges, 'edges (sobel)'},... + {acc_votes, 'votes'}}, green, ellipses); +end \ No newline at end of file