ad pcode......
==============

darin enthalten sind die programme in C (ordner: cout) und  python (ordner: src).
mit dem Makefile wird das binary "pcode" erzeugt - sollte eigentlich ohne probleme funktionieren (auf den pcs im rechnerübungsraum gehts sicher).

./pcode -h    gibt nun alle möglichen funktionen aus

was du wahrscheinlich fürs ps brauchst:

./pcode -i s1001l01.jpg -w "finaltexture"    erzeugt für das augenbild s1001l01.jpg der casia db die datei s1001l01_finaltexture.tiff - dies ist die rechteckige iris textur im format 512x64 und 8bit  farbtiefe.

falls im ps  nur die textur bearbeitet werden sollte könnte man den obigen befehl in ein shell-script packen und dann zb mit java die tiff datei einlesen und bearbeiten. ich hab meine sachen in C geschreiben da im C source code in der datei "image.c" schon viele hilfreiche funktionen zum auslesen/speichern usw von bildern enthalten sind. wenn man also ein programm in C schreiben würde könnte man die "image.h" datei inkludieren und funktionen wie

Image loadImage(char* filename)

verwenden.  in anderen sprachen müsste man diese funktionen selbst schreiben - sollte aber für tiff dateien auch kein problem sein.

falls im ps direkt die iriscodes der einzelnen algorithmen verwendet werden so kann man mit folgenden befehlen weiterarbeiten:

./pcode -t s1001l01_finaltexture.tiff -w "code algocode" -a lg      Libor Masek
./pcode -t s1001l01_finaltexture.tiff -w "code algocode" -a qsw   Ma, Tan, Wang
./pcode -t s1001l01_finaltexture.tiff -w "code algocode" -a d42   Tan (26 Floats)

die ergebnisse der jeweiligen algorithmen werden in .code dateien abgelegt (zb s1001l01_ld.code) und können zb in den ersten beiden fällen mit einem binäreditor angeschaut werden.

also ich würde vorschlagen:

./pcode -i s1001l01.jpg -w "finaltexture" auf alle bilder anwenden (zb mit shellscript) und einfach die image.h zum bilder auslesen inkludieren - ist am wenigsten aufwand falls man von den texturen startet. falls jemand unter windows arbeitet kann er das ja im rechnerübungsraum machen...


ad ko.tar.gz
============

Verwendung ist im Prinzip gleich wie bei den anderen Algorithmen:

mit "make" kompilieren und dann kann der Algorithmus auf vorverarbeitete Irisbilder angewandt werden:

./ko -i s1002l01_finaltexture.tiff -x 10 -y 3 -g 4

wäre der Algorithmus mit einer Basic Cell Region Dimension von 10x3 Pixel und  einer Gruppengröße von 4. Je nach Parameter werden  verschieden viele Bits extrahiert und in  s1002l01_ko.code geschrieben (analog zu den Algorithmen von Elias). 

ad ko_match
===========

Anbei ein kleines Programm zum Matchen! Code ist selbsterklärend.

make
./ko_match -f s1001l01_ko.code -s s1001l02_ko.code

->
Matching 's1001l01_ko.code' and 's1001l02_ko.code'
Lower Hamming distance: 114

ad Verwendung der noise masks
=============================

hier eine Anleitung um die Ergebnisse für den Ma et al. Algorithmus ("qsw") unter Verwendung von noise-masks zu reproduzieren.

Compilieren:

tar xzf pcode_2008_8_8.tar.gz
cd pcode_2008_8_8
make

1. Mit pcode executable

Texturen und Masken für zwei Bilder erzeugen:

./pcode -i S1001L01.jpg -w "finaltexture mask" -l
./pcode -i S1001L02.jpg -w "finaltexture mask" -l


Die erzeugten Bilder sind:

S1001L01_finaltexture.tiff
S1001L01_mask.tiff
S1001L02_finaltexture.tiff
S1001L02_mask.tiff

(Falls die Bilder nicht im selben Verzeichnis liegen, -b Option um den Namensteil for dem Unterstrich anzugeben, und -p Option um das Output Verzeichnis anzugeben.)


Codes erzeugen:

./pcode -a qsw -t S1001L01_finaltexture.tiff -m S1001L01_mask.tiff
    -l -w "code"
    ./pcode -a qsw -t S1001L02_finaltexture.tiff -m S1001L02_mask.tiff
        -l -w "code"


	Anzahl der unterschiedlichen Bits ausgeben:

	./pcode -c  S1001L01_qsw.code -c S1001L02_qsw.code

	Sollte schreiben: 1: 2389/7736


	Zum Vergleich, Codes ohne Masken:

	./pcode -a qsw -t S1001L01_finaltexture.tiff -m S1001L01_mask.tiff
	    -w "code"
	    ./pcode -a qsw -t S1001L02_finaltexture.tiff -m S1001L02_mask.tiff
	        -w "code"
		./pcode -c  S1001L01_qsw.code -c S1001L02_qsw.code

		Das ergibt: 1: 3570/10240


		2. Mit batch-processing (run.py)

		Zuerst run.py editieren und den absoluten Pfad zum pcode executable am Anfang ersetzen.

		Alle Texturen (und Masken) extrahieren:

		./run.py -e /scratch/CASIA-IrisV3-Interval/ -o textures

		Die Bilder werden in einen neu angelegten Ordner "textures" geschrieben.

		Codes für alle Bilder erzeugen:

		./run.py -c textures -o test1 -a qsw

		Verification mode anwenden:

		./run.py -v test1

		Die Verteilung der Hamming-Distanzen befindet sich danach in test1/distribution.pdf (auch als .gnuplot und .txt Datei), die ROC Kurve in test1/rates.pdf. gnuplot und epstopdf müssen installiert sein.