Has all user-defined functions and algortihm functions

Author: aniket0112

CheckForEmptyBox.m

@@ -0,0 +1,10 @@
+function[count]=CheckForEmptyBox(ANSWER)
+count=0;
+for x3=1:9
+    for y3=1:9
+        if(ANSWER(x3,y3)=='0')
+            count=count+1;
+        end
+    end
+end
+end

CheckForSUDOKUconsistency.m

@@ -0,0 +1,50 @@
+function[flag]=CheckForSUDOKUconsistency(ANSWER)
+flag=0;
+for i=1:9
+    k=1;
+    l=1;
+    for j=1:9
+        if ANSWER(i,j)~='0'
+        row(1,k)=ANSWER(i,j);
+        k=k+1;
+        end
+        if ANSWER(j,i)~='0'
+        column(1,l)=ANSWER(j,i);
+        l=l+1;
+        end
+    end 
+    u_row=unique(row);
+    u_column=unique(column);
+    srow=size(row);
+    su_row=size(u_row);
+    scolumn=size(column);
+    su_column=size(u_column);
+    if ((srow(2)~=su_row(2)) || (scolumn(2)~=su_column(2)))
+    flag = 1;
+    return
+    end
+    for minimumarray=1:9
+            elements=CollectElements(minimumarray,ANSWER);
+            elements=reshape(elements,[1,9]);
+            i=1;
+            for a=1:9
+                if elements(1,a)~='0'
+                element_array(1,i)=elements(1,a);
+                i=i+1;
+                end
+            end
+            selement_array=size(element_array);
+            suelement_array=size(unique(element_array));
+            if selement_array(2)~=suelement_array(2)
+                flag=1;
+                return
+            end
+            clear elements;
+            clear element_array;
+    end
+    clear row;
+    clear column;
+    clear u_row;
+    clear u_column;
+end
+end

CollectElements.m

@@ -0,0 +1,98 @@
+function[miniarray]=CollectElements(n,OUT)
+switch n
+    case 1
+        for i=1:3
+            for j=1:3
+        miniarray(i,j)=OUT(i,j);
+            end
+        end
+    case 2
+        i1=1;
+        j1=1;
+        for i=4:6
+            for j=1:3
+        miniarray(i1,j1)=OUT(i,j);
+            j1=j1+1;
+            end
+        i1=i1+1;
+        j1=1;
+        end
+    case 3
+        i1=1;
+        j1=1;
+        for i=7:9
+            for j=1:3
+        miniarray(i1,j1)=OUT(i,j);
+            j1=j1+1;
+            end
+        i1=i1+1;
+        j1=1;
+        end
+    case 4
+        i1=1;
+        j1=1;
+        for i=1:3
+            for j=4:6
+        miniarray(i1,j1)=OUT(i,j);
+            j1=j1+1;
+            end
+        i1=i1+1;
+        j1=1;
+        end
+    case 5
+        i1=1;
+        j1=1;
+        for i=4:6
+            for j=4:6
+        miniarray(i1,j1)=OUT(i,j);
+            j1=j1+1;
+            end
+        i1=i1+1;
+        j1=1;
+        end
+    case 6
+        i1=1;
+        j1=1;
+        for i=7:9
+            for j=4:6
+        miniarray(i1,j1)=OUT(i,j);
+            j1=j1+1;
+            end
+        i1=i1+1;
+        j1=1;
+        end
+    case 7
+        i1=1;
+        j1=1;
+        for i=1:3
+            for j=7:9
+        miniarray(i1,j1)=OUT(i,j);
+            j1=j1+1;
+            end
+        i1=i1+1;
+        j1=1;
+        end
+    case 8
+        i1=1;
+        j1=1;
+        for i=4:6
+            for j=7:9
+        miniarray(i1,j1)=OUT(i,j);
+            j1=j1+1;
+            end
+        i1=i1+1;
+        j1=1;
+        end
+    case 9
+        i1=1;
+        j1=1;
+        for i=7:9
+            for j=7:9
+        miniarray(i1,j1)=OUT(i,j);
+            j1=j1+1;
+            end
+        i1=i1+1;
+        j1=1;
+        end
+end
+end

FilterAndOCR.m

@@ -0,0 +1,37 @@
+%first finding sudoku grid and cropping it. but need to filter image to show clear grid
+
+image = imread('sudokuexample.jpg');                                %read imagefile
+adjustedimage=imadjust(image,[0.4 0.7],[0.0 1.0]);          %adjusting contrast as per histogram analysis
+grayimage=rgb2gray(adjustedimage);                          %convert to gray image
+removeborder=imclearborder(grayimage);                      %remove elements beyond border
+binarymask=removeborder>50;                                 %convert gray image to a binary mask
+binarymask2=imopen(binarymask,strel('disk',5));             %remove noises using morpholgical functions
+connComp=bwconncomp(binarymask2);                           %find connected components in image
+stats=regionprops(connComp,'Area');                         %store property 'Area' of connect components in stats variable
+mask=binarymask2;                                           %make a mask of binarymask2
+mask(vertcat(connComp.PixelIdxList{[stats.Area]<3000}))=0;  %remove all connected components pixels whose area < 3000 pixels in stats
+[x y]=find(mask);                                           %find all pixels x and y coordinate whose pixel value is 1
+
+%find rectangle of sudoku box to be cropped. so we find (xmin,ymin)
+
+xmin=min(x);                                                %find least x coordinate
+xmax=max(x);                                                %find max x coordinate
+ymin=min(y);                                                %find least y coordinate
+ymax=max(y);                                                %find max y coordinate
+crop=imcrop(grayimage,[ymin xmin ymax-ymin xmax-xmin]);     %crop using xmin ymin and length and width of crop area
+finalbinary=crop>90;                                        %convert cropped image to binary with required threshold
+finalbinary=~finalbinary;                                   %negate the image
+finalbinary=imopen(finalbinary,strel('square',3));   %disintegrates grid lines of image captured so area becomes either less or very high.
+
+%final process on finalbinary before applyin ocr
+connComp2=bwconncomp(finalbinary);                          %find connected objects and filter out which are not in area range    
+stats2=regionprops(connComp2,'Area');
+finalbinarymask=finalbinary;
+finalbinarymask(vertcat(connComp2.PixelIdxList{[stats2.Area]<825 | [stats2.Area]>2500}))=0;
+out=imerode(finalbinarymask,strel('disk',3));               %filter out remaining bug pixels
+figure, imshow(out); %final output image
+
+SettingUpAGrid;
+ocrtext=ocr(out,roi,'TextLayout','Block','CharacterSet','123456789');  %perform ocr and consider onlu 0-9 for recognition
+ocrtext.Text;                                               %display text recognised
+

FindMinArray.m

@@ -0,0 +1,27 @@
+function[mininumber] = FindMinArray(col,row)
+if(col>0 && col<4)
+    if(row>0 && row<4)
+        mininumber=1;
+    elseif(row>3 && row<7)
+        mininumber=4;
+    elseif(row>6 && row<10)
+        mininumber=7;
+    end
+elseif(col>3 && col<7)
+    if(row>0 && row<4)
+        mininumber=2;
+    elseif(row>3 && row<7)
+        mininumber=5;
+    elseif(row>6 && row<10)
+        mininumber=8;
+    end
+elseif(col>6 && col<10)
+    if(row>0 && row<4)
+        mininumber=3;
+    elseif(row>3 && row<7)
+        mininumber=6;
+    elseif(row>6 && row<10)
+        mininumber=9;
+    end
+end
+end

MoreAccurateSpace.m

@@ -0,0 +1,30 @@
+function[minimumarray]=MoreAccurateSpace(ANSWER)
+i5=1;
+
+for x3=1:9                                                          %this loop finds an array of all
+    for y3=1:9                                                      %coordinates of empty box and size of possible elements in them
+        if(ANSWER(x3,y3)=='0')
+        min_array=FindMinArray(x3,y3);
+        elements=CollectElements(min_array,ANSWER);
+        possible_elements=PossibleValues(elements,x3,y3,ANSWER);
+        s=size(possible_elements);
+        possible_element_array(i5,1)=x3;
+        possible_element_array(i5,2)=y3;
+        possible_element_array(i5,3)=s(2);
+        i5=i5+1;
+        end
+    end
+end
+s2=size(possible_element_array);                                    %find minimum size of possible elements
+minimum=min(possible_element_array(:,3));
+j=1;
+clear minimumarray;
+for i=1:s2(1)
+    if (minimum==possible_element_array(i,3))                        %return only minimum size of possible elements with coordinates
+    minimumarray(j,1)=possible_element_array(i,1);
+    minimumarray(j,2)=possible_element_array(i,2);
+    minimumarray(j,3)=possible_element_array(i,3);
+    j=j+1;
+    end
+end
+end

PossibleValues.m

@@ -0,0 +1,28 @@
+function[possvalues]=PossibleValues(array,x,y,OUT)
+j=1;
+for i=1:9
+    if(array(i)~='0')
+    values(j)=array(i);
+    j=j+1;
+    end
+end
+j=j-1;
+k=1;
+for i=1:9
+    if(OUT(x,i)~='0')
+    values(j+k)=OUT(x,i);
+    k=k+1;
+    end
+end
+k=k-1;
+l1=1;
+for i=1:9
+    if(OUT(i,y)~='0')
+    values(j+k+l1)=OUT(i,y);
+    j=j+1;
+    end
+end
+valuessorted=unique(sort(values));
+set=['1','2','3','4','5','6','7','8','9'];
+possvalues=setxor(valuessorted,set);
+end

SettingOutputMatrix.m

@@ -0,0 +1,20 @@
+%This script arranges all OCR(Optical Character Recognize) cells into an
+%array and outputs as OUT. 
+for i=1:81
+    a=isempty(ocrtext(i).Words);
+    if(a==1)
+        word(i)={'0'};
+    else word(i)=ocrtext(i).Words;
+    end
+end
+wordMatrix=cell2mat(word);
+o=1;
+for i=1:9
+    for j=1:9
+        OUT(j,i)=wordMatrix(o);
+        o=o+1;
+    end
+end
+
+%corrections
+OUT(8,1)='5';

SettingUpAGrid.m

@@ -0,0 +1,13 @@
+[row column]=size(out);
+r_round=round((row)/9);
+c_round=round((column)/9);
+u=1;
+for i=0:8
+    for j=0:8
+        xinit= i*c_round+20;    %xcoordinate is constant
+        yinit= j*r_round+35;
+        roi(u,1:4)=[xinit yinit 125 125];
+        u=u+1;
+    end
+end
+

SolveBoxes.m

@@ -0,0 +1,15 @@
+%This function does actual solving of SUDOKU
+function[ANSWER,nextcandidate,changecoordinates]=SolveBoxes(minimumarray,ANSWER)
+s3=size(minimumarray);
+     for i=1:s3(1)   
+        min_array=FindMinArray(minimumarray(i,1),minimumarray(i,2));    %Finds which smaller 3x3 array where element (x,y) belongs
+        elements=CollectElements(min_array,ANSWER);                     %extract that 3x3array
+        possible_elements=PossibleValues(elements,minimumarray(i,1),minimumarray(i,2),ANSWER);%finds XOR of all elements in row,column and 3x3 array with 1-9 characters
+        ANSWER(minimumarray(i,1),minimumarray(i,2))=possible_elements(1,1);%replace coordinate on ANSWER with singleton element
+        if numel(possible_elements)>1   %if possible elements were more than 1
+            nextcandidate=possible_elements(1,2);   %store next element for further swapping if required
+            changecoordinates=[minimumarray(i,1) minimumarray(i,2)]; %store coordinates of supposition change
+            return
+        end
+     end   
+end

SolvingAlgo.m

@@ -0,0 +1,18 @@
+FilterAndOCR;                                           %ImageProcess and fix bugs maunally
+SettingOutputMatrix;                                    %Set a Matrix to be fed to SudokuSolver
+ANSWER=OUT;                                             %ANSWER is answer matrix while OUT is question matrix
+count=CheckForEmptyBox(ANSWER);
+while count ~= 0
+    count=0;
+    i5=1;
+    k=1;
+    minimumarray=MoreAccurateSpace(ANSWER);             %Function finds all coordinates where least no. of elements can exist
+    if minimumarray(1,3)==1                             %minimumarray[row col no.of_possible_elements] 
+    ANSWER=SolveBoxes(minimumarray,ANSWER);             %Solves boxes with 1 element possibilty
+    else
+        %minimumarray=MoreAccurateSpaceIfNot1(ANSWER);  
+        %ANSWER=SolveBoxes(minimumarray,ANSWER);
+    break;
+    end
+    count=CheckForEmptyBox(ANSWER);                     %counts number of empty boxes
+end

subset.m

@@ -0,0 +1,4 @@
+function[flag]=subset(U,B)
+        u=union(U,B);
+        flag=isequal(u,U);
+end