Eğer genleşme ve aşınma hakkında daha fazla bilgi istiyorsanız Dilation – Erosion bağlantılarını takip edebilirsiniz.

void Dilation()
{
    if (!dilationDone)
    {

        dilationPixelArray = new int[imageWidth, imageHeight];
        for (int i = 1; i < imageWidth - 1; i++)
        {
            for (int j = 1; j < imageHeight - 1; j++)
            {
                if (binaryPixelArray[i, j] == 255)
                {
                    dilationPixelArray[i - 1, j] = 255;
                    dilationPixelArray[i, j - 1] = 255;
                    dilationPixelArray[i, j + 1] = 255;
                    dilationPixelArray[i + 1, j] = 255;
                }
            }
        }
    }
    else
    {
        int[,] tempArray = new int[imageWidth, imageHeight];
        Array.Copy(dilationPixelArray, tempArray, imageWidth * imageHeight);
        for (int i = 1; i < imageWidth - 1; i++)
        {
            for (int j = 1; j < imageHeight - 1; j++)
            {
                if (tempArray[i, j] == 255)
                {
                    dilationPixelArray[i - 1, j] = 255;
                    dilationPixelArray[i, j - 1] = 255;
                    dilationPixelArray[i, j + 1] = 255;
                    dilationPixelArray[i + 1, j] = 255;
                }
            }
        }
    }

}
void Erosion()
{
    if (!erosionDone)
    {
        erosionPixelArray = new int[imageWidth, imageHeight];
        for (int i = 1; i < imageWidth - 1; i++)
        {
            for (int j = 1; j < imageHeight - 1; j++)
            {
                if (binaryPixelArray[i, j] == 255)
                {
                    if (binaryPixelArray[i, j - 1] == 0 ||
                        binaryPixelArray[i - 1, j] == 0 ||
                        binaryPixelArray[i + 1, j] == 0 ||
                        binaryPixelArray[i, j + 1] == 0
                        )
                    {
                        erosionPixelArray[i - 1, j] = 0;
                        erosionPixelArray[i, j - 1] = 0;
                        erosionPixelArray[i, j + 1] = 0;
                        erosionPixelArray[i + 1, j] = 0;
                        erosionPixelArray[i, j] = 0;
                    }
                    else
                    {
                        erosionPixelArray[i, j] = binaryPixelArray[i, j];
                    }
                }
                else
                {
                    erosionPixelArray[i, j] = binaryPixelArray[i, j];
                }
            }
        }
    }
    else
    {
        int[,] tempArray = new int[imageWidth, imageHeight];
        Array.Copy(erosionPixelArray, tempArray, imageWidth * imageHeight);
        for (int i = 1; i < imageWidth - 1; i++)
        {
            for (int j = 1; j < imageHeight - 1; j++)
            {
                if (tempArray[i, j] == 255)
                {
                    if (tempArray[i, j - 1] == 0 ||
                        tempArray[i - 1, j] == 0 ||
                        tempArray[i + 1, j] == 0 ||
                        tempArray[i, j + 1] == 0
                        )
                    {
                        erosionPixelArray[i - 1, j] = 0;
                        erosionPixelArray[i, j - 1] = 0;
                        erosionPixelArray[i, j + 1] = 0;
                        erosionPixelArray[i + 1, j] = 0;
                        erosionPixelArray[i, j] = 0;
                    }
                    else
                    {
                        erosionPixelArray[i, j] = tempArray[i, j];
                    }
                }
                else
                {
                    erosionPixelArray[i, j] = tempArray[i, j];
                }
            }
        }
    }
}

Bundan önceki yazılardaki yapıyı kullandığınızı varsayarak yukarıdaki iki fonksiyonu aşağıdaki şekilde çağırmanız gerekli. Bu fonksiyonların yaptığı iş ise eğer resim ikili seviyeye indirgenmemişse (siyah-beyaz) önce bu işlemi yapmak. Tabii ikiliye çevirmek için herhangi bir eşik değeri belirlenmemişse otsu fonksiyonunu çağırarak önce bir eşik değeri hesaplatıyoruz. Binary fonksyionu ise 0-255 arasındaki parametreyi eşik değeri olarak kullanarak resmi ikili seviyeye indirgiyor, parametrenin 256 olması ise otsu ile hesaplanan eşik değerini alması içindir.

public void ShowDilation()
{
    if (!dilationDone)
    {
        if (!binaryDone)
        {
            if (otsuValue == 0)
                Otsu();
            Binary(256);
        }
        Dilation();
        dilationDone = true;
    }
    else
    {
        Dilation();
    }
    SetImage(ref dilationPixelArray);
}

public void ShowErosion()
{
    if (!erosionDone)
    {
        if (!binaryDone)
        {
            if (otsuValue == 0)
                Otsu();
            Binary(256);
        }
        Erosion();
        erosionDone = true;
    }
    else
    {
        Erosion();
    }
    SetImage(ref erosionPixelArray);
}

Önceki yazıda gri seviyeye çevirilmiş görüntümüz vardı eğer bu görüntüyü siyah beyaza çevirmek istiyorsanız bunun için bir eşik değeri seçerek 0-255 arasındaki gri seviye görüntüyü bu seviyeye göre siyah veya beyaz olarak ayırmak gerekiyor. Eşik değerini sabit bir değer olarak belirleyebileceğiniz gibi her görüntüye göre dinamik olarak bir eşik değeri belirleyebilen bir yöntem de mevcuttur: otsu. Otsu algoritması sayesinde üzerinde çalıştığınız görüntüye özel bir eşik değerini otomatik olarak belirleyebilirsiniz. Bunun için görüntünün histogram dizisine ihtiyacınız olacak. İlk yazıda verdiğim kodda histogram çıkartma özelliği yoktu. Bunun için aşağıdaki kodu kullanabilirsiniz:

int[,] pixelArray = new int[pictureBox1.Image.Height, pictureBox1.Image.Width];
int[,] greyPixelArray = new int[pictureBox1.Image.Height, pictureBox1.Image.Width];
int[] histogram = new int[256];

void BuildPixelArray(ref Image myImage)
{
pixelArray = new int[imageWidth, imageHeight];
greyPixelArray = new int[imageWidth, imageHeight];
Rectangle rect = new Rectangle(0, 0, myImage.Width, myImage.Height);
Bitmap temp = new Bitmap(myImage);
BitmapData bmpData = temp.LockBits(rect, ImageLockMode.ReadWrite, PixelFormat.Format24bppRgb);
int remain = bmpData.Stride - bmpData.Width * 3;
unsafe
{
byte* ptr = (byte*)bmpData.Scan0;
for (int j = 0; j < bmpData.Height; j++)
{
for (int i = 0; i < bmpData.Width; i++)
{
pixelArray[i, j] = ptr[0] + ptr[1] * 256 + ptr[2] * 256 * 256;
greyPixelArray[i, j] = (int)((double)ptr[0] * 0.11 + (double)ptr[1] * 0.59 + (double)ptr[2] * 0.3);
histogram[greyPixelArray[i, j]]++;
ptr += 3;
}
ptr += remain;
}
}
temp.UnlockBits(bmpData);
}

Burada histogram dizisini de oluşturduktan sonra artık otsu algoritması sayesinde dinamik olarak eşik değerini belirleyebiliriz:

int otsuValue;

void Otsu()
{
double fmax = -1.0;
double m1, m2, S, toplam1 = 0.0, toplam2 = 0.0;
int nTop = 0, n1 = 0, n2;

for (int i = 0; i < 256; i++)
{
toplam1 += (double)i * (double)histogram[i];
nTop += histogram[i];
}

for (int i = 0; i < 256; i++)
{
n1 += histogram[i];
if (n1 == 0)
continue;
n2 = nTop - n1;
if (n2 == 0)
break;
toplam2 += (double)i * (double)histogram[i];
m1 = toplam2 / n1;
m2 = (toplam1 - toplam2) / n2;
S = (double)n1 * (double)n2 * (m1 - m2) * (m1 - m2);
if (S > fmax)
{
fmax = S;
otsuValue = i;
}
}
}

Otsu veya sabit bir değere göre görüntüyü siyah beyaza çevirecek kod ise aşağıdadır. Bu fonksiyonun aldığı argThreshold parametresi eşik değerini belirtern 0-255 arasında bir değerdir.

void Binary(int argThreshold)
{
binaryPixelArray = new int[imageWidth, imageHeight];
for (int i = 0; i < imageWidth; i++)
{
for (int j = 0; j < imageHeight; j++)
{
if (greyPixelArray[i, j] < threshold)
binaryPixelArray[i, j] = 0;
else
binaryPixelArray[i, j] = 255;
}
}
}

Görüntüyü siyah beyaza çevirdikten sonra eğer kenar bulma algoritmalarını kullanmak isterseniz bir kaç seçeneğiniz mevcut. Bunlardan en popüleri sobel kenar bulma filtresidir. Aşağıdaki fonksiyonda type parametresi hangi tür kenarların bulunacağını belirtmek içindir. Dikey, yatay, köşegen şeklindeki kenarları veya tamamını ayrı ayrı bulabilirsiniz.

void Sobel(int type)
{
int normalizeMax = 0;
int normalizeMin = maxIntVal;

sobelPixelArray = new int[imageWidth, imageHeight];
int[,] sobelArray1 =
new int[3, 3] {
{ 1, 0, -1 },
{ 2, 0, -2 },
{ 1, 0, -1 }
};

int[,] sobelArray2 =
new int[3, 3] {
{ 1, 2, 1 },
{ 0, 0, 0 },
{-1,-2,-1 }
};
int[,] sobelArray3 =
new int[3, 3] {
{ 2, 1, 0 },
{ 1, 0,-1 },
{ 0,-1,-2 }
};

int G1, G2, G3;
for (int i = 1; i < imageWidth - 1; i++)
{
for (int j = 1; j < imageHeight - 1; j++)
{
G1 = 0;
G2 = 0;
G3 = 0;
for (int k = -1; k < 2; k++)
{
for (int l = -1; l < 2; l++)
{
G1 += greyPixelArray[i + k, j + l] * sobelArray1[k + 1, l + 1];
G2 += greyPixelArray[i + k, j + l] * sobelArray2[k + 1, l + 1];
G3 += greyPixelArray[i + k, j + l] * sobelArray3[k + 1, l + 1];
}
}
if(type == 0)
{
sobelPixelArray[i, j] = Math.Abs(G1) + Math.Abs(G2) + Math.Abs(G3);
}
else if (type == 1)
{
sobelPixelArray[i, j] = Math.Abs(G2);
}
else if (type == 2)
{
sobelPixelArray[i, j] = Math.Abs(G1);
}
else if (type == 3)
{
sobelPixelArray[i, j] = Math.Abs(G3);
}

if (normalizeMax < sobelPixelArray[i, j])
normalizeMax = sobelPixelArray[i, j];
if (normalizeMin > sobelPixelArray[i, j])
normalizeMin = sobelPixelArray[i, j];
}
}

NormalizeArray(ref sobelPixelArray, normalizeMax, normalizeMin);
}

Yukarıda bulunan kodun en altında çağırılan normalize fonksiyonu ise sonuç dizisini 0-255 değerleri arasına düşürmek içindir:

void NormalizeArray(ref int[,] sourceArray,int normalizeMax,int normalizeMin)
{

int factor = normalizeMax - normalizeMin;
for (int i = 0; i < sourceArray.GetLength(0); i++)
{
for (int j = 0; j < sourceArray.GetLength(1); j++)
{
sourceArray[i, j] = (sourceArray[i, j] - normalizeMin) * 255 / factor;
}
}
}

Bir diğer kenar bulma yöntemi ise Prewitt’tir:

int[,] prewittPixelArray;

void Prewitt()
{
int normalizeMax = 0;
int normalizeMin = maxIntVal;
prewittPixelArray = new int[imageWidth, imageHeight];
int[,] PrewittArray1 =
new int[3, 3] {
{-1,-1,-1 },
{ 0, 0, 0 },
{ 1, 1, 1 }
};

int[,] PrewittArray2 =
new int[3, 3] {
{ -1, 0, 1 },
{ -1, 0, 1 },
{ -1, 0, 1 }
};
int[,] PrewittArray3 =
new int[3, 3] {
{-1,-1, 0 },
{-1, 0, 1 },
{ 0, 1, 1 }
};

int[,] PrewittArray4 =
new int[3, 3] {
{ 1, 1, 0 },
{ 1, 0,-1 },
{ 0,-1,-1 }
};

int G1, G2, G3, G4;
for (int i = 1; i < imageWidth - 1; i++)
{
for (int j = 1; j < imageHeight - 1; j++)
{
G1 = 0;
G2 = 0;
G3 = 0;
G4 = 0;
for (int k = -1; k < 2; k++)
{
for (int l = -1; l < 2; l++)
{
G1 += greyPixelArray[i + k, j + l] * PrewittArray1[k + 1, l + 1];
G2 += greyPixelArray[i + k, j + l] * PrewittArray2[k + 1, l + 1];
G3 += greyPixelArray[i + k, j + l] * PrewittArray3[k + 1, l + 1];
G4 += greyPixelArray[i + k, j + l] * PrewittArray4[k + 1, l + 1];
}
}

prewittPixelArray[i, j] = Math.Abs(G1) + Math.Abs(G2) + Math.Abs(G3) + Math.Abs(G4);
if (normalizeMax < prewittPixelArray[i, j])
normalizeMax = prewittPixelArray[i, j];
if (normalizeMin > prewittPixelArray[i, j])
normalizeMin = prewittPixelArray[i, j];
}
}

int factor = normalizeMax - normalizeMin;
for (int j = 1; j < imageHeight - 1; j++)
{
for (int i = 1; i < imageWidth - 1; i++)
{
prewittPixelArray[i, j] = (prewittPixelArray[i, j] - normalizeMin) * 255 / factor;
}
}
}

Prewitt ve sobel’e alternatif olarak Robert kenar bulma filtresi de mevcuttur :

int[,] robertPixelArray;

void Robert()
{

robertPixelArray = new int[imageWidth, imageHeight];
for (int i = 1; i < imageHeight - 1; i++)
{
for (int j = 1; j < imageWidth - 1; j++)
{
robertPixelArray[j, i] = Math.Abs(greyPixelArray[j, i] - greyPixelArray[j - 1, i - 1]) + Math.Abs(greyPixelArray[j, i - 1] - greyPixelArray[j - 1, i]);
}
}
}

Eğer kenar bulma algoritmalarını kullanmadan önce görüntüdeki gürültüleri temizlemek istiyorsanız mean, median ve gaussian filtereleri ile bu işlemi yapabilirsiniz.

Mean filtresi :

int[,] meanPixelArray;

void Mean()
{
meanPixelArray = new int[imageWidth, imageHeight];
for (int i = 1; i < imageHeight - 1; i++)
{
for (int j = 1; j < imageWidth - 1; j++)
{
meanPixelArray[j, i] =
(
greyPixelArray[j, i - 1]
+ greyPixelArray[j, i + 1]
+ greyPixelArray[j, i]
+ greyPixelArray[j - 1, i - 1]
+ greyPixelArray[j - 1, i + 1]
+ greyPixelArray[j - 1, i]
+ greyPixelArray[j + 1, i - 1]
+ greyPixelArray[j + 1, i + 1]
+ greyPixelArray[j + 1, i]
) / 9;
}
}
}

Median filtresi:

int[,] medianPixelArray;

void Median()
{

medianPixelArray = new int[imageWidth, imageHeight];
int[] tempArray = new int[9];
for (int i = 1; i < imageHeight - 1; i++)
{
for (int j = 1; j < imageWidth - 1; j++)
{
int counter = 0;
for (int k = -1; k < 2; k++)
{
for (int l = -1; l < 2; l++)
{
tempArray[counter++] = greyPixelArray[j + l, i + k];
}
}
System.Array.Sort(tempArray);
medianPixelArray[j, i] = tempArray[4];
}
}
}

Gaussian filtresi

int[,] gaussianPixelArray;

void Gaussian()
{
gaussianPixelArray = new int[imageWidth, imageHeight];

int[,] gaussianArray =
new int[5, 5] {
{1,4,7,4,1},
{4,16,26,16,4},
{7,26,41,26,7},
{4,16,26,16,4},
{1,4,7,4,1}
};
int tempSum;
for (int i = 2; i < imageHeight - 2; i++)
{
for (int j = 2; j < imageWidth - 2; j++)
{
tempSum = 0;
for (int k = -2; k < 3; k++)
{
for (int l = -2; l < 3; l++)
{
tempSum += greyPixelArray[j + l, i + k] * gaussianArray[k + 2, l + 2];
}
}
gaussianPixelArray[j, i] = tempSum / 273;
}
}
}

Daha sonraki yazıda yapısal (morfolojik) işlemleri yapan filtreleri de açıklamalarıyla birlikte vermeyi düşünüyorum. O zamana kadar hepinize kolay gelsin.

Biyometri Nedir?

Biyometri insanları birbirinden ayırt edebilecek fiziksel özelliklerini ve sergiledikleri davranışları inceleyen bilim dalıdır.  İnsanları birbirinden ayırt edebilme şansını bize sunduğundan dolayı biyometri bir kimlik doğrulama sistemi olarakta kullanılmaktadır. Biyometrik tanıma sistemleri bir bireyin gerçekten ‘kim’ olduğunu kanıtlamasına olanak sağlar.

İnsanların bunu yapması için ek olarak bir kart, cihaz, kimlik taşımamaları ve şifre gibi ezbere dayalı bilgileri kafalarında tutmamaları ise bu biyometrik tanımanın önemli avantajlarındandır. Unutulması veya başkası tarafından kullanılması söz konusu olmayan bir kimlik onaylama yoludur. Bu sayede kimlik, pasaport, ehliyet gibi kartların yerini tamamen alacak bir sistem geliştirilebilir. Hem daha güvenli hemde aşılması zor sistemler gün geçtikçe orataya çıkacaktır. Örneğin üniversitemizin giriş kapısında bulunan kapılarda manyetik kartlar yerine araç sürücüsünü tanıyarak girişne izin veren bir sistemin kullanılması çok daha güvenli ve mantıklı olacaktır. Bu sayede yetki verilen kişi başka araçla da giriş yapabildiği gibi, yetkisiz bir kişi herhangi bir kartla giriş yapamayacaktır.

Biyometrik tanımada kullanılacak birden fazla yöntem vardır. Gereksinimlere göre bu yöntemlerden biri veya birkaçı kullanılabilir. Birden fazla yöntemi bir arada kullanmak sonuçları kesinleştirmek için gerekli olabilir. Bu yöntemler her zaman doğru sonuçları vermeyebilir, bundan dolayı kullanım alanına göre yüksek başarı sağlayanlar seçilmelidir. Başarı oranının yanı sıra tanıma işleminin gerçekleşmesi için gereken sürede yöntemlerin seçilmesinde dikkate alınmalıdır. Gerçek zamanlı (real-time) tespit yapmak gerektiğinde yöntem seçimine çok daha fazla dikkat edilmelidir.

Genel olarak bu sistemlerin çalışma prensibi; her yöntemin kendine ait girdi cihazıyla alınan verilerin analiz edilip daha önceden girilmiş değerlerle karşılarşıtırılıp eşleştirilmesine dayanmaktadır. Bilgisayarların birim zamanda yaptığı işlem sayısının sürekli artması  göz önüne alındığında eldeki veriler ile anlık olarak alınan örneğin karşılaştırılma hızı da gittikçe artmaktadır. Saniyeler içinde yüzbinlerce veriyi karşılaştırıp doğru sonuçları veren sistemler günümüzde çeşitli alanlarda kullanılmaktadır.

Biyometrinin Tarihi
İnsanoğlu biyometrik tanımayı doğduğu andan itibaren yapmaya başlar. Yeni doğan bebekeler gerek annesini gerek çevresindeki diğer kişi ve cisimleri sıfırdan başlayarak öğrenir. Bu öğrenme işlemini veritabanına ilk bilgilerin girilmesi olarak düşünebiliriz. Yeni doğan bebekler örneğine dönersek bu bebekler daha sonradan gördüğü, duyduğu yani duyu organlarıyla algıladığı her şeyi önceki veriler ile karşılaştırıp belirli sonuçlar elde ederek tanıma işlemini yapar. Örneğin annesini sesinden ve kokusundan rahatlıkla tanıyabilir. Beynimiz bu tanıma işlemlerini otomatik olarak yapmaya başlar ve genellikle mükemmele yakın başarı sağlar.

Beynimiz tarafından otomatik olarak yaptığımız bu tanımanın yanı sıra sistematik olarak yapılan tanımanın ilk örnekleri insanoğlunun tarihi kadar eski değildir. Binlerce yıl önce yaşamış insanların birbirlerini göz rengi, ten rengi, boy gibi kolaylıkla ölçülen özelliklerle kesin olarak ayırt ettikleri konuyla ilgili kaynaklarda belirtilmektedir.

Birçok yeni teknolojinin geliştirilmesinde olduğu gibi biyometrinin de gelişiminde güvenlik unsuru öncülük etmiştir. Biyometrik tanıma birçoğumuzun filmlerden aşina olduğu parmak izinden suçluyu tespit etme gibi yöntemlerle hala kullanılmaktadır. Hızla gelişen teknoloji sayesinde parmak izinin yanı sıra günümüzde bir çok yöntem ile bu tip suçlu tespiti yapılmaktadır. Bunların en bilindik olanlarından biriyse DNA testidir. İnsanların DNA’larının birbirinden farklı olduğu dış görünüşümüne de yansıdığı gibi belirgin bir şekilde ortadadır. Tek yumurta ikizleri haricinde (tek yumurta ikizlerinin parmak izleri birbirinden farklıdır) bir insanın başka bir insanla aynı DNA’ya sahip olmadığından dolayı günümüzde bu testlerde geçerliliğini korumaktadır.

Başlıca Biyometrik Yöntemler ve Çalışma Prensipleri

Biyometrik yöntemlerin genel çalışma prensibi iki adımdan oluşmaktadır. Birinci adımda tanınacak kişinin ilgili yönteme ait bilgiler gerekli araçlar vasıtasıyla bilgisayar ortamına aktarılıyor. Bu bilgiler yine yönteme özel algoritmalar sayesinde analiz ediliyor ve kişiyi tanımlayacak parametreler bu bilgiler içinden seçilerek veritabanına kayıt ediliyor. İkinci adım ise kişinin kimlik doğrulama isteğidir. Bu adımda sisteme aynı araçlar vasıtasyıla girilen bilgiler genellikle kayıt sisteminde uygulanan aynı algoritmayla analiz edilip veritabanındaki bilgilerle karşılaştırılıp eşleştirmelere bakılıyor. Eğer eşleşme varsa kişinin kimliği onaylanmıştır aksi halde sistemde bir sorun yoksa kişi iddia ettiği kimliğe sahip değildir.

Yukarıda geçen birinci adımında gerekli olan algoritmalar yöntemler arasında büyük farklılıklar göstermektedir. Örneğin ses ve parmak izi tanıma arasında bilgiyi dijital ortama aktaran araçlardan bu bilginin analizinde kullanılan algoritmaya kadar çoğu araç ve yazılım farklıdır. Ancak sisteme alınan bilgilerin işlenişi çoğunda ortaktır. Hangi yöntemde olursa olsun analogdan dijitale çevirilen veri içinden belirli özellikler seçilir. Bu özellik seçimi sonucunda ortaya çıkan veriler bizim karşılaştırma ve kayıt fonksiyonlarına vereceğimiz parametrelerdir. Bu parametrelerin sayısı arttıkça tanıma işleminin doğruluğu artar. Ancak doğru orantılı bir artış söz konusu değildir. Belirli bir limitten sonra parametre sayısının arttırılması sadece sisteme ek yük getirecektir ve tanıımanın doğruluğu üzerinde bir etki etmeyecektir.    Örneğin bir kişiyi tanımak için sadece boyunu parametre olarak alırsak aynı boyda iki insanı ayırt edemeyiz. Bunun yanı sıra eğer kişilerin kilolarını da parametre alırsak başarı oranımız artar.  Kişinin vücudundaki bütün ölçüleri almanın bir anlamının olmayacağı ortadadır.

Biyometrik tanıma işlemindeki bu iki adıma dört ayrı katman olarak bakabiliriz:

• Yönteme ait cihazlar ile analog ortamdan dijital ortama veri aktarımı

• Dijital ortamda aktarılan verilerden gerekli parametrelerin çıkarılması

• Bu parametrelerin önceki verilerle karşılaştırılması

• Karşılaştırma işleminin yapılması için gerekli olan verileri tutacak veritabanı

Analog ortamdan dijital ortama veri aktarımı sırasında kayıt esnasındaki ortamın tamamen aynısını oluşturmak çok zordur. Bundan dolayı çıkarılacak parametrelerin çevre koşullarının değişimine karşı sabit kalması veya sonucu etkilemeyecek kadar az değişmesine dikkat edilmelidir.

Örneğin bir ses tanıma sisteminde kayıt esnasında kişi mikrofona konuştuğu zaman çevredeki seslerde kayıt altına alınacaktır. Kimlik doğrulama için aynı kişi tekrar mikrofona konuştuğunda ise çevredeki seslerin (gürültülerin) aynı olamaz. Bundan dolayı tanıma işleminde kullanılacak parametreler özenle seçilmelidir.

Bu tip yanlış algılama olasılıklarının olduğu biyometrik tanıma yöntemlerinin kıyaslanması için aşağıdaki terimler ileri sürülmüştür:

• False Accept Rate (FAR) : Sistemin veritabanında bulunmayan bir kişiye ait bilgileri yanlış analiz etmesinden ve veritabanında bulunan biriyle eşleştirmesinden kaynaklanan yanlış tespitlerin oranıdır.

• False Reject Rate (FRR) : Sistemin veritabanında varolan kişileri sonraki bir tarama sonucunda bulamamasının oranıdır.

Bu iki orana bakılarak tanıma yöntemleri birbirleriyle kıyaslanabilir.

i.    Parmak İzi Tanıma

Tarihçe:
Parmak izinin oldukça eski bir tarihi vardır. Nehemiah Grew (1684), Marcello Malpighi (1686)  ve  J. E. Purkinje (1823)  adlı bilimadamları parmak izlerinin birtakım özellikler barındırdığına dikkat çekmiş olmalarına rağmen bu özelliklerin kişi tespitinde kullanacak kadar benzersiz olduğunu ortaya sürecek herhangi bir çalışma yapmamışlardır.

Günümzüde kullanılan yöntemlerin temeli olarak kullanılan parmak izi tanıma sistemlerinin temeli ise Henry Faulds ve Wiliam James Herschel adında iki İngilizin bilimadamının çalışmalarıyla başlamıştır. Bu iki bilimadamı kişilerin parmak izlerini alma yöntemleri üzerine çalışmışlar ve temel olarak mürekkep kullanımının üzerine gitmişlerdir.

Sir Francis Galton (1822-1911)  istatistik üzerine yaptığı çalışmalar soncunda iki bağımsız değişken arasındaki doğrusal ilişkinin yönünün ve kuvvetini belirten korelasyon (correlation) yöntemini ileri sürmüştür. Bu sayede iki örüntü (pattern) arasında karşılaştırma yapacak bir yöntem elde etmiştir. Çalışmalarının devamında insanların parmak izleri arasındaki farkı sınıflandırıp ayırt edecek yöntemler ortaya çıkarmıştır. Galton parmak izinin kalıtımsal olmadığını ve her insanın parmak izinin birbirinden farklı olacağını çalışmalarıyla ortaya çıkarmıştır.

Galton’un çalışmalarını takiben Dr Henry Faulds (1983-1930) parmak izinin sınıflandırılmasına tam olarak açıklık getirmiştir. Farklı sınıflandırmala olsa bile Galnton ve Henry’nin yaptığı çalışmaların ürünü olan sınıflandırma sistemi yaygın olarak kullanılmaktadır.

Günümüzdeki sistemlerde bu sınıflandırma genelde iki parmaktan alınan örnekler üzerinde gerçekleştirilmektedir. Tek parmaktan alınan bilgi ile de aynı işlem yapılabilir olmasına rağmen güvenlik ve stabil çalışma açısından en az iki parmak izi alınmaktadır. 25 Haziran 2007’de ABD’de sınır kapılarında bundan sonra iki değil on parmak izinin birden alınacağı bir sisteme geçileceğini açıklamıştır.

Ülkemizde parmak izinin incelenilmesi ve biyometrik tanıma olarak kullanılması 1910 yılında Macar asıllı Yusuf Cemil tarafından başlatılmıştır. Daha sonra ise polis teşkilatı tarafından kullanılmıştır.

Özellikleri:
Galton ve Henry’nin çalışmaları sonucunda ortaya çıkan sınıflar çizgilerin şekline göre ayrılmaktadır ve bu sınıflar aşağıdaki gibidir:

• Yay (arch)
• Döngü (loop)
• Helezon (whorl)

Yay (Arch)                      Döngü (Loop)               Helezon (Whorl)

Daha detaylı işlemler için bu sınıflarda alt sınılara bölünmektedir.

Bu sınıflandırmaların yanı sıra parmak izlerine çizgi bazında bakıldığında belirli özelliklere sahip noktalar ortaya çıkmaktadır.

• Eni boyuna neredeyse eşit olan çizgiler nokta (ridge dots) olarak alandırılır



• Noktalardan daha uzun olan ve değişken boyutlu çizgilerde vardır ve ada (island) olarak adlandırılır



• Bir çizginin bölünüp birden çok çizgiye ayrılıdığı noktalar çatal (bifurcation) olarak adlandırılır


Karşılıklı çatal (opposed bifurcation)

İkili Çatal (double bifurcation)

Üçlü Çatal (trifurcation)

• Çizgilerin bitiş noktalarıda özel olarak ele alınır
  
• Birden fazla çizginin kesiştiği noktalarda özel olarak ele alınır
  
• Bir çizginin çatallaşıp kısa bir mesafe sonra tekrar birleşmesi sonucunda oluşan kapalı yapıya göl (lake) adı verilir.
  
• Paralel giden iki çizgiyi birleştiren kısa çizgilere de köprü (bridge) adı verilir.
  

Parmak izi tanıma işlemi korelasyon yöntemiyle yapıldığı gibi yukarıda belirtilen özel noktaların yer ve sırasına göre de yapılabilir. İkinci işlem için graf yapısı oluşturulmalıdır. Korelasyon işleminin doğru sonuç verebilmesi yön bilgisine de bağlı olduğundan örnek alınırken buna dikkat edilmelidir.

Parmak izinden gerekli özellikleri çıkarmak için belli başlı görüntü işleme tekniklerini uygulanmaktadır.

• Görüntünün gürültülerden arındırılması
• Kenar algılama
• Özelliklerin çıkarılması

Parmak izinin gürültülerden arındırılması işleminde belirli filtreler kullanılır. Median, mean ve gaussian gibi filtreler bunlardan bazılarıdır.

Kenar algılama filtreleri olarak sobel, gradient, prewitt gibi filtrelerl kullanılır.

Özellik çıkarma işlemi için kenar algılama sonucunda elde edilen görüntüde inceltme algoritmaları uygulanıp çizgiler özellik çıkarma için uygun hale getirilir. Daha sonra çizgilerin bitiş ve çatal noktaları elde edilir.

Avantajları:

• Parmak izinin kolaylıkla alınabilmesi.
• İkizlerde bile farklılık gösterir.
• Parmak izinin değiştirilip bir başka parmak izine benzetilmesi zordur
• Belirli özelliklerinin çıkarılıp sadece bu özelliklerin saklanması sayesinde hızlı arama yapılabilir.

Dezavantajları:

• Örnek alınan parmağın yıpranması sonucu aynı izin tekrar elde edilemeyebilir.
• Kişinin kilo alması gibi fiziksel değişimlerden parmağında etkilenmesi ve parmak izinin eskisiyle örtüşmeyecek hale gelmesi mümkündür.
• Parmak izinin kalıbının kendisi yerine kullanılma ihtimali vardır.

ii.    Yüz Tanıma

Tarihçe:
İnsan yüzü parmakta olduğu gibi özelliklerinin kolay çıkarılabileceği bir yapıya sahip olmadığınadan yüz tanımanın gelişimi ve kullanımı parmak izinde olduğu kadar eskiye dayanmamaktadır. Yüzümüzün içerdiği özelliklerin fazlalığı bu özellikleri kullanacak yöntemlerin sayısını da arttırmıştır. Değişik özellikleri kullanan değişik yöntemler ortaya çıkmıştır. Bunlardan ilki sayılabilecek yöntem ‘eigenfaces’ Matthew Turk ve Alex Pentland 1987 yılında ortaya atılmıştır. Yüz tanımada kullanılan başlıca yöntemler aşağıdaki gibidir:

• PCA
• ICA
• LDA
• EP
• EBGM
• Kernel Methods
• Trace Transform
• AAM
• 3-D Morphable Model
• 3-D Face Recognition
• Bayesian Framework
• SVM
• HMM
• Boosting & Ensemble

‘Eigenface’ örnekleri

Yüz tanıma yöntemi kullanılarak 2000  yılında Meksika’da  yapılan seçimlerde birden fazla oy kullanılmasını engelleyecek bir sistem oluşturulmuştur. Ayrıca 2001 yılında ABD’de yapılan NFL (National Football League) finalinde 19 suçlu yakalanmıştır. ABD’de verilen ehliyet, kimlik gibi belgelerde bir kişinin farklı adlarla kayıt yaptırmaması amacıyla yüz tanıma sistemi kullanılmaktadır.

Özellikleri:
Yüz tanıma yönteminde kişilerden örnek almak diğer yöntemlere göre çok daha zordur.  Sıradan bir kamera ile çevreden birçok yüz görüntüsü alınabilir. Ancak burada başka bir sorun ortaya çıkmaktadır. Kamera tarafından alınan görüntüde tamamen yüze ait bölge bulunmalıdır. Bunun için ‘Face Detection’ yani yüz bulma algoritmaları kullanılmaktadır. Yüz bölgesi bulunduktan sonra işlemeler burada devam etmektedir.

Bu adımdan sonra değişik yollar izlenerek yüz tanıma işlemi yapılabilir. Bazı yöntemler yüzde bulunan oranları karşılaştırıken bazılar YSA ile öğreterek tanıma yapmaktadır. Bu yöntemlerin çalışma şekilleri aşağıda kısaca açıklanmıştır.

PCA yönteminde tanıma işleminin yapılabilmesi için alınan örneklerin veritabanında bulunanlar ile aynı boyutta olması gereklidir. PCA tekniği temel olarak çok boyutlu veri kümelerini analiz edilebilmesi için daha az boyutlu kümelere dönüştürür. Bu yöntemde yapılan işlem Karhunen-Loève transformu olarak da bilinmektedir. PCA yönteminde veritabanında saklanan görüntüler küçültülmüş ve sıkıştırılmış olarak saklanmaktadır. Bu sayede vertabanın yükü azaltılmış ayrıca arama hızı arttırılmıştır.

ICA (Independent component analysis) yöntemi çok değişkenli işaretleri alt parçalara bölerek işlem yapmaya dayalı bir hesaplama metodudur.

LDA (Linear Discriminant Analysis)  elde varolan sınıfların özelliklerini ölçerek yeni gelen örneklerin sınıflandırılmasını sağlayan bir yöntemdir. Sınıflar arasında farklılıklar arttırılmaya çalışılırken sınıf içindeki örneklerin arasındaki farklar azaltılmaya çalışılır. LDA sadece sınıflandırma yapmaya yarayan bir yöntemdir. Veri tipi hakkında herhangi bir bilgi vermez.

EP (Evolutionary Pursuit) genetik algorimtaları kullanarak sınıflandırma yapan bir yöntemdir. Karşılaştırılacak örnek sayısı (durum uzayı) çok büyük olduğu zaman genetik algoritmalara başvurmak hızlı bir çözüm elde etmemize yardımcı olmaktadır.

EBGM (Elestic Bunch Graph Matching) yönteminde insan yüzünü graf olarak ifade eder. Graftaki düğümler burun, göz gibi belirgin noktalardan oluşur. Kenarlar, noktalar arasındaki 2boyutlu uzaklıklar ile ağırlıklandırılır.  Her düğümde farklı faz ve genlikte oluşturulmuş 40 adet Gabor wavelet katsayısı bulunur. Bu katsayılara ‘jet’ denilmektedir. Tanıma işlemi jet’ler ve ağırlıklandırılmış kenarlar ile yapılır.

Trace Transform Radon dönüşümünün genelleştirilmiş halidir. Radon dönüşümü iki boyutlu uzayda düz çizgilere uygulanan intergral dönüşümüdür. Ters radon dönüşümü ile görüntülerin tekrar oluşturulması sağlanabilir. Trace transform sayesinde cisimleri tanırken rotasyon, boyutlandırma gibi transformasyonların ektileri ortadan kaldırılır. Bu sayede farklı açılardan görüntüsü alınan cisimlerde tanınabilir.

AAM (Active Appearance Model) nesnelerin şekillerini istatistiksel bir modelidir ve iki resmin eşleştirilmesi için kullanılan bir hesaplama yöntemidir. Algoritma gri seviye resimler üstünde tahmin edilen nokta ile hedef nokta arasındaki farkların hesaplanmasıyla (least squares) çalışır.

3-D Morphable Model yukarıda kullanılan tekniklere göre daha değişik bir yaklaşım ile yüz resimlerini 3 boyutlu olarak inceler. Örnek olarak alınan resmin çekildiği ortam ile veri tabanındakini karşılaştırırken çevre koşullarının değişimini 3 boyutlu görüntüye uyarlayarak elde ettiği sonuç ile karşılaştırma yapabilir. Bu yöntemi açıkayacan örnek programın videosunu izleyebilirsiniz. Verilen resimden 3boyutlu görüntüyü çıkarması ve transformasyonlardan bağımsız olması bu yöntemi güçlü kılmakla beraber uygulanmasını da bir o kadar zorlaştırmaktadır.

3-D Face Recognition bu yöntemin getirdiği en büyük yenilik yüz görüntüsünde kişinin doğal ifadeleriden bağımsız olarak tanıma yapabilmesidir. Öncelikle yüz bölgesi ve dokusu belirlenir.  Daha sonra bu bölge içinden gereksiz ve tanımayı zorlaştıracak bölümler (saç, vs) atılır. Bu işlemin ardından yüzün 3boyutlu gösterimi elde edilir. Bu elde edilen görüntü tanıma işlemi için kullanılmaktadır.
Bayesian Framework Bayes teoremine dayanan ve olasılıksal benzerlikleri ölçen bir yöntemdir. Bu yönteme göre iki çeşit yüz görüntüsü varyasyonu vardır: intrapersonal (kişinin içinde gelişen) ve extrapersonal (kişinin dışında gelişen). Yüzler arasındaki benzerlik Bayesian kuralına göre ölçülmektedir.

SVM (Support Vector Machine) yöntemi verilen noktaları destek vektörleri ile ifade eder ve aynı sınıfa ait noktaları bir bölümde tutacak bir hiperbol çizmeye çalışır. PCA yöntemiyle özellik çıkarımı yapıldıktan sonra SVM yöntemiyle görüntü ikilieri arasındaki farklar araştırılır. Yani veri tabanındaki görüntülere ait vektörler ile alınan örnek vektörleri karşılaştırılır.  SVM yöntemiyle resimde işaretlenen belirli noktaların takibi de yapılabilir. Kamera karşısında bulunan bir insanın yüzünü göz-ağız gibi bölgelere ayırarak bunların takibini yapan SVM yöntemiyle insanın ruh halini gösteren bir videoyu izleyebilirsiniz.

HMM (Hidden Markov Models) bir istatsitiksel model olup bir işareti karakterize etmek için kullanılır. HMM işlemi bilinmeyen parametreleri gözlenebilir parametreler ile elde etmeye yardımcı olur. Ortaya çıkarılan model parametreler ‘doku eşleştirme’ – ‘pattern matching’ için kullanılır. HMM yöntemi Bayesian ağı yönteminin basit bir hali olarakta nitelendirilebilir.

Avantajları:

• İnsan yüzlerinin tek yumurta ikizleri haricinde birbirnden tamamen farklıdır.
• Parmak izindeki kadar kolay taklit edilemeyecek özellikleri barındırırır. Bundan dolayı taklit edilmesi oldukça zor bir tanıma yöntemidir.
• Örnek alma işleminin sadece bir kamera ile kolaylıkla yapılabilinir.

Dezavantajları:

• Uygulanması diğer yöntemlere göre oldukça zordur.
• Çevre koşullarından çok fazla etkilenmesi.
• Kişilerin yüzündeki ufak mimiklerden bile tanımanın yanlış sonuçlar verebilme ihtimali vardır.
• Yüzde oluşacak bir yara ve hasarın tanımayı olumsuz etkilemesi söz konusudur.

iii.    İris Tanıma

Tarihçe:
1936 yılında Frank Burch isimli göz doktoru bir bireyi tanımak için iris desenlerinin kullanılabileceği fikrini öne sürdü. 1985 yılında Dr. Leonard Flom ve Dr. Aran Safir tüm irislerin eşsiz olduğunu ispatlayarak 1987 iris tanıma ile ilgili patentlerini aldılar. Dr. Flom, Dr. John Daugman’dan iris tanımayı otomatik hale getirecek bir algoritma geliştirmesini istemiştir. 1993 yılında ABD’de Defense Nuclear Agecny bu işlemi yapacak bir prototip üstünde çalışmalara başlamıştır. 1995 yılında tamamlanan sistem Dr. Daugman’a bu dalda bir patent kazandırmıştır. 1995 yılında otomatik iris tanıma yapabilen cihazlar piyasaya çıkmaya başlamıştır.

Özellikleri:

İris tanıma sistemleri yüz ve parmak tanımada olduğu gibi özel noktaların çıkarılmasıyla yapılamamaktadır. Daha çok ‘pattern recognition’ olarak bilinen doku arama yöntemiyle yapılır.

İris tanımada ilk adım göz resminden iris bölgesinin bulunmasıdır. Bunun için iris şeklinden yararlanılabilineceği gibi göz bebeğinin siyah renginden de yararlanılıp histogramdan da bu bölge çıkarılabilir. Ayrıca sobel kenar algılama algoritması ile kenarlar bulunup ‘circle detection’ algoritmalarıyla da göz bebeği ve iris bulunabilir. Göz kapağının tamamen açık olmadığı durumlarla da karşılaşılabileceği için önce göz bebeği ardından irisin bulunması daha iyi sonuçlar vercektir.

İris bölgesi seçildikten sonra bu bölge üzerinden dokuya dayalı olarak özellik çıkarma işlemleri yapılır. Bu özellik çıkarma ve karşılaştırma işlemininde birden fazla yolu bulunmaktadır.

Bu yöntemlerden biri göz bebeğinin etrafından alınan parçalar üzerinde işlem yapmaktır. Tüm iris üzerinde işlem yapılmamasının bir diğer sebebi ise göz kapağının yarı kapalı olması ve kirpiklerin irisi örtmesidir. İris üzerinden göz bebeğine bitişik yerlerden belirli sayıda parça alınarak bu karşılaştırma yapılabilir.

Yukarıdaki şekilde olduğu gibi göz bebeğinin sağından solundan ve altından belirli sabit büyüklükte parçalar alınır. Bu parçaların büyüklüğünün her zaman eşit olduğuğunu garanti altına almak için örnek olarak alınan görüntülerin boyutları sabit olmalıdır. İşleme başlamadan önce resmi tekrar boyutlandırmak gerekebilir. Görüntüden örnek olarak alınan bu üç parça birleştirilerek bu üçlü parçaya ait co-occurance matrisi oluşturulur.

Belli bir yönde ‘d’, belli bir mesafede ‘a’ belirlenen gri seviye değerleriyle iki pikselin resim üzerinde hangi sıklıkta bulunduğunu belirten matrise co-occurance matris denir. Herhangi d ve a değerleri kullanılabilir, bu değerlerin seçimi bir kurala tabi değildir.

Yönü belirten açı değeri 0; I, gri seviyeye sahip resmimizde mesafeyi ‘a’ olarak alırsak ; co-occurance matris de p ile simgelensin, i = I (x,y) , j = I (x+a,y) => p (i,j) değeri bir arttırılır. Bu işlem resmin tamamına uygulanır ve sonuçta co-occurance matris oluşturulmuş olur.

Bu matris oluşturulduktan sonra yapay sinir ağlarını eğitmekte kullanılır. Daha sonra alınan örnekler üzerinde de aynı işlem yapıldıktan sonra YSA ile sınıflandırma yapılarak eşleştirme sonucu elde edilir.

Avantajları:

• İris parmak veya yüz gibi vücud dışında olan bir organ olmadığından dolayı zarar görme olasılığı daha düşüktür.
• Parmak izi gibi yöntemlerde örnek alınırken fiziksel olarak temas olduğundan dolayı örnek alma sırasında yanlış veriler alınabilir. İris örneği alınırken ~10cm mesafeden bir resim çekilmesi yeterlidir.
• Tek yumurta ikizlerinde bile iris yapıları farklıdır. Yani iris dokusu tamamen kişiye özel bir yapıdadır.
• Doğumdan sonra oluşan iris dokusu dışardan bir etki gelmediği sürece ölene kadar değişmez.
• Göz, insanın ölümünden sonra en kısa sürede değişime uğrayan organlardan biridir.

Dezavantajları:

• Tanımanın yapılabilmesi için çekilen resmin çözünürlüğünün ve kalitesinin çok iyi olması gerekir.  Aksi halde beklenen sonuçlar elde edilmeyebilir.
• Yüksek çözünürlüklü iris resimleri ve üzerine iris deseni basılmış lensler ile varolan sistemleri aşmak mümkün olabilir.

iv.    Retina Tanıma

Retina tanıma işlemi insanın göz bebeği arkasındaki damar tabakanın tanınmasıdır. Bu bölgedeki damarlar kişiden kişiye değişmesine rağmen damar ve göz hastalıklarından (ör:diabet) damarların etkilenmesi söz konusu olduğundan pek yaygınlaşmış bir yöntem değildir. Ayrıca örnek alma sırasında kişinin belirli bir noktaya bakması da bu işlemi zorlaştırmakta ve yöntemin az tercih edilmesine yol açmıştır.

Retina resmi çekildikten sonra elde edilen görüntüde eşikleme yapılarak damar görüntüsü elde edilir. Bu eşikleme işlemi için gerekli olan değer dinamik olarak (genellikle otsu algoritmasıyla) elde edilir. Daha iyi sonuç almak için eşikleme işlemi ardışıl olarak yapılır ve birden çok eşik değeri alınarak adım adım damar görüntüsü elde edilir. Ortaya çıkan son görüntü üzerinde özellik çıkarma işlemleri yapılır. Buradan sonraki işlemler parmak izindeki yöntemlere benzemektedir.

v.    Damar Tanııma

Damar tanıma retina tanıma ile aynı algoritma ile çalışır. Ancak bu yöntemde örnekler göz arkasında bulunan damarlar yerine el üzerinde ki damarlardır.  Bu yöntemde de el resmi çekildikten sonra damar yapısı ortaya çıkarılır ve tanıma işlemi retina yönteminde olduğu gibi yapılır. Elde bulundan damarlarda kişiye özgü olduğundan dolayı geçerliliği olan bir yöntemdir. Ayrıca retina yönteminin aksine elden örnek resim alması daha kolay olmaktadır. Buna rağmen fiziksel olarak değişime ve deformasyona açık olan bir bölge olan el üstünde yara vs gibi değişimler olduğu zaman tanıma işlemi olumsuz sonuç vermektedir.

vi.    El Yazısı Tanıma

El yazısı tanıma işlemi ilk bakışta kesin bir sonuç vermeyeceği düşüncesi uyandırmasına rağmen tanıma işlemini başarıyla gerçekleştirmektedir. Kişilerin el yazısında kullandıları harflerin biçimleri birbirinden farklılık göstermesinin yanı sıra bu harfleri oluşturma biçimleri de dikkate alınır ve yöntemin başarı oranı arttırılır.  Harfleri oluşturma sırası, noktaları ve çizgileri çizme sırası da dikkate alınabilecek bir takım özelliklerdendir.

Varolan bir yazıdan tanıma yapılırsa birçok özellik kaybolabilir ve taklidi muhtemel bir hale gelir. Bundan dolayı yazı yazılırken yapılan tespit hem daha doğru sonuçlar verir hemde güvenliği artırır.

Diğer tanıma yöntemlerinde örneğin alındığı cihazın (ör:kamera) sadece o iş için üretilmemiş olması yani başka amaçlarda da kullanılmasının yanı sıra el yazsını tanımak için kullanılan cihazlar bu amaca özel hizmet eden cihazlardır. Bundan dolayı maliyeti diğer yöntemlerde kullanılan cihazlara göre daha fazla olabilir.

Biyometrinin Geleceği

Yakın gelecekte biyometrik kimliklerimiz bizleri yanımızda taşıdığımız kimliklerden, şifrelerden, kartlardan tamamen kurtaracaktır. Günlük hayatta birçok işlemimizi bu yöntemlerle yapabileceğiz. Örneğin kredi kartı kullanılmaya başladıktan sonra insanlar nakit para taşımak yerine bu kartları taşımaya başladılar. Daha sonraları ise kartların çalınmasıyla gerek bankalar gerek kullanıcılar birçok sorunla karşılaştılar. Eğer biyometrik tanıma yöntemleri bu alanda kullanılırsa alışveriş sonrası kasada sadece parmağımızı yada bakışımızı (iris- retina vs ) kullanarak paramızı ödeyebileceğiz.

Bu tip sistemler insanların tamamen kayıt altına aldığı için bu tip verilerin saklandığı veritabanlarının güvenliği en üst düzeyde olmalıdır. Ayırca sahte kimlik veya kredi kartı gibi olayların da önüne geçilmesi için mükemmele yakın bir çözüm üretmektedir. Yeterince yaygın kullanıma eriştiği zaman suç oranında etkisi hissedilir şekilde düşüşler yaşanacağı kesindir.

Görüntü işleme ile ilgili temel bilgileri biliyorsunuz farzederek bu yazıyı yazıyorum. Zira işin hikaye kısmını yazması biraz zor oluyor diyerekten konuya geçelim.

Görüntü işleme sırasında image veya bitmap nesneleri üzerinde işlem yapmak yerine dizileri kullanıyorum ondan dolayı aşağıdaki kodlarda da bütün işlemler diziler üzerinde olacak. Kullandığım birçok fonksiyon pointer kullanarak çalışıyor. C# ile nasıl pointer kullanacağınızı bilmiyorsanız şurada bulunan yazımı okuyabilirsiniz.

Öncelikle picturebox nesnesinden diziye dönüşüm işlemini yapan fonksiyonu verelim:

int[,] pixelArray = new int[pictureBox1.Image.Height, pictureBox1.Image.Width];
int[,] greyPixelArray = new int[pictureBox1.Image.Height, pictureBox1.Image.Width];

private void BuildPixelArray(Image myImage)
{
Rectangle rect = new Rectangle(0, 0, myImage.Width, myImage.Height);
Bitmap temp = new Bitmap(myImage);
BitmapData bmpData = temp.LockBits(rect, ImageLockMode.ReadWrite, PixelFormat.Format24bppRgb);
int remain = bmpData.Stride - bmpData.Width * 3;
unsafe
{
byte* ptr = (byte*)bmpData.Scan0;
for (int i = 0; i < bmpData.Height; i++)
{
for (int j = 0; j < bmpData.Width; j++)
{
pixelArray[i, j] = ptr[0] + ptr[1] * 255 + ptr[2] * 255 * 255;
greyPixelArray[i, j] = (int)((double)ptr[0] * 0.11 + (double)ptr[1] * 0.59 + (double)ptr[2] * 0.3);
ptr += 3;
}
ptr += remain;
}
}
temp.UnlockBits(bmpData);
}

Bu fonksiyon sayesinde picturebox nesnesindeki görüntüyü pixelArray dizisine taşıyoruz. Aynı fonksiyonda greyPixelArray dizisi ile tutulan griseviye görüntü de oluşturuluyor.

Dizideki görüntüyü form üzerinde bulunan bir picturebox nesnesine aktarmak için aşağıdaki fonksiyonu kullanabilirsiniz.

private void SetImage(int[,] sourceArray, ref PictureBox myPictureBox)
{
Rectangle rect = new Rectangle(0, 0, myPictureBox.Image.Width, myPictureBox.Image.Height);
Bitmap temp = new Bitmap(myPictureBox.Image);
BitmapData bmpData = temp.LockBits(rect, ImageLockMode.ReadWrite, PixelFormat.Format24bppRgb);
int remain = bmpData.Stride - bmpData.Width * 3;
unsafe
{
byte* ptr = (byte*)bmpData.Scan0;
for (int i = 0; i < bmpData.Height; i++)
{
for (int j = 0; j < bmpData.Width; j++)
{
ptr[0] = ptr[1] = ptr[2] = (byte)sourceArray[i, j];
ptr += 3;
}
ptr += remain;
}
}
temp.UnlockBits(bmpData);
myPictureBox.Image = temp;
}

Üstteki fonksiyon aldığı diziyi gri seviye olarak değerlendiriyor. Eğer renkli bir görüntünüz varsa bir aşağıdaki fonksiyonu kullanabilirsiniz

public void SetColorImage(ref int[,] sourceArray)
{
Rectangle rect = new Rectangle(0, 0, sourceArray.GetLength(0), sourceArray.GetLength(1));
Bitmap temp = new Bitmap(sourceArray.GetLength(0), sourceArray.GetLength(1));
BitmapData bmpData = temp.LockBits(rect, ImageLockMode.ReadWrite, PixelFormat.Format24bppRgb);
int remain = bmpData.Stride - bmpData.Width * 3;
unsafe
{
byte* ptr = (byte*)bmpData.Scan0;
for (int i = 0; i < bmpData.Width; i++)
{
for (int j = 0; j < bmpData.Height; j++)
{
ptr[0] = (byte)(sourceArray[i, j]%256);
ptr[1] = (byte)((sourceArray[i, j]/256)%256);
ptr[2] = (byte)((sourceArray[i, j]/65536)%256);
ptr += 3;
}
ptr += remain;
}
}
temp.UnlockBits(bmpData);
destPictBox.Image = temp;
}

Görüntüyü yeniden boyutlandırmak için aşağıdaki fonksiyonu kullanabilirsiniz. ConstWidth değişkenine istediğiniz değeri vererek işlem sonucundaki görüntünün enini ayarlayabilirsiniz. Ben tüm görüntüleri standart boyuta getirmek için böyle bir yol kullanmıştım. Fonksiyonun çalışmasını kolaylıkla anlayabilir ve istediğiniz en-boy değiştirme işlemini kolayca yapabilirsiniz.

private void ResizeImage(ref Image myImage)
{
float nPercent = ((float)constWidth / myImage.Width);
int sourceWidth = myImage.Width;
int sourceHeight = myImage.Height;
int sourceX = 0;
int sourceY = 0;

int destX = 0;
int destY = 0;
int destWidth = (int)(sourceWidth * nPercent);
int destHeight = (int)(sourceHeight * nPercent);

Bitmap bmPhoto = new Bitmap(destWidth, destHeight, PixelFormat.Format24bppRgb);
bmPhoto.SetResolution(myImage.HorizontalResolution, myImage.VerticalResolution);

Graphics grPhoto = Graphics.FromImage(bmPhoto);
grPhoto.DrawImage(myImage,
new Rectangle(destX, destY, destWidth, destHeight),
new Rectangle(sourceX, sourceY, sourceWidth, sourceHeight),
GraphicsUnit.Pixel);
myImage = bmPhoto;
grPhoto.Dispose();
}

Kenar algılama, gürültü yok etme ve yapısal (morfolojik) filtreleri de bir sonraki yazımda paylaşmak üzere. İyi işlemeler diliyorum :)