Le test avec variables utilisateur (réglages) qui sont [seuilfix_0]pour la saturation de l octant et [seuilfix_1]pour le nombre de d octants ôtés dans la comparaison des octants valides. //------------------------------------------------------------------ // donnée public raster ou bitmap pour Raster[0] et partiellement [1] Declarer int haut//hauteur RASTER Declarer int larg//largeur RASTER Declarer int rayon//rayon cercle a trouver Declarer int patt//forme cercle a trouver // variable nb tread declarer int pro//nb de process paralleles // raster pour transfert des parametres du cercle trouvé // seuls hauteur & largeur sont utilises dans les objets // Raster[1] stockera rayon, Raster[2,3] valeurs sur les octants declarer RASTER Raster[1](haut,larg,null,null,Raster[null])=0 declarer RASTER Raster[2,3](haut,larg,null,null,Raster[null])=0 //hauteur RASTER (bitmap) & largeur, rayon a trouver //& forme du cercle a trouver declarer RASTER Raster[0](haut,larg,rayon,patt,Raster[1])=0 declarer int nQV=0 ,oct=0 ,n=0 declarer int nQf = Raster[0].patPoids() // declaration variable multiprocessing tant que n declarer y_cent[n] declarer x_cent[n] declarer max_y_cent[n] declarer min_y_cent[n] declarer max_x_cent[n] declarer min_x_cent[n] n+=1 fin tan que 'pro' //decoupage du travail (plan bitmap) 1 tant que n max_y_cent[n]=Raster[0].larg/pro * n min_y_cent[n]=Raster[0].larg/pro * (n-1) max_x_cent[n]=Raster[0].haut/pro * n min_x_cent[n]=Raster[0].haut/pro * (n-1) n+=1 fin tan que 'pro' n=0 tant que n //variable de bouclage des plans (n nombre de plans) y_cent[n]=min_y_cent[n] x_cent[n]=min_x_cent[n] tant que y_cent[n] tant que x_cent[n] si Raster[0].point[Raster[0].x_cent[n],Raster[0].y_cent[n]-Raster[0].rayon] = 1; //test en un point. Raster[0].empilage(x_cent[n], y_cent[n]) nQV=0 //bouclage tous les segments de la pile tant que oct si //seuilfix_0 parametrable en choix user ou constant 'app 800/1000' //nPQ dans le texte est Raster[0].Octant[oct] Raster[0].Pile[0].SEGMENTS[oct]>=(Raster[0].nPa * seuilfix_0) ** sauvegarde données de [SEGMENTS[0..7]] nQV+=1 fin si oct+=1 fin tant que fin si si //seuilfix_1 parametrable en choix user ou constant '0 pour precision maximum' nQV>=(nQf - seuilfix_1)==> le cercle existe Raster[1].valideCentre(Raster[0].x_cent[n],Raster[0].y_cent[n],Raster[0].rayon) //synoptique du transfert de données a l extérieure du noyau. ** restitution données de sauvegarde de [SEGMENTS[0..7]] ** 4 octets par raster. Point (grâce au poids du pixel 4*8octets) ** soit 64 bits (sur Raster[2 et 3] dispo pour coter les 8 octants) Raster[2,3].valideCentre(Raster[2,3].x_cent[n],Raster[2,3].y_cent[n], Pile[0].SEGMENTS[0.3 ;4 .7]) //marquage du rayon sur Raster[1] Raster[].valideCentre(Raster[0].x_cent[n],Raster[0].y_cent[n],Raster[0].rayon) fin si fin si x_cent+=1 fin tant que 'max_x_cent[n]' y_cent+=1 fin tant que 'max_y_cent[n]' fin tant que 'pro' ------------------------------------------------------- ----------- objet PILE. tableau contenant les information sur le cercle en cours de recherche ------------------------------------------------------------------- objet PILE() declarerobjet[] SEGMENTS[0, 7]//tablo des accumulateurs PILE.SEGMENTS[ind_seg] = PILE.SEGMENTS[ind_seg]+1//operateur incrementation fin objet PILE ------------------------------------------------------------------- objet RASTER representant le bitmap ou image sur laquelle on cherche les informations. ------------------------------------------------------------------- objet RASTER(int h, int l,int r,int p,objet RASTER R) int RASTER.haut= h int RASTER.larg= l int RASTER.rayon=r//rayon cercle theorique int RASTER.patt=p//patt forme objet theorique int RASTER.nPa=0//attendu dans l octant declarer int[] RASTER.point[h*l] objet RASTER.rast=R objet RASTER.PILE()//tablo des accumulateurs procedure RASTER.empilage(int x_cent, int y_cent) procedure RASTER.testExistance(objet PILE, int ind_seg, boolrealite, int x, int y ) procedure RASTER.testRASTER(objet PILE, ind_seg, x, y ) procedure RASTER.valideCentre(int h, int l,int r) procedure int RASTER.patPoids() fin objet RASTER procedure RASTER.valideCentre(int hx, int lx,int rx) RASTER.point[hx,lx]=rx fin de procedure procedure RASTER.empilage( int x_cent, int y_cent) declarer int x, y, m, z z = 0 x = 0 y = RASTER.rayon m = 5 - 4*RASTER.rayon//initialisation Tant que x testExistance( 0, x+x_cent, y+y_cent ) testExistance( 1, y+x_cent, x+y_cent ) testExistance( 2, -x+x_cent, y+y_cent ) testExistance( 3, -y+x_cent, x+y_cent ) testExistance( 4, x+x_cent, -y+y_cent ) testExistance( 5, y+x_cent, -x+y_cent ) testExistance( 6, -x+x_cent, -y+y_cent ) testExistance( 7, -y+x_cent, -x+y_cent ) z = z + 1 si m > 0 alors y = y - 1 m = m - 8*y fin si x = x + 1 m = m + 8*x + 4 fin tant que 'x RASTER.nPa = z fin de procedure procedure RASTER.testExistance(int ind_seg, int x, int y ) si ( x y (RASTER.patt>>(ind_seg-1) & 1) et RASTER.point[x,y]=1 ) //segemnt incrementé si conditions reunies RASTER.PILE.SEGMENTS[ind_seg]+= 1; fin si fin de procedure procedure RASTER.patPoids() renvoie int declarer n = 0 declarer tot = 0 tant que n tot = tot +(RASTER.patt>>(ind_seg-1) & 1 ) //ex: patt=243 patt(en ^2)=11110011 //tot=nombre de 1 dans patt ! n = n+1 fin tant que 'n renvoyer tot fin de procedure