Magnus Bjernstad Klas Josephson

Igenkänning av handskrivna siffror med hjälp av
basbilder
Sammanfattning
I den här artikeln visar vi ett exempel p˚a en Matlabimplementation
av identifiering av handskrivna siffror
genom att utnyttja basbilder skapade fr˚an ett
inlärningsmaterial. Dessutom visas en algoritm för
identifiering av hur rader löper i en sida med okända
tecken.
1 Nyckelord
OCR, handskrivna siffror, basbilder, raddetektion
2 Introduktion
Vid m˚anga tillfällen är det intressant att kunna tolka
handskrivna tecken och överföra dessa p˚a textform,
till exempel vid inmatning av text och siffror i handdatorer.
Det finns flera metoder för att konstruera
ett program som utför denna uppgift. Vi har använt
oss av basbilder och jämför sedan de okända objekten
med dessa för att avgöra vilken siffra som tecknet ska
identifieras som.
3 Metod
Segmentering av siffror
Inledningsvis trösklas inbilden s˚a att en binär bild
erh˚alls. Ströpixlar tas bort med hjälp av att morfologiskt
öppna bilden med ett 2 × 2-pixlars strukturelement.
För att koppla samman siffror som best˚ar
av mer än ett sammanhängande omr˚ade dilateras
därefter bilden med ett kvadratiskt strukturelement
med ˚atta pixlars bredd.
Nästa delproblem best˚ar i att fr˚an en bild med siffror
identifiera sammanhängande omr˚aden som vardera
inneh˚aller en siffra. Genom att söka linjärt pixel
för pixel i bilden hittas en punkt där en siffra finns.
Utg˚aende fr˚an denna punkten lokaliseras alla andra
punkter i en 8-sammanhängande väg. För att inte
behöva arbeta vidare med den morfologiskt modifierade
bilden maskas motsvarande pixlar ut fr˚an originalbilden.
Klas Josephson F-00
E-mail: f00kj@efd.lth.se
Magnus Bjernstad F-00
E-mail: f00mbj@efd.lth.se
Handledare: Jacob Sternby
För att förenkla sökningen efter nästa siffra raderas
den utsegmenterade siffran fr˚an originalbilden.
P˚a s˚a sätt kan nästa siffra ocks˚a hittas genom linjär
sökning.
Homogenisering av siffror
Att göra de olika utsegmenterade siffrorna s˚a lika som
möjligt torde bidra till ett bättre resultat. Särskilt
med avseende p˚a basbildsmetoden finns det vissa
fördelar med att göra bilderna invarianta under lutning
i originalbilden. Tv˚a ettor som skrivits med olika
lutning rätas därför upp.
Detta kan uppn˚as genom att l˚ata nedre vänstra
hörnet av siffran motsvara origo. För att avgöra hur
mycket siffran ska roteras identifieras masscentrum
varp˚a bilden translateras s˚a att masscentrum hamnar
i origo. Därefter bildas matrisen A med tv˚a kolonner
och med lika m˚anga rader som antal pixlar som är
icke-noll. Varje rad inneh˚aller koordinaterna till motsvarande
pixel. Egenvektorerna till A T A ger d˚a tv˚a
huvudriktningar för bilden med tillhörande egenvektorer.
Bilden vrids s˚a mycket att egenvektorn som hör
till det största egenvärdet blir vertikal.
För att de segmenterade siffrorna ska kunna
jämföras krävs att de är lika stora. Varje inbild skalas
till 30×20 pixlar oberoende om inbilden inte har dessa
proportioner. Resultat av olika skalningsmetoder
ses i figur 1. Om denna skalning inte utförs innan bilden
roteras s˚a riskeras att en felaktig huvudriktning
för platta bilder identifieras.
2 2
2 2
2
2
Figur 1: Skillnaden mellan skalning d˚a proportionerna
bibeh˚alls (vänstra halvan) och d˚a proportionerna inte
bibeh˚alls (högra halvan).

Generering av basbilder
De m stycken bilderna varifr˚an basbilder ska genereras
läses in i en matris
⎛
⎞
x11 x21 . . . xm1
⎜ x12 x22 . . . xm2 ⎟
A ′ ⎜
= ⎜
⎝
.
.
. ..
.
x1n x2n . . . xmn
⎟
⎠ ,
där varje kolumn är en radstaplad bild med n pixlar.
För att kunna generera relevanta basbilder m˚aste alla
inbilder viktas lika, dvs. varje kolonn i A’ ska normeras
enligt
A·i = A′ ·i
||A ′ ·i ||1
.
Kovariansmatrisen C = AA T beskriver variationen
mellan de enskilda pixlarna i bilderna. Egenbilderna
är egentligen egenvektorer till denna kovariansmatris.
Denna är dock av storlek n × n vilket för stora inbilder
är alltför tungt att beräkna numeriskt. Istället
beräknas egenvektorerna till L = A T A som endast
är av storlek m × m - i de flesta fall ett numeriskt
betydligt enklare problem. L˚at V vara en matris med
egenvektorerna till matrisen L i dess kolonner. D˚a kan
m stycken egenvektorer ui till kovariansmatrisen C,
hörande till de m största egenvärdena, beräknas som
en linjärkombination av de radstaplade bilderna i A.
Detta l˚ater sig lätt göras med en matrismultiplikation
U = AV , där kolonnerna i U är egenvektorerna ui.
Efter en normering f˚as de sökta basbilderna.
De mest intressanta basbilderna är de med störst
tillhörande egenvärde. Med hjälp av endast ett f˚atal
av dessa kan bilderna i A approximativt ˚aterskapas
med gott resultat. Huvudsyftet med utnyttjandet av
basbilder är att oidentifierade siffror kan approximeras
med dessa basbilder.
Figur 2 visar fyra basbilder för tv˚aor. Där syns
det att de sista bilderna är betydligt brusigare än de
första.
Figur 2: Basbild nummer ett, tv˚a, 99 och 100 för
tv˚aor.
Identifikation av okända siffror
När väl basbilderna är konstruerade är det enkelt
att avgöra vilken siffra en viss bild inneh˚aller.
Skalärprodukterna mellan en okänd bild och alla basbilderna
för en viss siffra beräknas. Normen av dessa
koordinater blir d˚a ett m˚att p˚a hur lik bilden är denna
siffra.
Raddetektion
För att kunna använda sifferigenkänningen krävs en
presentation av identifikationen som tar hänsyn till
siffrornas inbördes placering. Detta innebär i praktiken
att en rimlig raddetektion m˚aste utföras. Figur
3 visar principen för en s˚adan algoritm. Steg ett
3 4 5
Figur 3: Princip för raddetektion.
är att genom linjär sökning hitta en pixel i den högst
belägna siffran p˚a första raden. Detta motsvaras att
den mittersta siffran i figuren. Utg˚aende fr˚an denna
siffra söks sedan inledningsvis ˚at vänster i dess
förlängning till dess att nästa pixel p˚aträffas. Proceduren
upprepas fram till vänsterkanten p˚a bilden.
Samma sak utförs˚at höger utg˚aende fr˚an startsiffran.
När en siffra är behandlad raderas den fr˚an urbilden
s˚a att den inte p˚aträffas igen.
4 Experiment
Implementation av ett program som identifikation av
handskrivna siffror var den praktiska delen av v˚art
projekt. Programmet är skrivet i Matlab förutom en
beräkningstung funktion skriven i C. Programkoden
är bifogad i appendix A.
Användning av programmet
Programmet kan använda sig av olika användare för
att kunna identifiera siffror skrivna av en viss person
med särskilda särdrag i sin handstil. För att
kunna använda programmet m˚aste inledningsvis basbilder
genereras fr˚an ett inlärningsmaterial. Dessa
inlärningsbilder inneh˚aller vardera endast en typ av
siffra och ska vara i PNG-format med namn enligt
formen img0001.png, img0002.png, . . . . Bilder med
en typ av siffror placeras under motsvarande underkatalog
till respektive användare (se figur 4).
För att skapa basbilder fr˚an inlärningsbilderna
till en viss användare körs kommandot
setupUser(user), där user är en sträng med
användarnamnet. Basbilderna som skapas läggs
i filerna baseImages/user/baseImages0.dat,
baseImages/user/baseImages1.dat, . . . .

|--sourceImages/
| |--user1/
| | |--0/
| | :
| | |--9/
| |--user2/
| |--0/
| :
| |--9/
|--segmentedImages/
| |--user1/
| |--user2/
| :
|--baseImages/
|--user1/
|--user2/
:
Figur 4: Katalogstruktur för programmet.
Att identifiera okända siffror görs med kommandot
identifyImage(image, user, ’plot’). image
anger en sökväg till en bildfil med siffror. Siffrorna
m˚aste vara mörka och bakgrunden ljus. Anges det frivilliga
argumentet ’plot’ visas identifikationen grafiskt
i realtid.
Med programmet bifogas kompilerade versioner av
getContiguous.c för Sun (getContiguous.mexol)
och för Windows (getContiguous.dll). Om
programmet ska köras p˚a en annan plattform
behöver getContiguous.c kompileras med Matlabkommandot
mex getContiguous.c.
Testresultat
I v˚ara testar har vi använt tre olika användare; Magnus,
Klas och Both. Basbilderna till användaren Both
är genererade fr˚an b˚ade Magnus och Klas siffror. Tabell
1 och tabell 2 visar hur stor procentandel rätt
som f˚as vid identifiering av cirka 200 siffror av varje
slag.
Resultaten visar att det är en framkomlig väg
att identifiera siffrorna med hjälp av basbilder. Vid
identifikation av användarens egna siffror erhölls en
träffsäkerhet p˚a nästan 100%. Noteras bör att denna
träffsäkerhet knappt sjunker när basbilder som skapats
fr˚an b˚adas siffror används. Intressant vore att
undersöka hur dessa resultat förändras med fler samtidiga
användare.
Att identifiera siffror med basbilder skapade fr˚an en
annan persons siffror ger överlag mycket d˚aligt resultat.
Detta är väntat eftersom det inte krävs särskilt
stor förändring av en handstil för att basbildernas
mest signifikanta delar ska förskjutas till omr˚aden
med tidigare mycket l˚ag signifikans.
Raddetektionen ger i allmänhet korrekta resultat.
Även kraftigt lutande rader hanteras väl. I vissa extremfall
kan ordningen p˚a raderna kastas om.
Magnus Klas Both
0 100 86 100
1 100 31 100
2 99 38 96
3 100 38 96
4 97 6 96
5 100 89 100
6 99 100 100
7 95 21 98
8 98 92 98
9 97 41 99
Totalt 99 54 98
Tabell 1: Procentandel rätt vid test p˚a Magnus siffror
med basbilder genererade med de tre användarna
Magnus, Klas och Both, där Both använder b˚adas
inlärningsbilder.
Klas Magnus Both
0 100 100 100
1 100 1 100
2 99 58 97
3 98 81 98
4 91 0 89
5 99 86 100
6 98 97 98
7 100 0 96
8 98 92 99
9 98 38 94
Totalt 98 55 97
Tabell 2: Procentandel rätt vid test p˚a Klas siffror
med basbilder genererade med de tre användarna
Klas, Magnus och Both, där Both använder b˚adas
inlärningsbilder.
Möjliga förbättringar
Önskvärt vore att ha en metod för att avgöra om ett
tecken inte är en siffra. Det enda vi använder oss av
för att urskilja felaktiga tecken är en storlekskontroll
för att hindra alltför sm˚a omr˚aden att tolkas som siffror.
En möjligt förbättring vad gäller klassificeringen är
att utveckla en mer sofistikerad metod för att analysera
de koordinater som f˚ar efter skalärprodukt mellan
den okända bilden och basbilderna. I nuläget avgörs
vilken siffra det är av normen av koordinaterna. En
utveckling av detta är att även ta hänsyn till hur
koordinaterna varierar mellan de olika möjliga siffrorna.
Vidare skulle man kunna göra noggrannare
undersökningar p˚a siffror som ofta ger resultat nära
varandra, främst fyror och nior. Detta skulle kunna
ske genom att man även tittar p˚a specifika särdrag för
siffror. Ett s˚adant exempel är att studera hur m˚anga
h˚al en siffra har. Där skulle fyror i normalfallet ge noll
h˚al, nior ge ett h˚al och ˚attor ge tv˚a h˚al.
Om man skulle använda sig av flera metoder är en

idé att vikta dessa vid klassificeringen s˚a att metoder
som är bra p˚a att till exempel skilja mellan tv˚a
specifika siffror endast har signifikans i detta fall.
Sammanfattning
Vi har i denna rapport gett ett exempel p˚a hur en
implementation av identifiering av handskrivna siffror
kan se ut. V˚ara resultat visar p˚a goda resultat
när basbildsmetoden används. Bra resultat erh˚alls
även när antalet personer som basbilderna bygger p˚a
utökas till tv˚a. Hur detta utvecklas med ännu fler
personer är n˚agot som skulle vara intressant att undersöka.
Speciellt hur bra det d˚a skulle fungera p˚a en
person som inte varit med och genererat basbilderna.

A m-filer
setupUser
function utbild = setupUser(user)
% Segmentera alla bilder som ligger i katalogen
% sourceImages/{user}/[0:9] samt skapa basbilder
% fr˚an dessa.
t = cputime;
for number=0:9
% Segmentera ut siffrorna
saveSegmentedImages(user , number);
% Spara motsvarande basbilder
saveBaseImages(user, number);
end
disp(sprintf(’Total tid: %.2f s’, cputime-t));
saveSegmentedImages
function saveSegmentedImages(user, number)
% Segmentera ut siffrorna som finns i bilderna som ligger i
% katalogen sourceImages/{user}/{number}/. Bilderna sparas i filen
% ’segmentedImages/{user}/segmentedImages{number}.dat’
% Sätt filnamn
imageName = sprintf(’sourceImages/%s/%d/img0001.png’, user, number);
imageNumber = 1;
% Öppna fil för lagring av segmenterade bilder
fid = fopen(sprintf(’segmentedImages/%s/segmentedImages%d.dat’, ...
user, number), ’w’);
% Skriv storleken p˚a varje segmenterad bild
fwrite(fid, [30, 20], ’ubit8’);
fclose(fid);
fid = fopen(sprintf(’segmentedImages/%s/segmentedImages%d.dat’, ...
user, number), ’a’);
% G˚ar igenom alla bilder som tillhör ’user’
while (exist(imageName))
originalImage = imread(imageName);
% Tröskla
originalImage = originalImage < 200;
% Ta bort sm˚a skräp samt dilatera ihop siffror
currentImage = imopen(originalImage, ones(2));
currentImage = imdilate(currentImage, ones(8));
% Koordinater för var nästa bild att extrahera finns
imagePosition = findFirst(currentImage, [1 1]);
% Extrahera denna bilden och uppdatera ursprungsbilden
[foundDigitImage, currentImage] = ...
getImage(currentImage, imagePosition, originalImage);
% G˚a igenom alla siffror i nuvarande bild
while imagePosition ~= -1
% Spara aktuell bild till fil om bilden är tillräckligt stor
if (foundDigitImage ~= -1)

fwrite(fid, foundDigitImage(:), ’ubit1’);
end
% Hitta första icke-nollpositionen i bilden
imagePosition = findFirst(currentImage, imagePosition);
% Segmentera ny siffra om det finns n˚agon
if (isempty(imagePosition) == 0)
[foundDigitImage, currentImage] = ...
getImage(currentImage, imagePosition, originalImage);
end
end
% Sätt namn p˚a nästa fil
imageNumber = imageNumber + 1;
imageName = ...
sprintf(’sourceImages/%s/%d/img%0.4d.png’, user, number, imageNumber);
end
% Stäng filen för lagring av segmenterade siffror
fclose(fid);
disp(sprintf(’Segmenteringen för %d:orna klara’, number));
function updatedPosition = findFirst(inPic, currentPosition)
% Hittar index [row, col] för första elementet i ’inPic’
% vars värde är icke-noll. Returnerar en tom matris om
% alla element är noll.
[nRows nCols] = size(inPic);
for i = currentPosition(1):nRows
for j = 1:nCols
if (inPic(i,j) ~= 0)
updatedPosition = [i j];
return;
end
end
end
updatedPosition = [];
saveBaseImages
function saveBaseImages(user, number)
% Skapa basbilder för siffra ’number’ till de segmenterade
% siffrorna som tillhör ’user’.
% Läs in bilderna som basbilderna ska baseras p˚a. Varje bild lagras
% som en (radstaplad) kolonnvektor i matrisen A.
fid = fopen(sprintf(’segmentedImages/%s/segmentedImages%d.dat’, ...
user, number), ’r’);
% Konrollera om bilder finns
if fid == -1
disp(’Inga segmenterade siffror finns’)
return
end
imageSize = fread(fid, 2, ’ubit8’);
A = fread(fid, [prod(imageSize), inf], ’ubit1’);
fclose(fid);
% Normera kolonnerna i A i 1-normen
A = A ./ repmat(sum(A), size(A, 1), 1);

% Att hitta egenvektorer till kovariansmatrise C=A*A’ är f˚ar sv˚art
% -> studera istället egenvektorer till A’*A (som bara är av
% storlek nPictures*nPictures).
L = A’*A;
[V, eigValues] = eig(L);
% Gör egenvärdena till en vektor istället för en matris
eigValues = diag(eigValues);
% Egenvektorerna U till C kan nu bildas som en linjärkombination av
% bilderna i kolonnerna hos A
U = A*V;
% Sortera egenvektorerna efter storleken p˚a motsvarande egenvärde
[sortedEig eigOrder] = sort(eigValues);
eigOrder = flipud(eigOrder);
U=U(:,eigOrder);
% Normera egenvektorerna
U = U ./ repmat(sqrt(sum(U.^2)), size(U, 1), 1);
% Spara basbilderna.
% Basbilderna sparas i en fil där de första tv˚a talen anger
% storleken p˚a varje bild.
fid = fopen(sprintf(’baseImages/%s/baseImages%d.dat’, user, number), ...
’w’, ’ieee-be’);
% Skriv storleken p˚a varje basbild
fwrite(fid, imageSize, ’ubit8’);
% Skriv basbilderna och stäng filen
fwrite(fid, U(:), ’float32’);
fclose(fid);
getImage
function [digit, updatedImage, digitRect] = getImage(inPic, startPos, originalpic)
% Hittar sammanhängande bild i ’inPic’ med början i ’startPos’.
% Bilden lagras i ’digit’ och den funna siffran ’raderas’ i
% ursprungsbilden och den nya, uppdaterade bilden sparas i
% ’updatedImage’. ’digit’ blir -1 om en för liten bild hittats.
% Extrahera pixlar i ett 8-sammanhängande omr˚ade kring ’startPos’.
% ’updatedImage’ är en bild med detta omr˚ade satt till noll.
% ’digit’ är en {antal pixlar}x2-vektor som inneh˚aller koordinater
% för pixlarna som utgör siffran.
[updatedImage, digit] = getContiguous(inPic, startPos(1), startPos(2));
% Konvertera listan över ing˚aende pixlar till en sparse-matris
digit = sparse(double(digit(:,1)), double(digit(:,2)), 1);
% Plocka ut motsvarande pixlar ur originalbilden
[row,col]=find(digit);
orgDigit=originalpic(min(row):max(row), min(col):max(col));
dilatDigit=digit(min(row):max(row), min(col):max(col));
digit = full(orgDigit & dilatDigit);
% Spara koordinatinformation om den funna bilden
digitRect = [min(row) max(row) min(col) max(col)];
% Skala om bilden till 30x20 om den är tillräckligt stor

if (max(size(digit)) > 20)
digit = resizeDigitImage(digit);
else
digit = -1;
return
end
% Rotera bilden s˚a att egenriktningen pekar rakt upp˚at
digit = rotateImageAlongEigenDirection(digit);
% Ändra storlek igen till 30x20 pixlar
digit = resizeDigitImage(digit);
function outPic = resizeDigitImage(inPic)
% Skala om ’inPic’ s˚a att den täcker 30x20 pixlar. Ta inte hänsyn
% till bildförh˚allandet.
outPicSize = [30 20];
[row col] = find(inPic);
digitRect = [min(row) max(row) min(col) max(col)];
inPic = inPic(digitRect(1):digitRect(2), digitRect(3):digitRect(4));
outPic = imresize(inPic, outPicSize, ’nearest’);
function outPic = rotateImageAlongEigenDirection(inPic)
% Rotera bilden ’inPic’ s˚a att huvudriktningen g˚ar vertikalt.
% Skifta origo till masscentrum av bilden
[nRows nCols] = size(inPic);
[ARows ACols] = find(inPic);
centerOM = centerOfMass(inPic);
ARows = ARows - centerOM(1);
ACols = ACols - centerOM(2);
A = [ARows ACols];
% Beräkna egenvektorerna och egenvärdena. Plocka ut egenvektorn
% hörande till det största egenvärdet.
[eigVec eigValue] = eig(A’*A);
[maxEigenValue maxIndex] = max(diag(eigValue));
eigVec = eigVec(:,maxIndex);
% Räkna ut vilken vinkel bilden ska vridas
if (abs(eigVec(1)) < eps)
theta = pi/2;
else
theta = atan(eigVec(2)/eigVec(1));
end
% Rotera bilden
outPic = imrotate(inPic, -rad2deg(theta));
function centerOfMass = centerOfMass(inPic)
[M, N] = size(inPic);
weightX = sum(inPic, 1);

weightY = sum(inPic, 2);
meanX = weightX *(1:N)’/sum(weightX);
meanY = weightY’*(1:M)’/sum(weightY);
centerOfMass = [meanY meanX];
getContiguous
#include
#include "mex.h"
#include "matrix.h"
struct list {
int row;
int col;
struct list *next;
struct list *prev;
};
typedef struct list item;
mxArray *getContiguous(mxLogical *image, int nRows, int nCols, int startRow, int startCol) {
/* Variabeldeklarationer */
item *pixel, *pixelHead;
item *toCheck, *toCheckHead, *toCheckTail;
int currRow, currCol;
int i,j, nPixels;
mxArray *pixels;
int pixelsDim[2];
int *data;
/* Initiera den nuvarande positionen till startpositionen */
currRow = startRow;
currCol = startCol;
nPixels = 0;
pixelHead = NULL;
toCheck = (item *)mxCalloc(1, sizeof(item));
toCheck->row = startRow;
toCheck->col = startCol;
toCheck->next = NULL;
toCheck->prev = NULL;
toCheckHead = toCheck;
toCheckTail = toCheck;
while(toCheckTail) {
/* Utg˚a fr˚an första pixeln i listan över pixlar att g˚a igenom */
currRow = toCheckTail->row;
currCol = toCheckTail->col;
/* Stega igenom alla grannar till den nuvarande positionen */
for (i = currCol-1; i = 0 && i < nCols && image[nRows*i + j] == 1) {
/* ...gör den svart,... */
image[nRows*i + j] = 0;

}
}
/* ...spara pixelpositionen för den vita pixeln... */
pixel = (item *)mxCalloc(1, sizeof(item));
pixel->row = j;
pixel->col = i;
pixel->next = pixelHead;
pixel->prev = NULL;
pixelHead = pixel;
nPixels++;
/* ...samt spara den nya pixeln som kand. för ytterligare utvidgning. */
toCheck = (item *)mxCalloc(1, sizeof(item));
toCheck->row = j;
toCheck->col = i;
toCheck->next = NULL;
toCheck->prev = toCheckHead;
toCheckHead->next = toCheck;
toCheckHead = toCheck;
}
}
/* Ta bort den precis kontrollerade
pixeln fr˚an kandidater till ytterligare utvidgning */
toCheckTail = toCheckTail->next;
}
pixelsDim[0] = nPixels;
pixelsDim[1] = 2;
pixels = mxCreateNumericArray(2, pixelsDim, mxINT32_CLASS, mxREAL);
data = mxCalloc(nPixels*2, sizeof(int));
i = 0;
pixel = pixelHead;
while (pixel) {
data[i] = pixel->row + 1;
data[nPixels + i] = pixel->col + 1;
pixel = pixel->next;
i++;
}
mxSetData(pixels, data);
return pixels;
void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[]) {
unsigned int *pixelList;
mxLogical *image;
mxLogical *updatedImage;
int i,n;
double *startRow, *startCol;
image = mxGetLogicals(prhs[0]);
startRow = mxGetPr(prhs[1]);
startCol = mxGetPr(prhs[2]);

}
/* Skapa en array som inneh˚aller en uppdaterad bild med den
utsegmenterade delen raderad */
plhs[0] = mxCreateNumericArray(mxGetNumberOfDimensions(prhs[0]),
mxGetDimensions(prhs[0]),
mxLOGICAL_CLASS, mxREAL);
updatedImage = mxGetData(plhs[0]);
/* Konvertera alla element i inbilden till heltal */
n = mxGetNumberOfElements(prhs[0]);
for (i=0; i < n; i++) {
updatedImage[i] = (bool) image[i];
}
plhs[1] =
(mxArray *) getContiguous(updatedImage,
mxGetM(prhs[0]),
mxGetN(prhs[0]),
(int)*startRow,
(int)*startCol);
identifyImage
function result = identifyImage(file, user, doPlot)
% Identifierar siffror i bilden ’file’ med basbilder som tillhör
% användaren ’user’. Om ’doPlot’ sätts till ’plot’ f˚as en bild där
% identifikationen överlagras p˚a bilden ’file’.
% Sätt doPlot till false ifall den ej initieras vid anrop
if (nargin < 3)
doPlot = false;
end
% Kontrollera att användaren finns
if (exist(sprintf(’baseImages/%s/baseImages0.dat’, user)) == false)
disp(’Användaren finns inte’);
return;
end
% Intitiera nödvändiga variabler
result = ’’;
digitRect = [1 1 1 1];
% Kotrollera om filen existerar
if (exist(file) == false)
disp(’Filen ej funnen’)
return;
end
% Läser in bild
originalImage = imread(file);

% Konvertera till gr˚askala
if (size(originalImage, 3) == 3)
originalImage = rgb2gray(originalImage);
end
% Tröskla, öppna, dilatera
originalImage = originalImage < 200;
currentImage = imopen(originalImage, ones(2));
currentImage = imdilate(currentImage, ones(8));
% Plotta bilden om det är valt
if (doPlot == ’plot’)
close;
imshow(not(originalImage));
pause(0.1);
hold on;
end
% Koordinater för var nästa bild att extrahera ’börjar’
imagePosition = findFirst(currentImage);
% Stega igenom inbilden tills inga fler rader p˚aträffas
while (imagePosition ~= -1)
% Initiera raden med identifierade siffror
identifiedRow = [];
% Stega ˚at vänster
direction = -1;
% G˚a igenom en rad i ursprungsbilden
while (imagePosition ~= -1)
% Extrahera siffran
[foundDigitImage, currentImage, newDigitRect] = ...
getImage(currentImage, imagePosition, originalImage);
% Behandla bara bilder som är tillräckligt stora
if (foundDigitImage ~= -1)
digitRect = newDigitRect;
% Spara första identifierade siffran i raden
if (isempty(identifiedRow))
rowStartRect = digitRect;
end
% Normalisera intensiteten
foundDigitImage = foundDigitImage/sum(foundDigitImage(:));
% Identifiera siffran
idNumber = identifyImageByBaseImages(foundDigitImage, user);
% Plotta identifikationen om det valts
if (doPlot == ’plot’)
text(imagePosition(2),imagePosition(1),num2str(idNumber), ...
’color’,’k’, ’backgroundcolor’, ’c’);
pause(0.0001)
end
% Uppdatera raden med identifierade siffror

end
if (direction == -1)
identifiedRow = [idNumber identifiedRow];
else
identifiedRow = [identifiedRow idNumber];
end
end
% Leta upp nästa siffra i raden
imagePosition = findNextInRow(currentImage, digitRect, direction);
% Om det inte finns fler siffror ˚at vänster - ändra
% sökriktning
if (isequal(imagePosition, -1) && direction == -1 && ...
isequal(foundDigitImage,-1) == false)
direction = 1;
imagePosition = findNextInRow(currentImage, rowStartRect, direction);
end
end
% Spara den identifierade raden (om den inte är tom)
if (isempty(identifiedRow) == false)
result = sprintf(’%s%s\n’, result, num2str(identifiedRow));
end
% Hitta nästa siffra (som nu är p˚a en ny rad)
imagePosition = findFirst(currentImage);
function firstIndex = findFirst(inPic)
% Hittar index [row, col] för första elementet i ’inPic’
% vars värde är icke-noll. Returnerar en tom matris om
% alla element är noll.
nRows = size(inPic,2);
% Hitta första icke-noll elementet. Linjärt index.
firstIndex = min(find(inPic’));
% Konvertera linjärt index till [row col]-format
firstIndex = [ceil(firstIndex/nRows) mod(firstIndex,nRows)];
function updatedPosition = findNextInRow(inPic, digitRect, direction)
% Söker i riktningen ’direction’ efter nästa pixel som är
% icke-noll. Index för denna pixel lagras i ’updatedPosition’.
% direction == 1 => höger
% direction == -1 => vänster
% Kontrollera riktning
if (direction == 1)
col = digitRect(4);
else
col = digitRect(3);
end
% Sök efter nästa till man n˚att kanten p˚a bilden
while (sum(inPic(digitRect(1):digitRect(2), col)) == 0)
col = col + direction;

% Kolla om vi g˚att utanför bilden
if (col == 0 || col > size(inPic, 2))
% Reurnera -1 d˚a raden är slut
updatedPosition = -1;
return
end
end
% Returnera position för nästa siffra
updatedPosition = ...
[min(find(inPic(digitRect(1):digitRect(2), col))) + digitRect(1) - 1 ...
col];
identifyImageByBaseImages
function idNumber = identifyImageByBaseImages(inPic, user)
% Avgör vilken siffra bilden ’inPic’ inneh˚aller baserat p˚a
% jämförelse med basbilder tillhörande användaren ’user’.
maxNorm = 0;
nUsedBaseImages = 20;
for number = 0:9;
% Läs in basbilderna
fid = fopen(sprintf(’baseImages/%s/baseImages%d.dat’, user, number), ...
’r’, ’ieee-be’);
% Kontrollera om basbilder finns
if fid == -1
disp(’Basbilder saknas’);
return
end
baseImageSize = fread(fid, 2, ’ubit8’);
baseImages = fread(fid, [prod(baseImageSize), nUsedBaseImages], ’float32’);
fclose(fid);
% Radstapla
currentImage = inPic(:);
% Beräkna skalärprodukterna mellan currentImage och alla
% basebilderna för en given siffra.
coordinates = currentImage’*baseImages;
% Identifiera siffran som den som har störst 2-norm av
% koordinaterna
normCoords(number + 1) = norm(coordinates);
if norm(coordinates) > maxNorm
maxNorm = norm(coordinates);
idNumber = number;
end
end