## There is a warning that appears when loading common_functions because of one of ## the packages we import. Please ignore the warnings, or run this cell twice to ## hide the warnings using Images, DataFrames, FixedPointNumbers, PyPlot, Colors, ProgressMeter using Interact, Reactive, DataStructures using JuMP, Clp, Mosek include("common_functions.jl"); # load target images test_image_files = get_image_files("./test_images") test_images_mat = load_images_as_cellarray_mats(test_image_files) println(length(test_images_mat), " test image files loaded."); function pickOpt(sub_test_image, basis_colors, optimize_color) ## function that picks the optimal basis image for one sub-image of the same size ## inputs: sub_test_image, the sub-image we are trying to optimize, same size as the desired basis ## basis_colors, the mode/mean array of basis library depending on optimize_color ## optimize_color, logical variable choosing the mean absolute difference (F) ## or mode absolute difference (T) # get number of basis library and the number of channels we are optimizing n_basis = size(basis_colors, 1) n_colors = size(basis_colors, 2) m = Model(solver = MosekSolver()) # optimization model @variable(m, pick_basis[1:n_basis], Bin) # one binary varible for each basis image, indicating whether it is chosen @variable(m, AbsMatchError[1:n_colors] >= 0) # absolute difference @constraint(m, sum(pick_basis) == 1) # SOS constraint, only one image can be picked test_image_value = nothing if optimize_color # calculate the mode/mean value for each basis image test_image_value = [ mode(sub_test_image[:,:,color]) for color in 1:n_colors ] else test_image_value = [ mean(sub_test_image[:,:,color]) for color in 1:n_colors ] end @expression(m, MatchError[color in 1:n_colors], test_image_value[color] - sum(dot(pick_basis,basis_colors[:,color])) ) @constraint(m, MatchError .<= AbsMatchError) @constraint(m, MatchError .>= -AbsMatchError) @objective(m, Min, sum(AbsMatchError)) # minimize the absolute error status = solve(m) # show some output to communicate that things are moving forward opt_pick_basis = getvalue(pick_basis) chosen_basis = findfirst(opt_pick_basis) return chosen_basis end function pickOptHist(sub_test_image,optimize_color,n_basis,hist_basis_mat) ## function that picks the optimal basis image for one sub-image of the same size ## using the histogram similarity criterion ## inputs: sub_test_image, the sub-image we are trying to optimize, same size as the desired basis ## optimize_color, logical variable choosing the mean absolute difference (F) ## or mode absolute difference (T) ## n_basis, number of basis images in the library ## hist_basis_mat, matrix storing the precalculated histogram of images in the library # get number of basis library and the number of channels we are optimizing corr = zeros(n_basis,1) m = Model(solver = MosekSolver(LOG=1)) # optimization model @variable(m, pick_basis[1:n_basis], Bin)# one binary varible for each basis image, indicating whether it is chosen @variable(m,test_image_hist_mean>=0) # used to calculate the histogram of the test image @constraint(m, sum(pick_basis) == 1)# SOS constraint, only one image can be picked if optimize_color # calculate for RGB (nothing,test_image_hist1) = hist(vec(sub_test_image[:,:,1]),-1:255) (nothing,test_image_hist2) = hist(vec(sub_test_image[:,:,2]),-1:255) (nothing,test_image_hist3) = hist(vec(sub_test_image[:,:,3]),-1:255) test_image_hist=test_image_hist1+test_image_hist2+test_image_hist3 test_image_hist_mean=test_image_hist - mean(test_image_hist) else # calculate for the mean value (nothing,test_image_hist) = hist(vec(sub_test_image[:,:,1]),-1:255) test_image_hist_mean=test_image_hist - mean(test_image_hist) end for basis in 1:n_basis # calculate correlation of the test image with each basis corr_num=(sum(test_image_hist_mean.*hist_basis_mat[basis])) corr[basis]=sum(corr_num/((sqrt(sum(test_image_hist_mean.^2))).*sqrt(sum(hist_basis_mat[basis].^2)))); end #Check if value is NaN for basis in 1:n_basis if isequal(corr[basis],NaN) corr[basis]=0 end end @expression(m, Correlation, sum(dot(pick_basis,corr[:]))) @objective(m, Max, Correlation) # maximize correlation to get best match status = solve(m) # return the basis of choosing opt_pick_basis = getvalue(pick_basis) chosen_basis = findfirst(opt_pick_basis) return chosen_basis end test_image = test_images_mat[1] # qr code image_files = get_image_files("./grayscale") # load gray scale library base_size = 8 # choose base_size optimize_color = true # choose optimizing mean (F) or mode (T) # load data images_mat = load_images_as_cellarray_mats(image_files) println(length(images_mat), " basis image files loaded."); function brute_force(test_image, images_mat, base_size, optimize_color) ## compact function that uses the brute force mosaicking, return the assembled image ## inputs: test_image, the image we are trying to mosaic in cellarray form ## images_mat, the image library loaded in cellarray form ## base_size, number of pixels along the width of the square base ## optimize_color, logical variable, choose whether we use mean absolute difference (F) ## or mode absolute difference (T) # scale the library based on the desired size from input desired_size = (base_size, base_size) images_mat = scale_cellarray_mats(images_mat, desired_size) # get dimensions n_basis = length(images_mat) # number of basis images w_basis = size(images_mat[1], 2) # basis width h_basis = size(images_mat[1], 1) # basis height w_test_image = size(test_image, 2) # target width h_test_image = size(test_image, 1) # target height n_basis_width = div(w_test_image, w_basis) # number of basis images needed to fill target width n_basis_height = div(h_test_image, h_basis) # number of basis images needed to fill target height # prepare some arrays for storage basis_colors = nothing n_colors = nothing basis_choice = zeros(n_basis_height, n_basis_width) mosaic_image = similar(test_image) @showprogress 1 for j = 1:n_basis_height # loop over all subimages for i = 1:n_basis_width # pick out the target grid sub_test_image = test_image[ (j-1)*h_basis+(1:h_basis) , (i-1)*w_basis+(1:w_basis) , : ] if optimize_color # use mode absolute difference n_colors = 3 basis_colors = zeros(n_basis, n_colors) for color in 1:n_colors for basis in 1:n_basis basis_colors[basis,color] = mode(images_mat[basis][:,:,color]) end end else # use mean absolute difference n_colors = 1 basis_colors = zeros(n_basis, n_colors) for color in 1:n_colors for basis in 1:n_basis basis_colors[basis,color] = mean(images_mat[basis][:,:,:]) end end end # call optimization fucntion for the subimage chosen_basis = pickOpt(sub_test_image, basis_colors, optimize_color) basis_choice[j,i] = chosen_basis mosaic_image[ (j-1)*h_basis+(1:h_basis) , (i-1)*w_basis+(1:w_basis) , : ] = images_mat[chosen_basis] end end return mosaic_image end mosaic_image = brute_force(test_image, images_mat, base_size, optimize_color); println("RESULTS:") println("\t ** Test Image, Mosaic Image **") imshow([test_image mosaic_image]); test_image = test_images_mat[2]; # dog imshow(test_image); image_files = get_image_files("./music0500") # image library with ~500 album covers base_size = 8 optimize_color = true # load data images_mat = load_images_as_cellarray_mats(image_files) println(length(images_mat), " basis image files loaded.") # try mosaick the image the brute force way mosaic_image = brute_force(test_image, images_mat, base_size, optimize_color); println("RESULTS:") println("\t ** Test Image, Mosaic Image **") imshow([test_image mosaic_image]); function split_rgb(test_image, images_mat, base_size, optimize_color) ## compact function that uses the splitting rgb speed up, return the assembled image ## inputs: test_image, the image we are trying to mosaic in cellarray form ## images_mat, the image library loaded in cellarray form ## base_size, number of pixels along the width of the square base ## optimize_color, logical variable, choose whether we use mean absolute difference (F) ## or mode absolute difference (T) # scale the library based on the desired size from input desired_size = (base_size, base_size) images_mat = scale_cellarray_mats(images_mat, desired_size) # declare the 3 channels and split the scaled library into 3 channels images_r = similar(images_mat) images_g = similar(images_mat) images_b = similar(images_mat) count=split_channel(images_mat,images_r,images_g,images_b) images_r = images_r[1:count[1]] images_g = images_g[1:count[2]] images_b = images_b[1:count[3]] # get dimensions n_basis = length(images_mat) # number of basis images w_basis = size(images_mat[1], 2) # basis width h_basis = size(images_mat[1], 1) # basis height w_test_image = size(test_image, 2) # target width h_test_image = size(test_image, 1) # target height n_basis_width = div(w_test_image, w_basis) # number of basis images needed to fill target width n_basis_height = div(h_test_image, h_basis) # number of basis images needed to fill target height # prepare some arrays for storage basis_colors = nothing n_colors = nothing basis_choice = zeros(n_basis_height, n_basis_width) mosaic_image = similar(test_image) @time @showprogress 1 for j = 1:n_basis_height # loop over all sub images for i = 1:n_basis_width # pick out the target grid sub_test_image = test_image[ (j-1)*h_basis+(1:h_basis) , (i-1)*w_basis+(1:w_basis) , : ] # find the channel of the sub-image and choose the corresponding basis for optimization channel = find_channel(sub_test_image) if (channel == 1) images_base = images_r elseif (channel == 2) images_base = images_g else images_base = images_b end n_basis = size(images_base)[1] # the basis size of the specific channel if optimize_color # optimize mean absolute difference n_colors = 3 basis_colors = zeros(n_basis, n_colors) for color in 1:n_colors for basis in 1:n_basis basis_colors[basis,color] = mode(images_base[basis][:,:,color]) end end else # optimiza mode absolute difference n_colors = 1 basis_colors = zeros(n_basis, n_colors) for color in 1:n_colors for basis in 1:n_basis basis_colors[basis,color] = mean(images_base[basis][:,:,:]) end end end chosen_basis = pickOpt(sub_test_image, basis_colors, optimize_color) basis_choice[j,i] = chosen_basis mosaic_image[ (j-1)*h_basis+(1:h_basis) , (i-1)*w_basis+(1:w_basis) , : ] = copy(images_base[chosen_basis]) end end return mosaic_image end mosaic_image = split_rgb(test_image, images_mat, base_size, optimize_color); println("RESULTS:") println("\t ** Test Image, Mosaic Image **") imshow([test_image mosaic_image]); test_image = test_images_mat[2] # dog image_files = get_image_files("./music0500") base_size = 8 optimize_color = true # load data images_mat = load_images_as_cellarray_mats(image_files) println(length(images_mat), " basis image files loaded."); function histogram_optimization(test_image,images_mat,base_size,optimize_color) ## function that uses histogram matching to return the assembled image ## inputs: test_image, the image we are trying to mosaic in cellarray form ## images_mat, the image library loaded in cellarray form ## base_size, number of pixels along the width of the square base ## optimize_color, logical variable, choose whether we want to perform mosaicing on ## a color image (T) or grayscaled image (F) image_files=load_cellarray_mats_as_images(images_mat) images_gray_mat=rgb2gray(image_files) # scale the library based on the desired size from input desired_size = (base_size, base_size) images_mat = scale_cellarray_mats(images_mat, desired_size) test_image_temp = cell(1,1) test_image_temp[1] = convert_mat_to_image(test_image) test_image_gray = rgb2gray(test_image_temp)[1] # get dimensions n_basis = length(images_mat) #Number of basis images w_basis = size(images_mat[1], 2) #Basis width h_basis = size(images_mat[1], 1) #Basis height w_test_image = size(test_image, 2) #Target image's width h_test_image = size(test_image, 1) #Target image's height n_basis_width = round(Int64, w_test_image/w_basis) #Number of basis images needed to fill target width n_basis_height = round(Int64, h_test_image/h_basis) #Number of basis images needed to fill target height #Initialize required arrays basis_choice = zeros(n_basis_height, n_basis_width) mosaic_image = copy(test_image) hist_basis_mat = cell(n_basis,1) hist_basis_mat1 = cell(n_basis,1) hist_basis_mat2 = cell(n_basis,1) hist_basis_mat3 = cell(n_basis,1) test_image1=rand(Int64,size(test_image,1),size(test_image,2),size(test_image,3)) images_mat1 = cell(length(images_mat),1) test_image_gray1=rand(Int64,size(test_image_gray,1),size(test_image_gray,2),size(test_image_gray,3)) images_gray_mat1 = cell(length(images_gray_mat),1) for basis in 1:n_basis images_mat1[basis]= rand(Int64,size(images_mat[basis],1),size(images_mat[basis],2),size(images_mat[basis],3)) end for basis in 1:n_basis images_gray_mat1[basis]=rand(Int64,size(images_gray_mat[basis],1), size(images_gray_mat[basis],2), size(images_gray_mat[basis],3)) end #Convert Hexadecimal intensity values to Int values for easy computation of Histogram test_image1 = convert_image_mat_to_Int64(test_image) test_image_gray1=convert_image_mat_to_Int64(test_image_gray) for basis in 1:n_basis images_mat1[basis]=convert_image_mat_to_Int64(images_mat[basis]) images_gray_mat1[basis]=convert_image_mat_to_Int64(images_gray_mat[basis]) end @showprogress 1 for j = 1:n_basis_height #loop over all sub images for i = 1:n_basis_width if optimize_color # pick out the target grid sub_test_image = test_image1[(j-1)*h_basis+(1:h_basis),(i-1)*w_basis+(1:w_basis),:] for basis in 1:n_basis # Find histogram of Channel 1(Red) (a,hist_basis_mat1[basis]) = hist(vec(images_mat1[basis][:,:,1]),-1:255) # Find histogram of Channel 2(Green) (a,hist_basis_mat2[basis]) = hist(vec(images_mat1[basis][:,:,2]),-1:255) # Find Histogram of Channel 3(Blue) (a,hist_basis_mat3[basis]) = hist(vec(images_mat1[basis][:,:,3]),-1:255) hist_basis_mat[basis]= hist_basis_mat1[basis]+hist_basis_mat2[basis]+hist_basis_mat3[basis] hist_basis_mat[basis]=hist_basis_mat[basis]-mean(hist_basis_mat[basis]) end else # pick out the target grid sub_test_image = test_image_gray1[(j-1)*h_basis+(1:h_basis),(i-1)*w_basis+(1:w_basis),:] for basis in 1:n_basis #Find histogram of one channel (a,hist_basis_mat[basis]) = hist(vec(images_gray_mat1[basis]),-1:255) hist_basis_mat[basis]=hist_basis_mat[basis]-mean(hist_basis_mat[basis]) end end chosen_basis = pickOptHist(sub_test_image,optimize_color,n_basis,hist_basis_mat) basis_choice[j,i] = chosen_basis if optimize_color mosaic_image[ (j-1)*h_basis+(1:h_basis) , (i-1)*w_basis+(1:w_basis) , : ] = images_mat[chosen_basis] else mosaic_image[ (j-1)*h_basis+(1:h_basis) , (i-1)*w_basis+(1:w_basis),:] = images_gray_mat[chosen_basis] end end end if optimize_color return mosaic_image, test_image else return mosaic_image, test_image_gray end end optimize_color = true; mosaic_image, test_image_used = histogram_optimization(test_image, images_mat, base_size, optimize_color); println("RESULTS:") println("\t ** Test Image, Mosaic Image **") imshow([test_image_used mosaic_image]); optimize_color = false; mosaic_image, test_image_used = histogram_optimization(test_image, images_mat, base_size, optimize_color); println("RESULTS:") println("\t ** Test Image, Mosaic Image **") imshow([test_image_used mosaic_image]); test_image = test_images_mat[5] # wisconsin state capitol image_files = get_image_files("./small_set") desired_downscaling = 3 # load data images_mat = load_images_as_cellarray_mats(image_files) println(length(images_mat), " basis image files loaded."); # load data images_mat = load_images_as_cellarray_mats(image_files) println(length(images_mat), " basis image files loaded") max_downscaling_height = floor( log2(size(images_mat[1],1)) ) max_downscaling_width = floor( log2(size(images_mat[1],2)) ) downscaling = round(Int, min(desired_downscaling, max_downscaling_height, max_downscaling_width)) n_basis = length(images_mat) h_test, w_test, n_colors = size(test_image) h_basis, w_basis, n_colors = size(images_mat[1]) h_basis_smallest = div(h_basis, 2^(downscaling-1)) w_basis_smallest = div(w_basis, 2^(downscaling-1)) h_grid_test_image = div(h_test, h_basis_smallest) w_grid_test_image = div(w_test, w_basis_smallest) memory_needed = (h_grid_test_image * w_grid_test_image * (2^downscaling-1)^2 * n_colors * downscaling * n_basis * 2) / 1e9 # GB println("Memory Needed for Data Pre-processing = ", memory_needed*2, " GB") function calculate_mean_errors(test_image, images_mat, downscaling) n_basis = length(images_mat) h_test, w_test, n_colors = size(test_image) h_basis, w_basis, n_colors = size(images_mat[1]) h_basis_smallest = div(h_basis, 2^(downscaling-1)) w_basis_smallest = div(w_basis, 2^(downscaling-1)) h_grid_test_image = div(h_test, h_basis_smallest) w_grid_test_image = div(w_test, w_basis_smallest) default_error = 1000 # grid_h_, grid_w, basis_top_h, basis_left_w, n_colors, downscaling, n_basis mean_errors = cell(downscaling,1) for scale in 1:downscaling mean_errors[scale] = default_error*ones(Float16, h_grid_test_image, w_grid_test_image, 2^(downscaling-scale), 2^(downscaling-scale), n_colors, n_basis) end possible_bases_for_grid_location = cell(h_grid_test_image, w_grid_test_image) # initialize the possible_bases_for_grid_location for j in 1:h_grid_test_image for i in 1:w_grid_test_image possible_bases_for_grid_location[j, i] = [] end end # return mean_errors, possible_bases_for_grid_location for scale in 1:downscaling h_grid_basis_image = 2^(downscaling-scale) w_grid_basis_image = 2^(downscaling-scale) @showprogress for basis in 1:n_basis basis_image = downscale_image(images_mat[basis], 2^(scale-1)) for top_grid_y in 1:(h_grid_test_image-h_grid_basis_image+1) top_y = (top_grid_y-1)*h_basis_smallest + 1 bottom_y = (top_grid_y-1+h_grid_basis_image)*h_basis_smallest for left_grid_x in 1:(w_grid_test_image-w_grid_basis_image+1) left_x = (left_grid_x-1)*w_basis_smallest + 1 right_x = (left_grid_x-1+w_grid_basis_image)*w_basis_smallest sub_test_image = test_image[top_y:bottom_y, left_x:right_x, :] basis_image_error = basis_image - sub_test_image abs_basis_image_error = abs(basis_image_error) for top_subgrid_y in top_grid_y:min( (top_grid_y+h_grid_basis_image-1) , h_grid_test_image ) top_sub_y = (top_subgrid_y-top_grid_y)*h_basis_smallest + 1 bottom_sub_y = (top_subgrid_y-top_grid_y+1)*h_basis_smallest for left_subgrid_x in left_grid_x:min( (left_grid_x+w_grid_basis_image-1) , w_grid_test_image ) left_sub_x = (left_subgrid_x-left_grid_x)*w_basis_smallest + 1 right_sub_x = (left_subgrid_x-left_grid_x+1)*w_basis_smallest push!(possible_bases_for_grid_location[top_subgrid_y, left_subgrid_x], (top_subgrid_y-top_grid_y+1, left_subgrid_x-left_grid_x+1, scale, basis) ) for color in 1:n_colors mean_abs_error = mean(abs_basis_image_error[top_sub_y:bottom_sub_y, left_sub_x:right_sub_x, color]) mean_errors[scale][top_subgrid_y, left_subgrid_x, top_subgrid_y-top_grid_y+1, left_subgrid_x-left_grid_x+1, color, basis] = mean_abs_error # end of color loop end # end of left_subgrid_x loop end # end of top_subgrid_y loop end # end of left_grid_x loop end #end of top_grid_y loop end # end of basis loop end # end of scaling loop end return mean_errors, possible_bases_for_grid_location end function lp_formulation(test_image, images_mat, downscaling, λ) n_basis = length(images_mat) h_test, w_test, n_colors = size(test_image) h_basis, w_basis, n_colors = size(images_mat[1]) h_basis_smallest = div(h_basis, 2^(downscaling-1)) w_basis_smallest = div(w_basis, 2^(downscaling-1)) h_grid_test_image = div(h_test, h_basis_smallest) w_grid_test_image = div(w_test, w_basis_smallest) # do the pre-processing to get the result println("INFO: Starting pre-processing") @time mean_errors, possible_bases_for_grid_location = calculate_mean_errors(test_image, images_mat, downscaling) println("INFO: Finished pre-processing") println("INFO: Building optimization model") # declare optimization model m = Model(solver = ClpSolver()) # place_basis variable # place_basis variable tells whether a particular basis image of a particular scale # is placed such that its top-left corner corresponds to the grid element [h,w] @time @variable(m, 0 <= place_basis[1:h_grid_test_image, 1:w_grid_test_image, 1:downscaling, 1:n_basis] <= 1) # exactly one basis must correspond to any location # any given grid-element is has to be covered by EXACTLY ONE basis image @time @constraint(m, C_one_basis[h_grid in 1:h_grid_test_image, w_grid in 1:w_grid_test_image], sum{ place_basis[h_grid-h_loc+1, w_grid-w_loc+1, scale, basis], (h_loc, w_loc, scale, basis) in possible_bases_for_grid_location[h_grid, w_grid] } == 1) # mosaic error # compute the mosaic error as described before @time @expression(m, mosaic_error[h_grid in 1:h_grid_test_image, w_grid in 1:w_grid_test_image], sum{ place_basis[h_grid-h_loc+1, w_grid-w_loc+1, scale, basis] * mean( mean_errors[scale][h_grid, w_grid, h_loc, w_loc, 1:n_colors, basis] ), (h_loc, w_loc, scale, basis) in possible_bases_for_grid_location[h_grid, w_grid] }) # total mosaic error @time @expression(m, total_mosaic_error, sum(mosaic_error)) # total downscaled basis # total number of basis images that were downscaled. calculated for the tradeoff @time @expression(m, total_downscaled_bases, sum(place_basis[:, :, 2:downscaling, :]) ) # set the objective as a linear combination using the tradeoff parameter @time @objective(m, Min, total_mosaic_error + λ * total_downscaled_bases ) println("INFO: Finished building optimization model") println("INFO: Starting solver") @time status = solve(m) println("INFO: Finished solver") println("INFO: Reconstructing image") opt_place_basis = getvalue(place_basis) @time mosaic_image = construct_mosaic_image(opt_place_basis, test_image, images_mat, downscaling); println("INFO: Finished reconstructing image") return mosaic_image end # construct mosaic image from solution function construct_mosaic_image(opt_place_basis, test_image, images_mat, downscaling) n_basis = length(images_mat) h_test, w_test, n_colors = size(test_image) h_basis, w_basis, n_colors = size(images_mat[1]) h_basis_smallest = div(h_basis, 2^(downscaling-1)) w_basis_smallest = div(w_basis, 2^(downscaling-1)) h_grid_test_image = div(h_test, h_basis_smallest) w_grid_test_image = div(w_test, w_basis_smallest) opt_place_basis = round(Int8, opt_place_basis) nonzero_indices = find(opt_place_basis) chosen_bases = [ ind2sub(opt_place_basis, nonzero_indices[i]) for i in 1:length(nonzero_indices) ] mosaic_image = similar(test_image) for choice in chosen_bases h_grid_loc = choice[1] w_grid_loc = choice[2] scale = choice[3] basis = choice[4] h_grid_basis_image = 2^(downscaling-scale) w_grid_basis_image = 2^(downscaling-scale) top_y = (h_grid_loc-1)*h_basis_smallest + 1 bottom_y = (h_grid_loc-1+h_grid_basis_image)*h_basis_smallest left_x = (w_grid_loc-1)*w_basis_smallest + 1 right_x = (w_grid_loc-1+w_grid_basis_image)*w_basis_smallest basis_image = downscale_image(images_mat[basis], 2^(scale-1)) mosaic_image[top_y:bottom_y, left_x:right_x, :] = basis_image end return mosaic_image end # plot two images side by side to see how we did λ = 0 mosaic_image = lp_formulation(test_image, images_mat, downscaling, λ) println("RESULTS:"); println("\t ** Desired Image, Mosaic Image **"); imshow([test_image mosaic_image]); my_image_url = nothing using Interact, Reactive, Colors, PyPlot, DataStructures test_images_dictionary = Dict( "QR Code" => 1, "Dog" => 2, "Frog Shadow" => 3, "Iron Man" => 4, "Wisconsin State Capitol" => 5, "User Uploaded Image" => 2, ) if my_image_url != nothing try target_file_name = "./test_images/test6.jpg" download(my_image_url, target_file_name) my_image_file = load(target_file_name) my_image_mat = convert_image_to_mat(my_image_file) test_images_mat[6] = my_image_mat test_images_dictionary["User Uploaded Image"] = 6 println("Uploaded user specified image") catch x error("Unable to download user specified image") end end basis_sets_dictionary = Dict( "Grayscale" => "./grayscale", "CD Covers Set #1" => "./music0500", "CD Covers Set #2" => "./music1000", "CD Covers Set #3" => "./music1500", "Avengers" => "./avengers", ) basis_size_list = OrderedDict{AbstractString, Int}() basis_size_list["64 x 64"] = 64 basis_size_list["32 x 32"] = 32 basis_size_list["16 x 16"] = 16 basis_size_list[" 8 x 8"] = 8 basis_size_list[" 4 x 4"] = 4 method_choice_dictionary = Dict( "Brute Force Method" => 1, "RGB Split Based Method" => 2, "Histogram Method" => 3, ) test_image_signal = @manipulate for test_image_choice=test_images_dictionary test_image_choice end basis_set_signal = @manipulate for basis_set_choice=basis_sets_dictionary basis_set_choice end basis_size_signal = @manipulate for basis_size_choice=basis_size_list basis_size_choice end optimize_color_signal = @manipulate for optimize_color_choice=[true, false] optimize_color_choice end method_choice_signal = @manipulate for method_choice=method_choice_dictionary method_choice end ; # suppress output test_image = test_images_mat[ value(test_image_signal) ] image_files = get_image_files( value(basis_set_signal) ) basis_size = convert(Int64, value(basis_size_signal)) optimize_color = convert(Bool, value(optimize_color_signal) ) optimization_method = convert(Int64, value(method_choice_signal) ) images_mat = load_images_as_cellarray_mats(image_files) println(length(images_mat), " basis image files loaded") test_image_used = test_image mosaic_image = similar(test_image) if optimization_method == 1 mosaic_image = brute_force(test_image, images_mat, basis_size, optimize_color) elseif optimization_method == 2 mosaic_image = split_rgb(test_image, images_mat, basis_size, optimize_color) elseif optimization_method == 3 mosaic_image, test_image_used = histogram_optimization(test_image, images_mat, basis_size, optimize_color) end figure(1) imshow( test_image ) title("Test Image") figure(2) imshow( mosaic_image ) title("Mosaic Image") figure(3) imshow( [test_image mosaic_image] ) title("Comparison") using Interact, Reactive, Colors, PyPlot, DataStructures test_images_dictionary = Dict( "QR Code" => 1, "Dog" => 2, "Frog Shadow" => 3, "Iron Man" => 4, "Wisconsin State Capitol" => 5, "User Uploaded Image" => 2, ) if my_image_url != nothing try target_file_name = "./test_images/test6.jpg" download(my_image_url, target_file_name) my_image_file = load(target_file_name) my_image_mat = convert_image_to_mat(my_image_file) test_images_mat[6] = my_image_mat test_images_dictionary["User Uploaded Image"] = 6 println("Uploaded user specified image") catch x error("Unable to download user specified image") end end basis_sets_dictionary = Dict( "Grayscale" => "./grayscale", "CD Covers Reduced Set #1" => "./small_set", "CD Covers Reduced Set #2" => "./small_set_2", "Avengers" => "./avengers", ) desired_downscaling_list = OrderedDict{AbstractString, Int}() desired_downscaling_list["1 (No Downscaling Allowed)"] = 1 desired_downscaling_list["2 (Decrease Size by at most 1/2)"] = 2 desired_downscaling_list["3 (Decrease Size by at most 1/4)"] = 3 desired_downscaling_list["4 (Decrease Size by at most 1/8)"] = 4 desired_lambda_list = 0:5:100 test_image_signal = @manipulate for test_image_choice=test_images_dictionary test_image_choice end basis_set_signal = @manipulate for basis_set_choice=basis_sets_dictionary basis_set_choice end desired_downscaling_signal = @manipulate for desired_downscaling_choice=desired_downscaling_list desired_downscaling_choice end desired_lambda_signal = @manipulate for desired_tradeoff_choice=desired_lambda_list desired_tradeoff_choice end ; # suppress output test_image = test_images_mat[ value(test_image_signal) ] image_files = get_image_files( value(basis_set_signal) ) desired_downscaling = convert(Int64, value(desired_downscaling_signal)) λ = convert(Int64, value(desired_lambda_signal) ) images_mat = load_images_as_cellarray_mats(image_files) println(length(images_mat), " basis image files loaded") max_downscaling_height = floor( log2(size(images_mat[1],1)) ) max_downscaling_width = floor( log2(size(images_mat[1],2)) ) downscaling = round(Int, min(desired_downscaling, max_downscaling_height, max_downscaling_width)) test_image_used = test_image mosaic_image = similar(test_image) mosaic_image = lp_formulation(test_image, images_mat, downscaling, λ) figure(1) imshow( test_image ) title("Test Image") figure(2) imshow( mosaic_image ) title("Mosaic Image") figure(3) imshow( [test_image mosaic_image] ) title("Comparison")