What are the optimal parameters for developing a pattern detector?

Pertanyaan itu membuka pagi saya hari ini. Asal-muasal pertanyaan itu muncul dari sebuah pertanyaan pada milis opencv perihal seberapa banyak dan seberapa variatif sampel positif dan negatif yang harus dikumpulkan untuk membuat suatu sistem pendeteksi objek visual secara umum. Hal ini cukup memancing rasa penasaran. Pertama persoalan deteksi merupakan persoalan pengenalan pola (pattern recognition) yang paling sederhana dan batasannya paling longgar jika dibandingkan dengan segmentasi (deteksi batas pola) dan klasifikasi/pengenalan banyak-objek ataupun banyak-kategori/kelas. Persoalan deteksi outputnya biner, yakni hanya ada dua jawaban: ya(ada) atau tidak jika diberikan suatu pola masukan. Sebagai contoh, mata kita sangat sensitif mendeteksi pola wajah. Bahkan mungkin untuk pola yang bukan wajah tapi tampak seperti wajah pun masih dapat dideteksi secara objektif, bukan hanya halusinasi satu orang saja.

Strategi yang umumnya sekarang ini diambil dalam membuat sistem detektor adalah menggunakan teknik pembelajaran mesin (machine learning) yang menggunakan metode statistik untuk menganalisis data menjadi sebuah model untuk melakukan pekerjaan deteksi pola tersebut. Langkah-langkah yang umumnya dilakukan adalah mempersiapkan kumpulan data berisi contoh-contoh pola baik dengan tambahan label sebagai pola acuan yang dibuat oleh manusia maupun tanpa label tetapi pada pengujian hanya diberikan umpan balik apakah kinerja pendeteksiannya lebih baik atau lebih buruk. Cara pertama disebut dengan supervised learning dan cara kedua disebut reinforcement learning.

Adapun panduan untuk mengumpulkan data contoh pada umumnya tidak secara gamblang menjelaskan sampai kondisi apa sebuah koleksi data dikatakan cukup membuat suatu sistem yang berbasis pembelajaran mesin. informasi yang ada hanyalah banyaknya data yang dikumpulkan haruslah cukup banyak. Salah satu metode untuk melakukan justifikasi ini biasanya menggunakan metode statistik. Pada asumsi populasi yang berdistribusi normal secara parametrik, maka generalisasi dilakukan dengan menggunakan limit hampiran (cek teorema limit tengah) lalu sensitivitas detektor sebagai sistem yang dibuat diuji berdasarkan kinerjanya yaitu akurasi dan kemampuan generalisasi berdasarkan jumlah data tadi. Jika diperhatikan, kedua hal ini mirip dengan analogi ayam-telur yakni mana yang duluan? *karena ayam ditulis lebih dulu maka jawabannya jelas ayam*

Persoalan kecukupan data ini tidak hanya terjadi pada sistem yang dibangun dengan metode statistik. Sistem yang dibangun dengan pengembangan pengetahuan heuristik yang diekstrak dari pakar (expert knowledge engineering) pun mengalami persoalan yang sama yaitu seberapa banyak yang dikatakan cukup. Lebih umum lagi seberapa banyak yang diperlukan jika juga mempertimbangkan karakteristik atau sifat dari pola masukan.

Seperti yang dicoba dilakukan oleh para peneliti di bidang teori pola yang berangkat dari teori informasi dan klasifikasi tipe data pada analisis data (statistik), Suatu data atau informasi dapat didekomposisi berdasarkan sifat-sifat intrinsiknya. Sebagai acuan, para matematikawan (khususnya para ahli aljabar) membuat generalisasi yang disebut dengan bilangan tidak hanya pada angka-angka yang selama ini kita kenal melainkan melihat pada struktur aljabar yang terdiri atas objek dan operasi elementer yang dapat diekstrak relasinya terhadap elemen lain dalam suatu himpunan. Hal ini lalu menjadi basis eksplorasi praktis yaitu untuk analisis data, dan hingga pada waktunya yaitu masa kini kita sudah terbiasa dengan melakukan pengenalan pola dalam berbagai wujud bahkan tidak hanya melakukan pengenalan atau analisis tetapi juga sintesis pola yang dimungkinkan dengan adanya teknologi yang mengamplifikasi kemampuan berpikir manusia yaitu komputer.

Kalau pekerjaan mendeteksi pola ini dilihat dalam kacamata yang lebih luas yaitu bagaimana sistem yang sudah ada (manusia) bekerja, maka mungkin kita akan mendapatkan penjelasan yang lebih baik. Persoalan persepsi merupakan kajian multi-disiplin mulai dari disiplin ilmu kimia yang menjelaskan tentang sifat material. Disiplin ilmu fisika yang menjelaskan bagaimana fenomena-fenomena interaksi antar benda. Disiplin ilmu biologi yang menjelaskan bagaimana organ-organ tubuh manusia bekerja dalam sistem indera dan syaraf. Disiplin ilmu psikologi yang mengkaji bagaimana pikiran sebagai bagian dari jiwa (psyche) bekerja secara fungsional. Hingga disiplin matematika yang membuat formulasi bagaimana pola dianggap sebagai sebuah ‘bilangan’ dapat dimanipulasi lewat relasi-relasi dan Informatika dan Rekayasa yang mensimulasikan proses mental yang diperlukan untuk memroses pola yang dikerjakan oleh mesin (komputer).

Kembali ke bahasan awal, jika kita akan membangun suatu koleksi data sebagai bagian dari pengembangan sistem pendeteksi pola maka untuk mendapatkan banyaknya data yang dikatakan ‘cukup’ maka beberapa hal harus dipertimbangkan :

1. material dari objek
2. proses transmisi informasi objek ke sensor (misal objek berinteraksi dengan cahaya ke mata)
3. proses persepsi yang terjadi pada indera
4. model abstraksi pola dari informasi yang terlibat pada 1, 2, 3

Seharusnya metode untuk melakukan pengenalan dimasukkan jika yang ingin dibuat adalah sistem pendeteksinya. Namun karena pertanyaannya dibatasi pada banyaknya data contoh yang dikatakan cukup, maka metode dihilangkan dari daftar tersebut.

Material objek fisik menentukan seberapa besar ruang kombinatorial pola yang terjadi secara internal objek. Transmisi informasi dan persepsi merupakan proses yang memetakan informasi dari ruang kombinasi pola ke ruang kombinasi pola yang lain. Pada tiap proses pemetaan ada faktor eksternal yang terlibat. Kadang dianggap sebagai gangguan, kadang dianggap sebagai dukungan. Suatu proses dapat dianggap sebagai gangguan jika proses tersebut membuat batasan antara informasi yang satu dengan informasi lainnya pada suatu ruang menjadi semakin sulit dibedakan ataupun adanya penambahan informasi yang tidak relevan. Sebaliknya, suatu proses dianggap sebagai dukungan jika informasi akhir menjadi lebih sederhana dan batasan pembedaan objek menjadi lebih mudah diketahui.

Informasi pada asal dan transformasi yang terjadi pada proses direpresentasikan dengan model abstraksi yang dibuat oleh para matematikawan (objek-objek aljabar seperti bilangan, vektor, graf, dllsb). Bila hal-hal tersebut disederhanakan, maka suatu populasi kombinasi pola yang mungkin ditentukan dari sifat dari objek sumber dan proses-proses transformasi yang terjadi.

Jika kita kembali pada bahasan tentang statistik, maka ada kajian tentang sampling. Proses pengumpulan informasi berupa koleksi contoh untuk membuat sistem pendeteksi pola pada dasarnya adalah proses sampling. Ada banyak metode untuk melakukan sampling. Masing-masing metode dirancang pada umumnya untuk mengurangi bias dan faktor yang dapat meningkatkan risiko validitas suatu kesimpulan yang dibuat dengan menggunakan metode statistik.

Begitu pula dengan pengembangan koleksi data contoh. Pengumpulan data contoh seharusnya tidak hanya menggunakan asumsi banyaknya data, tetapi juga mempertimbangkan karakteristik dari data yang meminimumkan bias-bias yang terjadi pada proses sampling. Dengan demikian, basis data yang dikumpulkan dapat menjadi acuan pengambilan keputusan yang pada akhirnya membantu memilih dan mengembangkan metode-metode pengambilan kesimpulan (dalam hal ini detektor pola) yang berkinerja baik.

Sepertinya tulisan ini sudah semakin dan terlalu panjang. Oleh sebab itu saya akan akhiri sampai sini saja. Beberapa hal yang perlu dibahas selanjutnya antara lain : metode-metode sampling, macam-macam representasi/model pola, hingga akhirnya apa saja metode-metode atau algoritma untuk melakukan klasifikasi data dalam rangka mengembangkan ‘the ultimate pattern detector’.

Whoosh is a fast, featureful full-text indexing and searching library
implemented in pure Python. Programmers can use it to easily add search
functionality to their applications and websites. Every part of how Whoosh
works can be extended or replaced to meet your needs exactly.

Whoosh bisa diunduh di situs pypi atau di repositori di bitbucket (Mercurial). Setelah dipasang, whoosh bisa digunakan dengan kode pendek berikut

from whoosh.index import create_in, open_dir
from whoosh.fields import *

Hal pertama yang perlu dilakukan sebelum mengindeks dokumen adalah membuat schema. Schema digunakan untuk mendefinisikan struktur indeks yang akan disimpan oleh Whoosh. Skema sederhana berikut bisa dijadikan contoh. Pilihan stored menyatakan bahwa elemen ini akan dikembalikan dalam hasil pencarian.

schema = Schema(title=TEXT(stored=True), path=TEXT(stored=True), content=TEXT)

Setelah skema indeks didefinisikan langkah selanjutnya adalah membuat indeks. Whoosh menggunakan indeks yang disimpan pada filesystem (Whoosh tidak menggunakan database umum). Fungsi create_in disediakan sebagai jalan pintas dari membuat objek file indeks.

_ix = create_in('indexdir', schema)
w = _ix.writer()

#telusuri direktori untuk mencari file teks
for root, dirnames, filenames in os.walk('data'):
    for filename in fnmatch.filter(filenames, '*.txt'):
        doc = os.path.join(root, filename)
        f = open(doc)
        text = f.read()
        w.add_document(title=unicode(filename[:-4]), content=unicode(text), path=unicode(doc))
        f.close()

    w.commit()

Pada kasus di atas, saya memberi nama file sesuai dengan judulnya. Proses di atas terdiri dari 3 langkah yaitu :

1. memanggil objek IndexWriter
2. menambahkan item/dokumen
3. melakukan commit

Jika ada dokumen baru yang ingin ditambahkan maka pola di atas juga dapat langsung digunakan tapi tidak perlu lagi melakukan pembuatan indeks melalui create_in. Jika direktori indeks sudah dibuat maka objek Index dapat dipanggil dengan fungsi open_dir.

_ix = open_dir('indexdir')

Untuk melakukan Pencarian dari indeks, dapat menggunakan objek IndexSearcher yang dipanggil dari objek indeks menggunakan

    s = _ix.searcher()
    q = QueryParser('content', _ix.schema).parse(unicode(qs))
    r = s.search(q)
    for rr in r:
        print rr
    s.close()

Nah! cukup begitu saja untuk menambahkan hasil pencarian. Pembuatan indeks pun dilakukan dengan cepat.

Di awal-awal mencoba dengan hanya bermodalkan google, sempat seringkali gagal compile. kegagalan pertama, scipy.weave akan mencari compiler MS Visual C++ sehingga saya harus memaksa untuk menggunakan gcc. Kesalahan berikutnya adalah gagal compile. Perjuangan masih berlanjut ketika kode sudah berhasil dikompilasi, tetapi Image tidak berubah padahal di dalam kode inline nilainya sudah berubah. Hal lain yang perlu dicatat adalah saya mulai menggunakan interface opencv versi 2 (cv2) yang sudah terintegrasi dengan numpy karena untuk melakukan manipulasi piksel dengan menggunakan scipy.weave lebih memudahkan untuk menggunakan representasi numpy.array dibandingkan dengan IplImage (ya iyalah, scipy kan pake numpy).

OK, Pembahasan akan saya mulai dengan penggunaan fungsi inline dari scipy.weave. Perhatikan kode berikut:

import cv, cv2
import numpy as np
from scipy.weave import inline

MASK = np.array([[0,-1],[1,-1],[1,0],[1,1],[0,1],[-1,-1],[-1,0],[-1,1]])
def calc_lbp(src, dst):
    code = r"""
        for (int y=1; y<Nsrc[0]-1; ++y){
            for (int x=1; x<Nsrc[1]-1; ++x){
                unsigned char px = SRC2(y,x);
                unsigned char n = 0;
                for(int m=0; m<8; ++m) 
                    if(SRC2(y+MASK2(m,1),x+MASK2(m,0))>px) 
                        n |= 1 << m;
                DST2(y,x) = n;
            }
        }
    """
    inline(code, ['src','dst','MASK'], compiler='gcc')
    return dst

parameter src dan dst merupakan objek numpy.array. kode ditulis dalam string, lalu beberapa variabel ditransfer ke dalam kode C++ yang akan digenerate dan dikompilasi pada saat pertama kali dipanggil lalu disimpan dalam disk cache sehingga jika dilakukan pemanggilan berikutnya yang dijalankan adalah kode yang sudah terkompilasi (baca: jauh lebih cepat!). Pada kode tersebut saya tidak mentransfer dimensi dari array src dan dst karena pada saat pembangkitan kode C++, scipy.weave akan membuat variabel-variabel yang memudahkan mengakses data dari objek numpy.array diantaranya N{nama-variabel-array} yaitu array yang berisi banyaknya elemen tiap dimensi array, D{nama-variabel-array} yang berupa nilai integer yang menyatakan dimensi array tersebut. Pada contoh kode di atas, variabel Nsrc merupakan variabel yang disediakan untuk mengakses banyaknya elemen pada tiap dimensi array src (misal untuk array 2 dimensi row-wise, Nsrc[0] untuk banyaknya baris dan Nsrc[1] menunjukkan banyaknya kolom, Dsrc bernilai 2). Untuk mengakses elemen dari array (get/set) disediakan MACRO-MACRO tambahan dengan format {nama-variabel-array-uppercase}{dimensi}({indeks}). Pada kode di atas, array src dan dst berdimensi 2 sehingga untuk mengakses elemennya menggunakan SRC2(i,j) dan DST2(i,j). Kalau src adalah array berdimensi satu maka elemennya diakses menggunakan MACRO SRC1(i). kalau parameter compiler tidak diisi maka compiler yang digunakan dalam lingkungan windows adalah MSVC.

Kode sisanya adalah membaca berkas video, dan menampilkan hasil eksekusi fungsi lbp di atas ke dalam windownya sendiri.

#...lanjutan kode di atas

filename = r"tol2.avi"
cap = cv2.VideoCapture(filename)
if not cap.isOpened(): 
    print "capture failed"
    exit()
f, im = cap.read()
gr = cv2.cvtColor(im, cv.CV_BGR2GRAY)
lbp = cv2.cvtColor(im, cv.CV_BGR2GRAY)

calc_lbp(gr, lbp) #panggilan pertama agak lambat karena harus memanggil kompilator gcc

while True:
    f, im = cap.read()
    if not f:
        cap = cv2.VideoCapture(filename)
        f, im = cap.read()
    cv2.cvtColor(im, cv.CV_BGR2GRAY, gr)
    
    calc_lbp(gr, lbp) #pemanggilan berikutnya jauh lebih cepat (menjalankan ekstensi native)
  
    cv2.imshow("lbp", lbp)
    cv2.imshow("img", im)
    cv2.imshow("gr", gr)
    
    key = cv2.waitKey(1)
    if key == 27:
        break

istilah biner berasal dari representasi kenisbian intensitas piksel tetangga terhadap piksel yang sedang diproses. LBP dihitung dengan mengasosiasikan sejumlah ketetanggaan dengan bit-bit pada angka. Misalkan, untuk area ketetanggaan 3×3 piksel maka piksel yang ada di tengah akan memiliki tetangga sebanyak 8 piksel. Suatu posisi bit akan bernilai 1 jika intensitas piksel tetangga lebih besar daripada piksel yang sedang diproses (piksel tengah). Setiap piksel tetangga diasosiasikan dengan satu posisi bit sehingga untuk ketetanggan 3×3 (8 tetangga) tersebut maka setiap piksel yang diproses akan memiliki variasi tetangga sebanyak 2^8 = 255 kombinasi.

Implementasi algoritma menghitung fitur LBP diperlihatkan pada kode (python) berikut.

import cv

def calc_lbp(im):
    """
    calculate LBP (Local Binary Pattern) image N8 neighborhood
    """
    sz = cv.GetSize(im)
    gr = cv.CreateImage(sz, 8, 1)
    lbp = cv.CreateImage(sz, 8, 1)
    
    #convert to grayscale
    cv.CvtColor(im, gr, cv.CV_BGR2GRAY)

    LBPMASK = [(0,-1),(1,-1),(1,0),(1,1),(0,1),(-1,-1),(-1,0),(-1,1)]
    
    for y in xrange(1, sz[1]-2):
        for x in xrange(1, sz[0]-2):
            n = 0
            gv = gr[y,x]
            for i in xrange(len(LBPMASK)):
                m = LBPMASK[i]
                if gr[y+m[1], x+m[0]]>gv:
                    n += 1 << i
            lbp[y,x] = n
            
    return lbp

if __name__ == '__main__':
    im = cv.LoadImage('jalan2.jpg')

    lbpim = calc_lbp(im)
    cv.ShowImage('lbp', lbpim)

    key = cv.WaitKey(0)

Untuk menunjukkan efek dari kode di atas, saya akan menggunakan gambar yang sama dengan tulisan sebelumnya.

citra asal

ekstraksi fitur LBP

Dalam beberapa paper yang saya baca, fitur LBP ini dikombinasikan dengan fitur HOG untuk menghasilkan sistem pendeteksi yang lebih akurat. Pemrosesan lebih lanjut dengan PCA dilakukan untuk mereduksi dimensi vektor yang perlu diproses untuk membandingkan dan ternyata (di paper yang saya baca) melaporkan bahwa hasil pendeteksiannya menjadi lebih akurat. Mari kita buktikan apakah laporan itu benar atau tidak. tunggu tulisan selanjutnya!

Curhatnya saya hentikan sampai sini saja. Ceritera mengenai pengalaman saya dalam menjalani aktivitas sebagai dosen saya tuliskan di blog kampus. tulisan-tulisan di sini akan tetap saya fokuskan pada hasil utak-atik (terutama kode proof-of-concept) dalam mempelajari topik-topik dalam dunia informatika.

Kali ini saya sedang iseng membuat implementasi dari HOG (Histogram of Oriented Gradients). Fitur ini dikaji secara lebih dalam oleh Navneet Dalal dan Bill Triggs dari INRIA, Perancis untuk mendeteksi pejalan kaki (pedestrian) pada citra di tahun 2005. Sama seperti deskriptor yang digunakan pada SIFT (Scale Invariant Feature Transform *eh, saya belum membahas SIFT ya?*), informasi vektor gradien disimpan dalam koordinat polar (panjang dan arah).

Walaupun HOG *katanya* sudah ada di OpenCV tapi di dokumentasi python sepertinya belum ditambahkan. Python ini sedikit dianaktirikan di OpenCV, saya baru bisa menikmati fasilitas SVM di python di versi 2.3 (dengan python 2.6), karena OpenCV versi 2.2 untuk python hanya berisi modul untuk python versi 2.7. Akhirnya saya terpaksa membuat sendiri. Sebetulnya pembuatan HOG di OpenCV from scratch sudah pernah ditulis oleh Saurabh Goyal di sini. Apa yang saya buat mengadopsi dari yang sudah ditulis di sana (dengan modifikasi sesuka saya tentunya) terutama bagian penghitungan dengan memanfaatkan citra integral. Kode yang ditulis dengan python menurut saya jadi lebih sederhana dan (semoga) lebih mudah dibaca dan dipahami oleh pembaca (setia?) blog ini. Selamat menikmati

Mari kita buka bahasan kita dengan kode dalam python yang akan saya jelaskan setelahnya. Saya menggunakan dua modul yaitu cv(opencv) dan numpy (dengan alias np).

import cv
import numpy as np

def calc_hog(im,numorient=9):
    """
    calculate integral HOG (Histogram of Orientation Gradient) image (w,h,numorient)
    
    calc_hog(im, numorient=9)
    
    returns 
        Integral HOG image

    params 
        im : color image
        numorient : number of orientation bins, default is 9 (-4..4)
    
    """
    sz = cv.GetSize(im)
    gr = cv.CreateImage(sz, 8, 1)
    gx = cv.CreateImage(sz, 32, 1)
    gy = cv.CreateImage(sz, 32, 1)
    
    #convert to grayscale
    cv.CvtColor(im, gr, cv.CV_BGR2GRAY)
    
    #calc gradient using sobel
    cv.Sobel(gr, gx, 1, 0, 3)
    cv.Sobel(gr, gy, 0, 1, 3)
    
    #calc initial result
    hog = np.zeros((sz[1], sz[0], numorient))
    mid = numorient/2
    for y in xrange(0, sz[1]-1):
        for x in xrange(0, sz[0]-1):
            angle = int(round(mid*np.arctan2(gy[y,x], gx[y,x])/np.pi))+mid
            magnitude = np.sqrt(gx[y,x]*gx[y,x]+gy[y,x]*gy[y,x])
            hog[y,x,angle] += magnitude
            
            
    #build integral image
    for x in xrange(1, sz[0]-1):
        for ang in xrange(numorient):
            hog[y,x,ang] += hog[y,x-1,ang]
    for y in xrange(1, sz[1]-1):
        for ang in xrange(numorient):
            hog[y,x,ang] += hog[y-1,x,ang]
    for y in xrange(1, sz[1]-1):
        for x in xrange(1, sz[0]-1):
            for ang in xrange(numorient):
                #tambah kiri dan atas, kurangi dengan kiri-atas
                hog[y,x,ang] += hog[y-1,x,ang] + hog[y,x-1,ang] - hog[y-1,x-1,ang]
    return hog

beberapa langkah yang dilakukan dalam membuat citra hog integral a.l.:

• menghitung citra gradien dengan memanfaatkan operator sobel
• membuat citra histogram untuk menampung diskretisasi sudut/orientasi (sebanyak orientasi yang diperlukan, harus berjumlah ganjil), saya memanfaatkan array dari numpy.
• membuat citra integral terhadap setiap orientasi.

Pada contoh kode di atas, saya membuat array berdimensi 3 berukuran lebar citra x tinggi citra x banyaknya elemen orientasi yang diinginkan. banyaknya orientasi selalu ganjil supaya simetris dalam menskalakan perhitungan sudut orientasi (misal -n div 2,…,-1, 0, 1,…,n div 2). citra 3 dimensi ini juga bisa didekomposisi menjadi kumpulan citra sebanyak n yang masing-masing mewakili tiap sudut.

penggunaan citra integral akan memudahkan untuk membuat fitur HOG dalam berbagai skala resolusi karena kompleksitas komputasi untuk menghitung fitur HOG berukuran 8×8 piksel, 16×16 piksel, atau NxN berapapun N sama saja (2 penjumlahan dan 2 pengurangan). Hal ini akan sangat bermanfaat karena biasanya fitur HOG tidak digunakan dalam satu skala resolusi saja melainkan multi-skala. Implementasi Dalal dan Triggs menggunakan banyak skala sedangkan pengembangan oleh Pedro F. Felzenzswalb yang memenangkan perlombaan PASCAL VOC tahun 2009 menggunakan dua buah skala dan cakupan (root dan kumpulan part).

langkah selanjutnya adalah memanfaatkan citra HOG integral untuk menghitung fitur HOG.

def calc_hog_block(hogim, r):
    """
    calculate HOG feature given a rectangle and integral HOG image
    
    returns
        HOG feature (not normalized)

    params
        hogim : integral HOG image
        r : 4-tuple representing rect (left,top,right,bottom)
    """
    numorient = hogim.shape[2]
    result = np.zeros(numorient)
    for ang in xrange(numorient):
        result[ang] = hogim[r[1],r[0],ang] + hogim[r[3],r[2],ang] - hogim[r[1],r[2],ang] - hogim[r[3],r[0],ang]

    return result

Seperti terlihat pada kode di atas, berapapun dimensi area yang akan dihitung fitur HOG lokalnya kompleksitasnya konstan. Hasil histogram di atas tidak dinormalisasi melainkan diserahkan kepada kode yang menggunakan setelahnya. Hal ini disebabkan ada beberapa kombinasi norm yang dapat digunakan untuk menormalisasi vektor/histogram yang dihasilkan dari fungsi di atas.

Sebagai contoh pemanfaatan fitur HOG agar tulisannya tidak terlalu panjang, saya akan tampilkan bagaimana memvisualisasikan fitur HOG pada setiap area citra.

def draw_hog(target, ihog, cellsize=8):
    """
    visualize HOG features
    
    returns
        None
        
    params
        target  : target image
        ihog    : integral HOG image
        cellsize: size of HOG feature to be visualized (default 8x8)
        
    """
    ow,oh = cv.GetSize(target)
    halfcell = cellsize/2
    w,h = ow/cellsize,oh/cellsize
    norient = ihog.shape[2]
    mid = norient/2

    for y in xrange(h-1):
        for x in xrange(w-1):
            px,py=x*cellsize,y*cellsize
            #feat = calc_hog_block(ihog, (px,py,max(px+cellsize, ow-1),max(py+cellsize, oh-1)))
            feat = calc_hog_block(ihog, (px, py, px+cellsize, py+cellsize))
            px += halfcell
            py += halfcell
            
            #L1-norm, nice for visualization
            mag = np.sum(feat)
            maxv = np.max(feat)
            if mag > 1e-3:
                nfeat = feat/maxv
                N = norient
                fdraw = []
                for i in xrange(N):
                    angmax = nfeat.argmax()
                    valmax = nfeat[angmax]
                    x1 = int(round(valmax*halfcell*np.sin((angmax-mid)*np.pi/mid)))
                    y1 = int(round(valmax*halfcell*np.cos((angmax-mid)*np.pi/mid)))
                    gv = int(round(255*feat[angmax]/mag))
                    
                    #don't draw if less than a threshold
                    if gv < 30:
                        break
                    fdraw.insert(0, (x1,y1,gv))
                    nfeat[angmax] = 0.
                    
                #draw from smallest to highest gradient magnitude
                for i in xrange(len(fdraw)):
                    x1,y1,gv = fdraw[i]
                    cv.Line(target, (px-x1,py+y1), (px+x1,py-y1), cv.CV_RGB(gv, gv, gv), 1, 8)
            else:
                #don't draw if there's no reponse
                pass

cellsize adalah ukuran dari area yang dihitung untuk mendapatkan HOG lokal. Setiap histogram digambarkan sebagai garis yang orientasinya menyesuaikan. Ada sedikit perbedaan di sini yaitu arah kemiringan garis yang divisualisasikan bukan menggambarkan arah gradien melainkan diputar 90 derajat (tegak lurus) atau normal dari gradien. Hal ini dilakukan untuk memudahkan evaluasi secara visual karena garis yang digambar bersesuaian dengan puncak dari gradien di citra asal.

Contoh penggunaan fungsi-fungsi dan prosedur di atas ada pada kode berikut.

im = cv.LoadImage('gambar.jpg')

#image for visualization
vhog = cv.CreateImage(cv.GetSize(im), 8, 1)

hog = calc_hog(im)

draw_hog(vhog, hog, 8)
cv.ShowImage('hi', vhog)

#clear for reuse
cv.Set(vhog, 0)

draw_hog(vhog, hog, 16)
cv.ShowImage('lo', vhog)

key = cv.WaitKey(0)

Kekurangan dari kode di atas adalah, untuk menghitung citra HOG diperlukan waktu yang cukup lama yang mungkin disebabkan oleh overhead di python dan numpy. Karena saya masih bereksperimen dan belum berencana membuat aplikasi yang interaktif menggunakan HOG, Hal ini masih ditoleransi. Mungkin saya akan mempertimbangkan untuk menggunakan interface lain untuk memanfaatkan fitur HOG ini (C,C++,atau C#). Contoh hasil penghitungan dan visualisasi fitur HOG dapat dilihat pada gambar-gambar berikut.

citra asal

Tampilan fitur HOG dengan parameter area lokal 8x8 piksel

Tampilan fitur HOG dengan parameter area lokal 4x4 piksel

Sampai dengan kondisi di atas, saya masih ragu melakukan klasifikasi (misal mendeteksi objek mobil pada citra di atas) hanya dengan melihat visualisasinya saja tampak kurang diskriminatif. Sepertinya masih perlu dibuktikan apakah bisa melakukan deteksi objek hanya berdasarkan fitur HOG tersebut. Mari kita lanjutkan lain kali saja.

ralat

• untuk menampilkan gambarnya harusnya cos untuk y dan sin untuk x, dan tanda untuk y dinegasikan, gambar akan diupdate segera.

hasil visualisasi HOG 8x8 (yang benar)

visualisasi HOG 4x4 (yang benar)

jadi selama ini yang salah itu cara visualisasinya. Kalau begini saya jadi optimis mencoba menerapkan SVM untuk klasifikasi objek (mobil misalny). Mungkin juga mengasosiasikan model bagian dengan segmentation mask untuk digabung dengan grabcut (eh, ngebocorin kerjaan).

Saya menggunakan MRF untuk memodelkan proses binerisasi citra. Masukan proses ini diasumsikan adalah citra grayscale. Memodelkan proses binerisasi citra menggunakan MRF dimulai dengan membuat model energi potensial terhadap clique (subgraf yang merupakan graf komplit) pada graf. Citra dianggap sebagai graf berstruktur grid dengan tiap piksel sebagai simpul dan terhubung dengan piksel tetangganya (saya menggunakan ketetanggaan 4 untuk menghubungkan antar piksel). Setiap konfigurasi pelabelan piksel dapat dievaluasi energinya secara keseluruhan sebagai jumlah dari energi pada tiap piksel. Pelabelan/Pewarnaan piksel yang optimal dicapai bila energi yang berasosiasi dengan konfigurasi tersebut adalah minimal terhadap pelabelan lainnya.

Karena saya sudah akrab dengan model optimasi berbasis populasi seperti algoritma genetik, ant colony, atau particle swarm saya tadinya berniat mencari konfigurasi pelabelan dengan menggunakan teknik ini. Niat ini kemudian saya urungkan karena malas membayangkan memori dan waktu yang diperlukan untuk mencari konfigurasi yang optimal (kalau N adalah besar populasi, maka perlu N citra tambahan untuk algoritma genetik dan 2N untuk PSO). Akhirnya dengan berat hati saya paksakan diri untuk mempelajari teknik optimasi dengan menggunakan Gibbs sampler.

Energi ini bisa dianalogikan sebagai risiko untuk menggunakan pelabelan yang dipilih. Saya menggunakan pairwise clique (subgraf yang terdiri dari 2 simpul) sebagai orde tertinggi untuk memodelkan energi potensial. Energi potensial pada tiap piksel adalah risiko nilai suatu piksel dibandingkan dengan ‘ground truth’ prior. ‘ground truth’ ini saya modelkan secara sederhana seperti thresholding menggunakan nilai mutlak 128. Energi potensial pada pasangan piksel merupakan smoothness prior yaitu estimasi risiko jika pelabelan suatu piksel terhadap tetangganya. secara keseluruhan, proses binerisasi ini mirip dengan proses binerisasi yang deterministik yang dilanjutkan dengan penghalusan.

Kode berikut adalah potongan prosedur yang saya buat di delphi. Beberapa bagian saya buang seperti misalnya pemodelan temperatur untuk proses sampling dan pembatasan pengulangan. Model Prior juga saya ganti dari yang berbasis statistik tiap label menjadi nilai mutlak.

procedure TForm1.do_mrf;
const N4            : array[0..3] of TPoint = ((X: - 1; Y: 0), (X: 1; Y: 0), (X: 0; Y: - 1), (X: 0; Y: 1));
const NLABEL        = 2;

var
  bi, bo            : TBitmap;
  i, j, k           : integer;
  p1, po            : array of PArrRGB;
  lf                : array of array of 0..NLABEL - 1; //labeling configuration
  cur_energy, z, r  : real;
  delta             : real;
  prev_energy, total_energy: real;
  step, max_step    : integer;
  Energy            : array[0..NLABEL - 1] of real;

  function Vc1(x, y, l: integer): real;
  {
    risiko jika label suatu pixel berbeda dari prior
  }
  begin
    result := abs(l * 255 - p1[y][x].r);//prior kecenderungan absolut
  end;

  function Vc2(x, y, l: integer): real;
  {
    risiko kalau suatu pixel diberi label berbeda dengan label tetangganya (pairwise clique)
  }
  var
    n               : integer;
    dl, dx          : real;
  begin
    result := 0;
    for n := 0 to 3 do begin
      dl := abs(lf[y + N4[n].Y][x + N4[n].X] - l);
      dx := abs(p1[y + N4[n].Y][x + N4[n].X].r - p1[y][x].r);
      result := result + dl * dx;
    end;
  end;

  function Vc(x, y, l: integer): real;
  {
    total risiko suatu pixel (x,y) diberi label l
  }
  begin
    result := Vc1(x, y, l) + Vc2(x, y, l);
  end;

  function calc_energy: real;
  {
    total risiko pelabelan seluruh piksel
  }
  var i, j          : integer;
  begin
    result := 0.0;
    for j := 1 to bo.Height - 2 do
      for i := 1 to bo.Width - 2 do
        result := result + Vc(i, j, lf[j][i]);
    result := result / (bo.Width * bo.Height);
  end;

  procedure initialize;
  {
    inisialisasi dengan nilai prior
  }
  var
    i, j, k         : integer;
    min_v, v        : real;
  begin
    for j := 1 to bo.Height - 2 do begin
      for i := 1 to bo.Width - 2 do begin

        min_v := MAXINT;
        for k := 0 to NLABEL - 1 do begin
          v := Vc1(i, j, k);
          if v < min_v then begin
            min_v := v;
            lf[j][i] := k;
          end;
        end;

      end;
    end;
  end;

  procedure display_output;
  var
    j, i, tmp       : integer;
  begin
    for j := 0 to bo.Height - 1 do begin
      for i := 0 to bo.Width - 1 do begin
        if lf[j][i] = 1 then tmp := 255 else tmp := 0;
        po[j][i] := warna_create(tmp, tmp, tmp);
      end;
    end;
    Image1.Picture.Bitmap.Assign(bo);
    Image1.Refresh;
  end;

begin
  //bi := citra_filter_mean(Image1.Picture.Bitmap, KMEAN);//pakai ini untuk kasus denoising citra biner
  bi := citra_make_greyscale(image1.picture.bitmap);
  bo := citra_clone(bi);

  setlength(p1, bi.Height);
  setlength(po, bo.Height);
  for j := 0 to bi.Height - 1 do p1[j] := bi.ScanLine[j];
  for j := 0 to bo.Height - 1 do po[j] := bo.ScanLine[j];

  setlength(lf, bo.Height);
  for j := 0 to bo.Height - 1 do setlength(lf[j], bo.Width);

  step := 0;
  max_step := 50;

  initialize;
  prev_energy := calc_energy;
  display_output;

  repeat
    //gibbs sampling on every site
    for j := 1 to bo.Height - 2 do begin
      for i := 1 to bo.Width - 2 do begin

        total_energy := 0;
        for k := 0 to NLABEL - 1 do begin
          Energy[k] := exp(-Vc(i, j, k));
          total_energy := total_energy + Energy[k];
        end;
        r := random;
        z := 0;
        for k := 0 to NLABEL - 1 do begin
          try
          z := z + Energy[k] / total_energy;
          except
            showmessage(format('TotalE=%f',[total_energy]));
          end;
          if z > r then begin
            lf[j][i] := k;
            break;
          end;
        end;

      end;
    end;
    
    display_output;

    cur_energy := calc_energy;
    delta := cur_energy - prev_energy;
    Caption := format('#%d E=%.5f', [step, delta]);
    prev_energy := cur_energy;

    inc(step);
  until (abs(delta) < 1e-3) or (step >= max_step);
  
  setlength(p1, 0);
  setlength(po, 0);
  for j := 0 to bo.Height-1 do setlength(lf[j], 0);
  setlength(lf, 0);
  bo.Free;
  bi.Free;
end;

Hasilnya bisa dilihat pada gambar berikut :

citra asal

citra biner menggunakan global threshold

citra biner menggunakan MRF

beda hasil threshold manual dengan MRF

Model MRF di atas (khususnya bagian prior 1-clique) tidak efektif untuk citra yang tidak terlalu kontras (misal citra teks yang pencahayaannya kurang bagus) atau pembersihan citra biner yang ber-noise seperti pada contoh berikut.

noisy

jika menggunakan model MRF seperti kode di atas hasilnya akan seperti ini.

noisy_mrf1

Untuk mengatasi kasus seperti itu, saya mencoba melakukan smoothing citra awal yang sudah biner menjadi grayscale menggunakan mean filter. sehingga hasil akhirnya menjadi seperti ini (cukup memuaskan).

noisy_mrf

MRF juga dapat diterapkan pada graf penalaran First-Order Logic (FOL) yang diberi atribut probabilitas pada tiap term-nya. Kombinasi FOL dengan MRF disebut juga sebagai Markov-Logic Network (MLN). Pada kasus MLN pelabelan dilakukan pada unifikasi term dan busur graf dimodelkan sebagai ketergantugan antar instansiasi dari term. MLN ini saya gunakan dalam riset untuk membaca tulisan tangan (handwriting recognition) sebagai mesin inferensi dengan memanfaatkan relasi spasial antar objek (region/titik kontur). Mudah-mudahan bisa diselesaikan segera supaya bisa saya bagikan di blog ini.

Hal yang menjadi kunci dari pertanyaan di atas adalah interpretasi terhadap susunan informasi. Tabel merupakan kumpulan informasi yang posisinya diatur untuk mempermudah pencarian. oleh sebab itu judul tabel ditempatkan sebelum tabel tersebut (di atas) sebagai petunjuk isi tabel sebelum dilakukan pencarian. Hal ini juga yang menjadi alasan mengapa kepala tabel (table header) ditempatkan di baris pertama atau kolom pertama (kiri atau kanan tergantung kebiasaan baca/tulis).

Berbeda dengan tabel, judul untuk gambar ditempatkan setelah gambar tersebut (di bawah). Alasannya adalah gambar digunakan untuk mengkomunikasikan pesan (ingat ungkapan ‘a picture is worth a thousand worth’) secara visual. Mata manusia merupakan salah satu indera yang dapat memproses informasi secara paralel. Oleh sebab itu gambar akan diproses terlebih dahulu secara top-down (keseluruhan-detil) dan judul digunakan sebagai pengarah pengambilan kesimpulan terhadap gambar yang sebelumnya dilihat.

Tabel berisi informasi tekstual yang harus diinterpretasi secara bottom-up karena makna tulisan ’100′ tidak bisa diinterpretasi secara visual secara sekilas (gist) melainkan harus diinterpretasi simbol-per-simbol dan diintegrasi dengan pengetahuan tentang aturan penulisan bilangan desimal. Inilah yang membuat orang pada umumnya cenderung malas untuk membaca tabel dibandingkan melihat representasi lain dari tabel tersebut (grafik) karena beban kerja kognitif (mengolah informasi abstrak) otak lebih banyak digunakan dibanding kerja intuitif (mengolah informasi alamiah) ketika melihat gambar.

Untuk memahami mean-shift filter, perlu menambahkan konsep bahwa nilai rata-rata yang dipakai bisa jadi tidak terbatas di area ketetanggaan itu saja melainkan bisa saja ada di tempat lain. Oleh sebab itu, nilai rata-ratanya perlu ‘jalan-jalan’ atau bergeser (shift) sampai menemukan nilai rata-rata yang tepat. Kalau dalam mean filter dan bilateral filter yang dihitung hanya rata-rata nilai piksel, maka pada mean-shift filter koordinat piksel yang masuk kriteria seleksi juga dihitung nilai rata-ratanya. Dengan demikian didapat nilai rata-rata koordinat piksel sebagai koordinat baru. Nilai koordinat baru ini kemudian dijadikan titik acuan untuk menghitung nilai rata-rata di ruang fitur (intensitas piksel, warna, atau gradien). Jika titik koordinat baru ternyata tidak berubah maka nilai rata-rata di ruang fitur piksel digunakan untuk mengganti nilai piksel di seluruh koordinat yang pernah menjadi koordinat acuan sampai di koordinat semula.

Berbasis kode mean-shift filter di plugin ImageJ, saya buat versi delphi untuk mean-shift filtering. Kode aslinya dimodifikasi supaya lebih efisien dengan mengasumsikan koordinat yang pernah dikunjungi diganti dengan nilai akhir maka koordinat yang pernah dikunjungi tidak perlu lagi diproses. Efisiensi dilakukan dengan menggunakan citra biner yang berfungsi sebagai mask atau flag, yaitu penanda suatu piksel sudah pernah diproses (akibat penggeseran atau belum).

procedure TForm1.MeanShift1Click(Sender: TObject);
var
  rad               : array of TPoint;
  i, j, k           : integer;
  FeatureSpaceRadius: real;
  ImageSpaceRadius  : Integer;
  fsr2, isr2        : real;
  yiqimage          : array of array of array of real;
  p                 : array of PArrRGB;//lihat tulisan sebelumnya tentang mengakses piksel
  b                 : TBitmap;
  delta             : real;
  iter, maxiter     : integer;
  cur, old          : TPoint;
  sumx, sumy, sumf1, sumf2, sumf3: real;
  invnum            : real;
  xx, yy            : integer;
  f1, f2, f3        : real;
  of1, of2, of3     : real;
  df1, df2, df3     : real;
  dx, dy            : integer;
  bs                : TBitmap;
  mask              : array of array of boolean;
  path              : array of TPoint;

  function is_ok(x, y: integer): boolean;
  begin
    result := (x >= 0) and (y >= 0) and (x < b.Width) and (y < b.Height);
  end;
begin
  //transform image to feature space (YIQ color space)
  b := Image1.Picture.Bitmap;
  setlength(yiqimage, b.Height);
  setlength(mask, b.Height);
  setlength(p, b.Height);
  for j := 0 to high(yiqimage) do begin
    p[j] := b.ScanLine[j];
    setlength(yiqimage[j], b.Width);
    setlength(mask[j], b.Width);
    for i := 0 to b.Width - 1 do with p[j][i] do begin
        mask[j][i] := True;
        setlength(yiqimage[j][i], 3);
        yiqimage[j][i][0] := 0.299 * r + 0.587 * g + 0.114 * b; ;
        yiqimage[j][i][1] := 0.5957 * r - 0.2744 * g - 0.3212 * b; ;
        yiqimage[j][i][2] := 0.2114 * r - 0.5226 * g + 0.3111 * b;
      end;
  end;

  //precompute sampling displacement
  ImageSpaceRadius := 20;
  isr2 := ImageSpaceRadius * ImageSpaceRadius;
  for j := -ImageSpaceRadius to ImageSpaceRadius do begin
    for i := -ImageSpaceRadius to ImageSpaceRadius do begin
      if i * i + j * j <= isr2 then begin
        SetLength(rad, length(rad) + 1);
        rad[high(rad)] := Point(i, j);
      end;
    end;
  end;

  FeatureSpaceRadius := 40;
  fsr2 := FeatureSpaceRadius * FeatureSpaceRadius;
  maxiter := 100;
  for j := 0 to b.Height - 1 do begin
    for i := 0 to b.Width - 1 do begin
      if not mask[j][i] then continue;
      cur.X := i;
      cur.Y := j;
      iter := 0;
      f1 := yiqimage[j][i][0];
      f2 := yiqimage[j][i][1];
      f3 := yiqimage[j][i][2];
      setlength(path, 0);
      repeat
        old := cur;
        of1 := f1;
        of2 := f2;
        of3 := f3;

        invnum := 0;
        sumx := 0;
        sumy := 0;
        sumf1 := 0;
        sumf2 := 0;
        sumf3 := 0;
        for k := 0 to high(rad) do begin
          xx := cur.X + rad[k].X;
          yy := cur.Y + rad[k].Y;
          if is_ok(xx, yy) then begin
            df1 := f1 - yiqimage[yy][xx][0];
            df2 := f2 - yiqimage[yy][xx][1];
            df3 := f3 - yiqimage[yy][xx][2];
            if (df1 * df1 + df2 * df2 + df3 * df3 <= FSR2) then begin
              invnum := invnum + 1;
              sumx := sumx + xx;
              sumy := sumy + yy;
              sumf1 := sumf1 + yiqimage[yy][xx][0];
              sumf2 := sumf2 + yiqimage[yy][xx][1];
              sumf3 := sumf3 + yiqimage[yy][xx][2];
            end;
          end;
        end;
        if invnum < 1 then begin
          break;
        end;
        invnum := 1.0 / invnum;
        f1 := sumf1 * invnum;
        f2 := sumf2 * invnum;
        f3 := sumf3 * invnum;
        cur.X := round(sumx * invnum);
        cur.Y := round(sumy * invnum);
        if not mask[cur.Y][cur.X] then begin
          break;
        end;
        setlength(path, length(path) + 1);
        path[high(path)] := cur;
        dx := cur.X - old.X;
        dy := cur.Y - old.Y;
        df1 := f1 - of1;
        df2 := f2 - of2;
        df3 := f3 - of3;
        delta := dx * dx + dy * dy + df1 * df1 + df2 * df2 + df3 * df3;
        inc(iter);
      until (delta < 3) or (iter >= maxiter);
      p[j][i].r := round(f1 + 0.9563 * f2 + 0.6210 * f3);
      p[j][i].g := round(f1 - 0.2721 * f2 - 0.6473 * f3);
      p[j][i].b := round(f1 - 1.1070 * f2 + 1.7046 * f3);
      mask[j][i] := false;
      for k := 0 to high(path) do begin
        mask[j][i] := false;
        p[path[k].Y][path[k].X] := p[j][i];
      end;
    end;
  end;
  Image1.Refresh;
end;

Kode di atas menggunakan ruang warna YIQ untuk menghitung kedekatan antar piksel. Fungsi jarak yang digunakan adalah jarak Euclid. Selain fungsi jarak dan ruang fitur, filter mean-shift memiliki 2 parameter umum yaitu Radius dalam domain spasial (ImageSpaceRadius) yang dalam filter-filter umumnya menunjuk ke area ketetanggaan dan Radius dalam domain fitur (FeatureSpaceRadius) yaitu batas kedekatan suatu piksel pada ruang fitur. Contoh pemrosesan dengan filter mean-shift ditampilkan di gambar berikut.

Kode yang saya tulis ketika dijalankan akan menghasilkan file teks berisi kode python yang spesifik dengan dimensi matriks yang menjadi parameter.

def genmat(la):
    result = []
    for i in xrange(0,la[0]):
        if len(la)==1:
            result += [["%s" % i]]
        else:
            row = ["%s" % i]
            tmp = genmat(la[1:])
            for x in tmp:
                result += [row+x]
    return result

def setup(n, output="Test", tablename="vec", cols=[], classprefix="DocSearch"):
    classname=classprefix+output
    fpy = open(output+".py", "w")
    if len(cols)==0:
        cols = [("id", "INTEGER PRIMARY KEY"), ("desc", "CHAR(255)")]
    lcols = []
    try:
        dim = len(n)
        vcols = genmat(n)
    except:
        dim = 1
        vcols = genmat([n])
    for f in vcols:
        lcols += [("v"+"_".join(f), "DOUBLE NOT NULL")]
    scols = ", ".join(["%s %s" % (c, t) for c, t in lcols+cols])
    fpy.write("""
import sqlite3

class %s:
    def __init__(self, dbname="db%s.db"):
        self.db = dbname
        self.con = sqlite3.connect(self.db)
        
    def setup(self):
        self.con.execute("CREATE TABLE %s (%s)")
        self.con.commit()
    """ % (classname, output, tablename, scols))

    acols = ", ".join(["%s" % (c) for c, t in cols])
    icols = ", ".join(["%s" % (c) for c, t in lcols+cols])
    ivcols = ", ".join(["?"]*(len(lcols)+len(cols)))
    _ipcols = []
    for f in vcols:
        _ipcols += ["f"+"".join(["["+v+"]" for v in f])]
    ipcols = ", ".join(_ipcols)
    fpy.write("""    
    def insert(self, f, %s):
        self.con.execute("INSERT INTO %s (%s) VALUES (%s)" %s (%s, %s))
        self.con.commit()
    """ % (acols, tablename, icols, ivcols, "%", ipcols, acols))
    
    qcols = ", ".join(["%s*%s" % (c, "?") for c, t in lcols])
    fpy.write("""    
    def query(self, f):
        c = self.con.cursor()
        c.execute("SELECT (%s) as dot, %s FROM %s ORDER BY dot DESC" %s (%s))
        rows = c.fetchall()
        return rows
    """ % (qcols, acols, tablename, "%", ipcols))
    
    fpy.write("""

if __name__=="__main__":
    search = %s()
    search.setup()
    """ % (classname))
    fpy.close()
   
if __name__=="__main__":
    setup(3, "1x3")
    setup([2,2], "2x2")
    setup([8,8], "8x8")
    #print genmat([2,2])
    

Kode di atas juga berisi contoh penggunaan fungsi untuk berbagai dimensi (misal 1xn, mxn, mxnxsxtx…xz). Contoh keluaran untuk matriks 2×2 seperti berikut:

import sqlite3

class DocSearch2x2:
    def __init__(self, dbname="db2x2.db"):
        self.db = dbname
        self.con = sqlite3.connect(self.db)
        
    def setup(self):
        self.con.execute("CREATE TABLE vec (v0_0 DOUBLE NOT NULL, v0_1 DOUBLE NOT NULL, v1_0 DOUBLE NOT NULL, v1_1 DOUBLE NOT NULL, id INTEGER PRIMARY KEY, desc CHAR(255))")
        self.con.commit()
        
    def insert(self, f, id, desc):
        self.con.execute("INSERT INTO vec (v0_0, v0_1, v1_0, v1_1, id, desc) VALUES (?, ?, ?, ?, ?, ?)" % (f[0][0], f[0][1], f[1][0], f[1][1], id, desc))
        self.con.commit()
        
    def query(self, f):
        c = self.con.cursor()
        c.execute("SELECT (v0_0*?, v0_1*?, v1_0*?, v1_1*?) as dot, id, desc FROM vec ORDER BY dot DESC" % (f[0][0], f[0][1], f[1][0], f[1][1]))
        rows = c.fetchall()
        return rows
    

if __name__=="__main__":
    search = DocSearch2x2()
    search.setup()
    

Kode di atas masih bisa dikembangkan lagi, misalnya untuk interface basisdata lain seperti mysql atau postgreS atau menggunakan SQLAlchemy. Oya, saya juga lupa, kode untuk Update belum ada .

import wx
import opencv.cv as cv
import opencv.highgui as gui


class CvMovieFrame(wx.Frame):
    TIMER_PLAY_ID = 101
    def __init__(self, parent):
        wx.Frame.__init__(self, parent, -1)

        self.capture = gui.cvCreateCameraCapture(-1)
        frame = gui.cvQueryFrame(self.capture)
        self.SetSize((frame.width, frame.height))
        self.displayPanel = wx.Panel(self, -1)
        cv.cvCvtColor(frame, frame, cv.CV_BGR2RGB)
        self.bmp = wx.BitmapFromBuffer(frame.width, frame.height, frame.imageData)
        self.Bind(wx.EVT_PAINT, self.onPaint)

        self.playTimer = wx.Timer(self, self.TIMER_PLAY_ID)
        wx.EVT_TIMER(self, self.TIMER_PLAY_ID, self.onNextFrame)
        fps = gui.cvGetCaptureProperty(self.capture, gui.CV_CAP_PROP_FPS)

        self.Show(True)
        if fps!=0: self.playTimer.Start(1000/fps)#every X ms
        else: self.playTimer.Start(1000/15)#assuming 15 fps

    def onPaint(self, evt):
        if self.bmp:
            dc=wx.BufferedPaintDC(self.displayPanel, self.bmp)
        evt.Skip()

    def onNextFrame(self, evt):
        frame = gui.cvQueryFrame(self.capture)
        if frame:
            cv.cvCvtColor(frame, frame, cv.CV_BGR2RGB)
            self.bmp.CopyFromBuffer(frame.imageData)
            self.Refresh()
        evt.Skip()

if __name__=="__main__":
    app = wx.App()
    app.RestoreStdio()
    CvMovieFrame(None)
    app.MainLoop()

kode ini kemudian disesuaikan sehingga menjadi

import wx
import cv #cukup 1 import


class CvMovieFrame(wx.Frame):
    TIMER_PLAY_ID = 101
    def __init__(self, parent):
        wx.Frame.__init__(self, parent, -1)

        self.capture = cv.CreateCameraCapture(-1)
        frame = cv.QueryFrame(self.capture)
        self.SetSize((frame.width, frame.height))
        self.displayPanel = wx.Panel(self, -1)
        cv.CvtColor(frame, frame, cv.CV_BGR2RGB)
        self.bmp = wx.BitmapFromBuffer(frame.width, frame.height, frame.tostring()) #imageData sudah tidak ada
        self.Bind(wx.EVT_PAINT, self.onPaint)

        self.playTimer = wx.Timer(self, self.TIMER_PLAY_ID)
        wx.EVT_TIMER(self, self.TIMER_PLAY_ID, self.onNextFrame)
        fps = cv.GetCaptureProperty(self.capture, cv.CV_CAP_PROP_FPS)

        self.Show(True)
        if fps!=0: self.playTimer.Start(1000/fps)#every X ms
        else: self.playTimer.Start(1000/15)#assuming 15 fps

    def onPaint(self, evt):
        if self.bmp:
            dc=wx.BufferedPaintDC(self.displayPanel, self.bmp)
        evt.Skip()

    def onNextFrame(self, evt):
        frame = cv.QueryFrame(self.capture)
        if frame:
            cv.CvtColor(frame, frame, cv.CV_BGR2RGB)
            self.bmp.CopyFromBuffer(frame.tostring())
            self.Refresh()
        evt.Skip()

if __name__=="__main__":
    app = wx.App()
    app.RestoreStdio()
    CvMovieFrame(None)
    app.MainLoop()

setelah dicoba dan berhasil timbul masalah baru (sepertinya hanya di windows) yaitu gambar dari webcam terlihat berkedip (sesekali). walaupun kode di atas sudah menggunakan doublebuffering (wx.BufferedPaintDC) seperti yang dianjurkan oleh wxPython, namun sepertinya tidak mempan kalau dijalankan di Windows (saya coba di Win7). Cara lain untuk menghilangkan kedipan ini ditunjukkan di mailing-list wxPython-users dengan catatan perlu menggunakan pustaka khusus windows yaitu pythonwin32 seperti di kode berikut.

import wx 
import win32api 
import win32con 
import sys 
import cv 
sys.path.append('C:\OpenCV2.1\Python2.6\Lib\site-packages') 
class captureTest(wx.Frame): 
    TIMER_PLAY_ID = 101 
    def __init__(self, parent): 
        wx.Frame.__init__(self, parent, -1) 

        def SetCompositeMode(self, on=True): 
            exstyle = win32api.GetWindowLong(self.GetHandle(), win32con.GWL_EXSTYLE) 
            if on: 
                exstyle |= win32con.WS_EX_COMPOSITED 
            else: 
                exstyle &= ~win32con.WS_EX_COMPOSITED 
            win32api.SetWindowLong(self.GetHandle(), win32con.GWL_EXSTYLE, exstyle) 

        SetCompositeMode(self, True) 
        self.capture = cv.CaptureFromCAM(0) 
        capImg = cv.QueryFrame(self.capture) 
        self.SetSize((capImg.width, capImg.height)) 
        self.displayPanel = wx.Panel(self, -1) 
        cv.CvtColor(capImg, capImg, cv.CV_BGR2RGB) 
        self.buildBmp = wx.BitmapFromBuffer(capImg.width, capImg.height, capImg.tostring()) 
        self.Bind(wx.EVT_PAINT, self.onPaint) 
        self.playTimer = wx.Timer(self, self.TIMER_PLAY_ID) 
        wx.EVT_TIMER(self, self.TIMER_PLAY_ID, self.onNextFrame) 
        fps = cv.GetCaptureProperty(self.capture, cv.CV_CAP_PROP_FPS) 
        self.Show(True) 
        if fps!=0: self.playTimer.Start(1000/fps) #every X ms 
        else: self.playTimer.Start(1000/15) #assuming 15 fps 

    def onPaint(self, evt): 
        if self.buildBmp: 
            dc=wx.BufferedPaintDC(self.displayPanel, self.buildBmp) 
        evt.Skip() 

    def onNextFrame(self, evt): 
        capImg = cv.QueryFrame(self.capture) 
        if capImg: 
            cv.CvtColor(capImg, capImg, cv.CV_BGR2RGB) 
            self.buildBmp.CopyFromBuffer(capImg.tostring()) 
            self.Refresh() 
        evt.Skip() 

if __name__=="__main__": 
    app = wx.App() 
    app.RestoreStdio() 
    captureTest(None) 
    app.MainLoop()

Kode tersebut belum saya coba, karena di komputer yang saya gunakan belum terpasang pustaka pythonwin32. Setelah meneruskan membaca sambil mencoba ternyata di diskusi tersebut juga ada jawabannya yaitu tidak menggunakan Timer tetapi memanfaatkan event EVT_IDLE. kode akhirnya seperti ini (catatan tambahan, saya mengabaikan frame-per-second dari data video):

import wx
import cv


class CvMovieFrame(wx.Frame):
    def __init__(self, parent):
        wx.Frame.__init__(self, parent, -1)

        self.capture = cv.CreateCameraCapture(-1)
        
        frame = cv.QueryFrame(self.capture)
        self.SetSize((frame.width, frame.height))
        self.displayPanel = wx.Panel(self, -1)
        cv.CvtColor(frame, frame, cv.CV_BGR2RGB)
        self.bmp = wx.BitmapFromBuffer(frame.width, frame.height, frame.tostring())
        self.Show(True)
        
        self.Bind(wx.EVT_IDLE, self.onIdle)

    def onIdle(self, event):
        self.nextFrame()
        event.RequestMore()

    def nextFrame(self):
        img = cv.QueryFrame(self.capture)
        cv.CvtColor(img, img, cv.CV_BGR2RGB)
        self.bmp.CopyFromBuffer(img.tostring())
        dc = wx.ClientDC(self.displayPanel)
        dc.DrawBitmap(self.bmp, 0, 0, False)
        

if __name__=="__main__":
    app = wx.App()
    app.RestoreStdio()
    CvMovieFrame(None)
    app.MainLoop()

Kode di atas ternyata cukup memuaskan. tidak ada lagi kedipan ketika menggambar frame baru.