[Image processing][Soglie] Aiuto con Otsu

[DavideDaSerra]

Ciao, sto imprecando come un dannato pechè non ho capito esattamente come si comporti l'algoritmo otsu per il calcolo delle soglie.
In teoria dovrebbe massimizzare la varianza inter-classe, ma la teroia, si sa, è diversa dalla pratica e io vorrei capire come implementarlo.

Per ora ho capito che:
1- devo calcolare l'istogramma dell'immagine (OK)
2- devo determinare una soglia da cui partire (ma non so da dove partire)
3- il buio più scuro

Qualcuno saprebbe aiutarmi?

per ora il codice che ho scritto è questo:

Codice: Seleziona tutto

import numpy as np

hist(image,bin=255): #funzione che calcola l'istogramma
	hist = np.zeros(bin)
	for i in xrange(0,bin):
		hist[i]=sum(img[img==i])
	return hist

media_cumulativa(hst,level): 
	mc = 0
	for i in xrange(0,level):
		mc = (hst[i]*i) + mc
	return mc

def OTSU(image,max=255):
	def OTSU(image,max=255):
	hst = hist(image,max)
	num_pix_liv_1 = sum(hst[:th])
	num_pix_liv_2 = sum(hst[th:])
	
	somma_pix_liv_1 = 0
	for i in xrange (0,th):
		somma_pix_liv_1 = somma_pix_liv_1 + ( hst[i]*i )
	
	somma_pix_liv_2 = 0
	for i in xrange (th,max):
		somma_pix_liv_2 = somma_pix_liv_2 + ( hst[i]*i )
		
	media_pix_liv_1 = somma_pix_liv_1 / float(num_pix_liv_1)
	media_pix_liv_2 = somma_pix_liv_2 / float(num_pix_liv_2)
        media_globale = np.average(image)


	

sottolineo che vorrei evitare di usare funzioni di libreria perchè devo capirene bene il funzionamento

[DavideDaSerra]

nel caso a qualcuno interessasse ho risolto così:

Codice: Seleziona tutto

def hist1_d(img, _bins=257):
    #hist = np.zeros(bin)
    #for i in xrange(0,bin):
    #    hist[i]=sum(img[img==i])
    
    hist,bns = np.histogram(a=img,bins=range(_bins))
    return hist

def otsu(image): ## funziona
    hist = hist1_d(image)
    BCV = np.zeros(len(hist))
    # WCV = np.zeros(len(hist))
    
    for th in xrange(1, len(hist)):
        skip = 0
        mb = 0
        mf = 0
        
        if np.sum(hist[:th]) != 0:
            mb = np.sum(hist[:th] * range(th)) / float(np.sum(hist[:th]))
        else:
            skip = True
        
        if np.sum(hist[th:]) != 0:
            mf = np.sum(hist[th:] * range(th,len(hist))) / float(np.sum(hist[th:]))
        else:
            skip = True
         
        tot = float(np.sum(hist[:]))
        wb = np.sum(hist[:th])/tot ## peso dello sfondo
        wf = np.sum(hist[th:])/tot ## peso del primo piano
        
        if not skip: 
            BCV[th] = wb * wf * np.square(mf - mb) ## between class variance (da max)
        else:
            BCV[th] = 0
        
    return np.argmax(BCV)-1, BCV # ritorna la soglia, (differisce di 1 da quella opencv)