« Programmation objet et géométrie/Objets en Python sous Gimp/Programmation JavaScript sous ImageJ » : différence entre les versions

Contenu supprimé Contenu ajouté
→‎Fonction de deux variables : simplification du code
→‎Représentation dans l'espace : simplification du code et création d'objets javascript
Ligne 66 :
===Représentation dans l'espace===
 
ImageJ permet aussi de convertir une surface donnée par ses lignes de niveau comme ci-dessus, en une représentation graphique sous forme d'une surface dans l'espace. De même que ci-dessus, on va donc créer une image où les niveaux de gris représentent une fonction <math>z=f(x,y)</math> et la faire convertir par ImageJ en dessin de la surface correspondante, vue en perspective. La fonction <math>z=f(x,y)</math> considérée est la somme des distances entre le point de coordonnées (i,j) et les points de coordonnées respectives A(200;50), B(100;350) et C(350;350) (''Attention'': L'axe des ''y'' est orienté vers le bas). On sait depuis [[w:Fermat|Fermat]] et [[w:Torricelli|Torricelli]] que cette fonction atteint son minimum en un point appelé ''point de Fermat-Torricelli'' du triangle dont les sommets sont donnés ci-dessus.
 
Comme on fait de la géométrie, il est assez efficace de créer des objets ''point'' et ''triangle'' qui vont considérablement simplifier le code JavaScript (avec des méthodes adéquates) qui suivra. Tout d'abord, l'objet ''point'' ne possède que deux propriétés, ses coordonnées, et une méthode, son affichage. On a besoin d'une fonction ''distance'' (entre deux points) et d'une procédure ''triangle'' (ayant pour variables ses trois sommets):
L'image sera en noir et blanc, sur 65536 niveaux de gris (''16-bit''), et les instructions ''moveTo'' et ''lineTo'' (méthodes de l'objet ''ip'', lui-même processeur d'image défini sur l'objet ''plan'' qui est une instance de la classe ''image'') servent à dessiner le triangle en blanc par-dessus la représentation de la somme des distances:
 
<source lang="javascript">
function point(x,y){//objet point
this.x=x;
this.y=y;//les coordonnées sont des propriétés du point
this.plot=function(proc){//l'affichage est une méthode du point
proc.putPixel(x,y,255*256+255*256*256);
}
}
 
function distance(a,b){//a et b sont deux points
d= return Math.sqrt(Math.pow(ia.x-N/2b.x,2)+Math.pow(ja.y-N/8b.y,2));
}
 
function triangle(a,b,c,proc){//a, b et c sont les sommets du triangle,
// proc est là où on le dessine
ip proc.moveTo(N/2a.x, N/8a.y);//origine on part du premier segmentsommet
ip proc.lineTo(N/4b.x, 7*N/8b.y);// tracé du premiercôté segment[ab]
proc.lineTo(c.x,c.y);// puis du côté [bc]
proc.lineTo(a.x,a.y);// et du côté [ca]
}
 
 
On note ''A.x'' l'abscisse de A (''x'' est une propriété de l'objet ''A''). La création de l'image se fait comme ci-dessus, avec la méthode ''createImage'' de l'objet ''IJ''. On obtient alors un objet ''plan'' qui est une image (le chevalet initialement blanc). La méthode ''getProcessor'' permet alors d'avoir les filtres de cet objet (flou, Voronoi etc.). Ce processuer ne servira ici que pour ses mathodes de tracé de pixel et de segments (le triangle):
 
<source lang="javascript">
var N=400;//taille de l'image
plan=IJ.newImagecreateImage("Fermat", "16-bit", N, N, 1);//création de l'image en noir et blanc
plan = IJ.getImage();//création du dessin plan (lignes de niveau)
ip = plan.getProcessor();//les filtres du plan dans ip
 
A=new point(N/2,N/8);
B=new point(N/4,7*N/8);
C=new point(7*N/8,7*N/8);//les sommets du triangle sont des points
 
for(var i=0;i<N;i++){
IJ.showProgress(i, N-1);//on regarde où on en est
for(var j=0;j<N;j++){
P=new point(i,j);
d=Math.sqrt(Math.pow(i-N/2,2)+Math.pow(j-N/8,2));
//la d=distance de (iP,jA) à +distance(P,B)+distance(N/2P,N/8C);
d+=Math.sqrt(Math.pow(i-N/4,2)+Math.pow(j-7*N/8,2));
//plus la distance de (i,j) à (N/4,7N/8)
d+=Math.sqrt(Math.pow(i-7*N/8,2)+Math.pow(j-7*N/8,2));
//plus la distance de (i,j) à (7N/8,7N/8)
c=Math.round(d*64-32*256);//le niveau de blanc est la somme des distances
ip.putPixel(i, j, c);//normalisée empiriquement
}
}
triangle(A,B,C,ip.setColor(255);//ledessin du triangle est dessiné en blanc
plan.updateAndDrawshow();//affichage une seule fois, pour gagner du temps
ip.moveTo(N/2, N/8);//origine du premier segment
ip.lineTo(N/4, 7*N/8);//tracé du premier segment
ip.lineTo(7*N/8, 7*N/8);//tracé du second segment
ip.lineTo(N/2,N/8);//retour au départ pour fermer le triangle
plan.updateAndDraw();//affichage une seule fois, pour gagner du temps
</source>