\documentclass[10pt]{article}
\usepackage[utf8]{inputenc}
\usepackage[T1]{fontenc}

\begin{document}
\begin{verbatim}
# -*- coding: utf-8 -*-
Created on Fri Jul 3 16:02:40 2015
@author: arno
"""
# non demandé
def demande_valeur(text):
    x=int(input(text))
    return x
# Q1.
def demande_fenetre()
    Px=demande_valeur('Valeur de Px : ',)
    Py=demande_valeur('Valeur de Py : ' ')
    H=demande_valeur('Valeur de H : ')
    return [P\overline{x},Py,L,H]
# Q2. fenetre=demande_fenetre()
def verification_fenetre(image_width,image_height,fenetre):
    [Px,Py,L,H]=fenetre
    return 0<=Px and Px+L<=image_width and 0<=Py and Py+H<=image_fenetre
# Q3. SELECT filename FROM instruments JOIN definitions ON instruments.id=defini
tions.mid WHERE name='pince';
# Q4.
def centre(fenetre):
    [Px,Py,L,H]=fenetre
    return [(2*Px+L)//2,(2*Py+H)//2]
# Q5. à chaque pixel est associé un entier entre 0 et 255. Or 2**8=256. Donc cha
que pixel est codé sur 8 bits=1 octet.
# Au total pour l'image: 3*m*n=1 440 000 octets
# soit en gros 1,37 Méga-octets
# Q6.
def grayscale(imagecolor):
[m,n]=imagecolor.shape[1:3]
    image=[[0 for x in range (m)] for y in range(n)] # avec numpy: image=zeros((
m,n)) for i in range(m):
            for j in range(n):
                rgb=[imagecolor[0][i][j],imagecolor[1][i][j],imagecolor[2][i][j]]
                image[i][j]=(max(rgb)+min(rgb))//2
    return image
# Q7
def construction_coordonnees_pts(fenetre,numM,numN):
    [Px,Py,L,H]=fenetre
    for x
        for arange(Px,Px+L+1,L//(numM-1)):
        for y in arange(Py,Py+H+1,H//(numN-1)):
            pts.append(x) # x est le même pendant l'exécution de la boucle for y
    return pts.append(y)
    return pts
# Q8. Ix = imgI[ux+1,uy] - imgI[ux,uy]
\end{verbatim}

mars 15, 16 22:10\\
stdin

\begin{verbatim}
# Iy = imgI[ux,uy+1] - imgI[ux,uy
        Page 2/4
# Q9.
def creation_patch(P,patch_size): #P=[Px,Py]
    pts=[]
        x in range(patch_size):
            for y in range(patch_size):
                pts.append(P[0]+x-(patch_size-1)//2) # x est le même pendant l'exécu
tion de la boucle for
    return pts.ppend(P[1]+y-(patch_size-1)//2)
    return pts
# Q10.
def calc_Ab(imgI,imgJ,patch): #patch_size=sqrt(len(patch)/2)
    b=zeros((len(patch)//2,'1))
    for k in len(patch)//2:
        [Ix, Iy,Itdt]=calc_LK_terms([patch[2*k],patch[2*k+1]],imgI,imgJ)
        A[k,0]=Ix
        A[k,1]=1y
        b[k,0]=-Itdt
    return A,b
# Q11.
def resoud_LK(A,b):
    M=dots(transpose(A),A) #système de Cramer MX=B de taille 2x2
    B=dots(transpose(A), b)
    # algorithme du pivot de Gauss-Jordan
    # recherche d'un pivot sur la colonne 0
    if M[0,0]==0:
        M[1,:],M[0,:] = M[0,:],M[1,:]
    # on effectue une transvection sur la ligne 1
    M[1,:]=M[1,:] - (M[1,0]/float(M[0,0]))*M[0,:]
    B[1,:]=B[1,:] - (M[1,0]/float(M[0,0]))*B[0,:]
    # calcul de dy puis dx
    dy=B[1,0]/1oat(M[1,1])
    dx=(B[0,0]-M[0,1]*dy)/float(M[0,0])
    return [dx,dy]
# Q12.
def recherche_points(imgI,imgJ,pts): # pts=construction_coordonnees_pts(fenetre,
numM, numN)
    for -
        P=[pts[2* ]
        patch=creat,pts[2*k+1]]
        [A,b]=
        [dx,dyl,patch)
        fpts 1
        fpts.appe(pts[2*k]+int(dx))
    return fpts
# Q13. On n'a pas pris en compte le cas où le patch sort de l'image et le cas ou
transpose(A)*A n'est pas inversible.
# Q14.
fpts=recherche_points(imgI,imgJ,pts)
ffpt=recherche_points(imgJ,imgI,pts)
statut=[]
for k in range(len(ftps)):
    statut.append(fpts[k]==ffpts[k])
\end{verbatim}

\begin{verbatim}
\# Q15. la notation A[i:j:k] n'a pas été redéfinie: A[start:stop:step]
\# points[0::2] donne les abscisses (indices pairs) et points[1::2] les ordonnées
(indices impairs)
\# on calcule la distance entre un point de référence dans l'image précédente et
dans l'image courante, ceci pour chaque point de référence
\# on donne le résultat dans un tableau numpy de flottants de taille $1 \times($ numm*numN
)
\# Q16.
    tri_rapide(t):
if len(t) $<=1$ :
            retur
            \# rn t \# ou avec un seul élément
    else:
            tte fonction renverra None en sortie
            plus_pe] \# choix arbitraire du pivot
            plus_petits=[ $x$ for $x$ in $t$ if $x<p i v o t$
            pus_grands= $x$ for $x$ in $t$ [1] if $x>=$ pivot ]
            \# trie la liste plus_petits et renvoie None
            \#tri_rapide(plus_grands) \# trie la liste plus_grands et renvoie None
rarn tri_rapide(plus_petits)+[pivot]+tri_rapide(plus_grands) \# concaté
et renvoi du resultat
def mediane(a):
    tri_rapide(a)
    if $\mathrm{n} \% 2==1$ :
    if n\%2==1:
    else:
        return (a[n//2]+a[(n-1)//2])/2.
\# Q17. Algorithme de tri rapide. $O\left(n^{* *} 2\right)$ dans le pire des cas et $O(n \cdot \log (n))$ dan
s le meilleur des cas
\# Q18.
def verification_pts(pts,fpts,statut):
    nouveaux_pts=[]
n=len(pts)//2
    n=1en(pts)/12
    critere2=calcul1(pts,fpts)
    for $k$ in range( $n$ ):
        if statut[k]==True and critere2[k]<=med:
            nouveaux_pts.append(pts[2*k])
            nouveaux_pts.append(pts[2*k+1])
    return nouveaux_pts
\# Q19.
$\mathrm{n}=1 \mathrm{en}$ (pts)//2
critere3=[]
for k in range( n ):
    result=cv2.matchTemplate(imgJ,creation_patch([pts[2*k],pts[2*k+1]],patch_siz
e),CV_TM_CCORR_NORMED)
    critere3.append(result)
\# Q20. Argh.
\end{verbatim}


\end{document}