function Irot=rotationdirectcrop(I,theta); 

% function Irot =rotationdirectcrop(I,theta); 
% 
% Rotation effectuee directement en respectant les tailles des images. 
% Approximation bilineaire. Valable si l'angle de rotation est petit. 

[m,n] = size(I); 
% on repere les coordonnees du pixel central de la matrice  
% en supposant que le cadre de cette matrice soit [0,n-1] x [0,m-1] 

xc = (n-1)/2; 
yc = (m-1)/2; 

%On declare une matrice assez grande pour contenir l'image apres rotation. 

D=sqrt(m^2+n^2)/2; 
MM = ceil(D-m/2); 
NN = ceil(D-n/2); 
Iinit= [zeros(MM,n);I;zeros(MM,n)]; 
Iinit = [zeros(m+2*MM,NN) Iinit zeros(m+2*MM,NN)];
[mm,nn] = size(Iinit); 
Irot = zeros(mm,nn);  

% Il faut avoir en tete que le pixel (j,k) de cette matrice 
% corrrespond au point d'abscisse -NN + k-1 et d'ordonnee -MM + j-1.  

for j=1:mm 
    for k=1:nn 
        x = - NN + k -1; 
        y = - MM + j-1; 
        % On applique a ce point la rotation affine de centre (xc,yc) et 
        % d'angle -theta.
        X = xc + cos(theta)*(x-xc) - sin(theta)*(y-yc); 
        Y = yc  + sin(theta)*(x-xc) + cos(theta)*(y-yc);
        if X*(X-(n-1))>0
                Irot(j,k) = 0; 
        elseif  Y*(Y-(m-1))>0 
                Irot(j,k)=0; 
        % Dans ces deux cas, on sort en effet du cadre ou se trouve l'image I.         
        else
            % On effectue ici le travail sur le transparent 8 du cours 2. 
            t = X - floor(X);  
            s = Y - floor(Y); 
            indexXinf = floor(X)+1; 
            indexXsup = ceil(X)+1; 
            indexYinf = floor(Y)+1; 
            indexYsup = ceil(Y) +1; 
            Iaux1 = (1-t)*I(indexYinf,indexXinf) + t*I(indexYinf,indexXsup); 
            Iaux2 = (1-t)*I(indexYsup,indexXinf) + t*I(indexYsup,indexXsup); 
            Irot(j,k) = (1-s)*Iaux1 + s*Iaux2;
        end        
    end
end
Irot=Irot(MM+1:MM+m,NN+1:NN+n);      
end

