Discussion :

[Sonilight]

Bonjour à vous!

Dans le cadre d'un travail de recherche sur des orthèses visuelles, j'utilise matlab pour simuler la demi sphérisation d'une image.
En faites, j'aimerais projeter une image sur une demi sphère et que tout ce qui se retrouve en dehors de la demi sphère reste inchangé.
En farfouillant un peu dans l'aide, j'ai trouvé ceci

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
[x,z,y] = sphere;
I = imread('text2.png');
warp(x,y,z,I);
set(gca,'ZDir','reverse')

Cela coresponds à l'effet que je souhaite mais j'aimerais que la partie que l'on ne voit pas (l'autre moitié de la sphère) soit projeté sur un plan.
En faites, j'aimerais coller mon image sur un plan comme celui-ci.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
x=-3:0.1:3; y=-3:0.1:3; 
[X,Y]=meshgrid(x,y); 
Z=(4-X.^2-Y.^2).^0.5; 
mesh(X,Y,Z); 
axis equal;

Un petit coup de main ne serait pas de refus ?

[Jerome Briot]

Essaie ceci :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
x=-3:0.1:3; y=-3:0.1:3; 
[x,y]=meshgrid(x,y); 
z=(4-x.^2-y.^2).^0.5; 
z=real(z);
 
figure('doublebuffer','on')
 
load clown
colormap(map)
 
surf(x,y,z,'facecolor','texturemap',...  
    'cdata',X,'edgecolor','none');
 
axis equal vis3d
set(gca,'ydir','reverse')

A lire : 3-B-2. L'objet Surface

[Sonilight]

Merci pour cette réponse rapide.
C'est presque ça!
En faites, je voudrais avoir cet effet là (voir image jointe).
Il manque l'effet de dilatation du à la projection.
Comment faire?

[Jerome Briot]

Pose ta question (avec l'image) dans le forum Algorithmes > Traitement d'images pour obtenir des infos sur les méthodes d'interpolation permettant d'obtenir ce type d'effet.

[Sonilight]

C'est fait! Ils m'ont donné ce code

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
 
double ATANSCALE = 2/Math.PI;
 
for(int y=0;y<height;y++) {
	for(int x=0;x<width;x++) {
 
		// center+rescale coords in [-1,1]
		double xk=((double)x/width)*2-1;
		double yk=((double)y/height)*2-1;
 
		// outside of the sphere -> next
		if ( (yk*yk+xk*xk)>=0.999 ) continue;
 
		// compute zk from (xk,yk)
		double zk = Math.sqrt(1-(xk*xk+yk*yk));
 
		// cartesian coords (xk,yk,zk) in [-1,1] -> spherical coords (xs,ys) in [-1,1]
		double xs = Math.atan( xk / zk ) * ATANSCALE;
		double ys = Math.atan( yk / zk ) * ATANSCALE;
 
		// spherical coords (xs,ys) -> texture coords
		int xtex = (int)(width*(xs+1)/2);
		int ytex = (int)(height*(ys+1)/2);
 
		// set pixel value
		output[x][y] = input[xtex][ytex];
	}
}

Y'a t-il une âme charitable pour me traduire cela sous matlab? Cela me permettra de faire patienter mon audimat avant de leur donner quelquechose de plus complexe (raytracer)


Merci d'avance

[Jerome Briot]

Tu devrais pouvoir le traduire en MATLAB assez facilement... (sans chercher à l'optimiser bien entendu )

Une petite tentative de ta part ?

[Sonilight]

Qui ne tente rien n'a rien.
Je vais essayer et je vous dis quoi.

[Sonilight]

Voici ce que j'ai après traduction

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
 
 
>> ATANSCAL = 2/pi;
ATANSCALE = double (ATANSCAL);
y=0;
x=0;
 
for y = 0:20
	for x=0:20 
 
		double(x);
		double(y);
		xk = (x/20)*2-1;
		double(xk);
		yk = (y/20)*2-1;
		double(yk);
 
		if ( (yk*yk+xk*xk)>=0.999 ) 
		continue;
		end;
 
		zk=(1-x.^2-y.^2).^0.5;
		double(zk);
		xs = atan( xk / zk ) * ATANSCALE;
		double(xs);
		ys = atan( yk / zk ) * ATANSCALE;
		double(ys);		
 
		xtex = 20*(xs+1)/2;
		ytex = 20*(ys+1)/2;
 
		x.outputdata = input('xtek','s');
		y.outputdata = input('ytek','s');
	end
end

Tout ceci n'est pas trés concluant...

[Jerome Briot]

Dans le code que tu essaies de traduire, input et output désigne respectivement l'image initiale et l'image finale (ce sont des matrices).

[Sonilight]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
 
ATANSCAL = 2/pi;
ATANSCALE = double (ATANSCAL);
y=0;
x=0;
a = zeros(20,20);
b = zeros(20,20);
for y = 0:20
	for x=0:20 
 
		double(x);
		double(y);
		xk = (x/20)*2-1;
		double(xk);
		yk = (y/20)*2-1;
		double(yk);
 
		if ( (yk*yk+xk*xk)>=0.999 ) 
		continue;
		end;
 
		zk=(1-x.^2-y.^2).^0.5;
		double(zk);
		xs = atan( xk / zk ) * ATANSCALE;
		double(xs);
		ys = atan( yk / zk ) * ATANSCALE;
		double(ys);		
 
		xte = 20*(xs+1)/2;
		yte = 20*(ys+1)/2;
		ytex = uint32 (yte);
		xtex = uint32 (xte);
		b(xtex,ytex)=zk;
	end
end

J'avoue avoir un peu de mal à comprendre. xtex et ytex ne sont pas des entiers alors pourquoi il servirait d'indice pour une matrice?
Et ensuite que faut il faire? Est ce qu'on peut mapper une image directement?

[Sonilight]

Alors voila ce que j'obtient:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
 
ATANSCAL = 2/pi;
ATANSCALE = double (ATANSCAL);
y=0;
x=0;
a = zeros(20,20);
b = zeros(20,20);
for y = 0:20
	for x=0:20 
 
		double(x);
		double(y);
		xk = (x/20)*2-1;
		double(xk);
		yk = (y/20)*2-1;
		double(yk);
 
		if ( (yk*yk+xk*xk)>=0.999 ) 
		continue;
		end;
 
		zk=(1-x.^2-y.^2).^0.5;
		double(zk);
		xs = atan( xk / zk ) * ATANSCALE;
		double(xs);
		ys = atan( yk / zk ) * ATANSCALE;
		double(ys);		
 
		xte = 20*(xs+1)/2;
		yte = 20*(ys+1)/2;
		ytex = uint32 (yte);
		xtex = uint32 (xte);
		b(x,y)=zk;
	end
end
figure('doublebuffer','on')
load clown
colormap(map)
surf(b,'facecolor','texturemap',...  
    'cdata',X,'edgecolor','none');

Je sais bien que je dois vous apparaitre comme un boulet mais là j'avoue que je calle.
(Si je suis embetant, dites le moi et j'arrterai de vous ennuyer avec mes soucis )

[Sonilight]

Bon, j'ai fait une erreur de synthaxe dans mon code d'où la forme bizarre que nous avions à la fin.
Maintenant, j'ai bien obtenu une demi sphère coupée par un plan...

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
 
ATANSCAL = 2/pi;
ATANSCALE = double (ATANSCAL);
y=0;
x=0;
a = zeros(20,20);
b = zeros(20,20);
for y = 0:20
	for x=0:20 
 
		double(x);
		double(y);
		xk = (x/20)*2-1;
		double(xk);
		yk = (y/20)*2-1;
		double(yk);
 
		if ( (yk*yk+xk*xk)>=0.999 ) 
		continue;
		end;
 
		zk=(1-xk.^2-yk.^2).^0.5;
		double(zk);
		xs = atan( xk / zk ) * ATANSCALE;
		double(xs);
		ys = atan( yk / zk ) * ATANSCALE;
		double(ys);		
 
		xte = 20*(xs+1)/2;
		yte = 20*(ys+1)/2;
		ytex = uint8 (yte);
		xtex = uint8 (xte);
		b(xtex,ytex)=zk;
	end
end

Mais cela ne me dit toujours pas comment plaquer une image afin d'avoir un effet de dilatation sur l'image.
Je vais refaire un tour du coté du forum algorithme

[Sonilight]

Enfin fini.
Pour ceux que cela interesse voici la code

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
 
ATANSCAL = 2/pi;
ATANSCALE = double (ATANSCAL);
y=0;
x=0;
r=input('Taille de la sphere(0<t<1)?');
k=input('Coefficient de dilatation (0<x<1)?');
width=input('largeur?');
height=input('longueur?');
ks = -k+1;
a=imread('Text.png');
for y = 1:height
	for x=1:width 
 
 
                b(x,y)=a(x,y);
		double(x);
		double(y);
		xk = (x/width)*2-1;
		double(xk);
		yk = (y/height)*2-1;
		double(yk);
		if ( (yk*yk+xk*xk)<=r*0.999 ) 
 
 
 
		zk=(1-xk.^2-yk.^2).^0.5;
		double(zk);
		xs = atan( ks*xk / zk ) * ATANSCALE;
		double(xs);
		ys = atan( ks*yk / zk ) * ATANSCALE;
		double(ys);		
 
		xte = width*(xs+1)/2;
		yte = height*(ys+1)/2;
		ytex = uint16 (yte);
		xtex = uint16 (xte);
 
                b(x,y)=a(xtex,ytex);
                end
	end
end;
imshow(b)

Je l'ai un peu optimisé afin qu'on puisse voir une partie non dilatée, rentrer nous même un coefficient de dilatation et choisir le rayon du cercle . Voili voilou
Et merci encore