Besoin d'une formule pour trouver la prochaine cordoné 3d(x,y,z) avec 2 angle et la vitesse

[inviteadaf7cef]

bonjours,
jai beaucoup chercher et je n'ai pas trouvé la solution a mon problème.

pour vous mettre dans le contexte :
je suis en première année de programmation, j'ai relever le défis avec un ami de se crée un petit jeux en 3d qui se déroule dans l'espace.

nous ne pouvons utiliser que deux programme : VisialStudio et 3d studio max. donc je ne peut pas utiliser de moteur graphique.
Avec 3d studio max, je peut seulement crée des objet 3d

je suis confronté a un problème mathématique :

je n'arrive pas a déduire la prochaine position (x,y,z)
jai la coordonné d'origine(x1,y1,z1), deux angle(A,B) et la vitesse(S)

tout ce que j'ai trouvé étais sur une base de 180 Degré et moi je suis avec 2 angle de 360 Degré

merci de votre aide
-----

[invite74a6a825]

Bonjour

Il faudrait utiliser des matrices 3D pour faire les tranformations en donnant un déplacement élémentaire sous forme de vecteur 3D fonction du temps et de la vitesse

[invite74a6a825]

Voilà l'organisation d'une matrice 3D de rotation/translation

---------------------
|cosz|-siz|    |trax|
---------------------
|    |cosy|-siy|tray|
---------------------
|    |-six|cosx|traz|
---------------------
|    |    |    |    |
---------------------

[invite74a6a825]

Et le code source en c++ pour gérer les matrices

#include "stdafx.h"
#include "niv.h"
#define FF fflush(stdout);

#define DBG_SUR 0
#define DBG_ROT 0
#define DBG_MAT 0
extern FILE *f_dbg;
double *geo_egalp(double *,double *);
void print_po(char *,double *);

/*
---------------------
|cosz|-siz|    |trax|
---------------------
|    |cosy|-siy|tray|
---------------------
|    |-six|cosx|traz|
---------------------
|    |    |    |    |
---------------------
*/

/*
##---------------------------------------------- 
##		mat_mimp(a,n)   
##              -----------
##        impression  matrice a[n,n]
##
##---------------------------------------------- 
*/
void mat_mimp(double a[4][4],int n)
{  
int i,j;

      for(i=0;i<n;i++)
      {   for(j=0;j<n;j++)
	     fprintf(f_dbg,"%.3f ,",a[j][i]);
	  fprintf(f_dbg,"\n");
      }
}
/*
##---------------------------------------------- 
##		mat_mat1(b,n)
##              ---------
##          matrice unite                          
##
##---------------------------------------------- 
*/
void mat_mat1(double b[4][4],int n)
{   int i,j;
    for (i=0;i<n;i++)
       {  for (j=0;j<n;j++)
	     b[i][j]=0.0;
	  b[i][i]=1.0;
       }
}
/*
##---------------------------------------------- 
##		mat_mrotz(rz,cosaz,sinaz,inverse)
##              -------------------------------
## matrice rotation z   
##
##---------------------------------------------- 
*/
void mat_mrotz(double rz[4][4],double cosaz,double sinaz,int inverse)
{
#if DBG_MAT
	fprintf(f_dbg,"matrotz SIN COS %f %f \n",sinaz,cosaz);
#endif
	mat_mat1(rz,4);
	rz[0][0]=cosaz;
	if (inverse) 
		{rz[1][0]= sinaz;rz[0][1]= -sinaz;}
		else
		{rz[1][0]= -sinaz;rz[0][1]= sinaz;}
	rz[1][1]=cosaz;
#if DBG_MAT
mat_mimp(rz,4);
#endif
}
/*
##---------------------------------------------- 
##		mat_tcopy(a,b,n)
##              --------------
##
##---------------------------------------------- 
*/
void mat_tcopy(double a[4],double b[4],int n)
{   int i;
    for (i=0;i<n;i++) a[i]=b[i];
}
/*
##---------------------------------------------- 
##		mat_mcopy(v,w,n)
##              ------------
#----------------------------------------------
*/
void mat_mcopy(double v[4][4],double w[4][4],int n)
{    int i,j;
     for (i=0;i<n;i++)
     for (j=0;j<n;j++)
	w[j][i]=v[j][i];
}
/*
##---------------------------------------------- 
##		mat_mmul(a,b,c,n)   
##              ----------------
##       produit  matriciel  c = a * b
##
##---------------------------------------------- 
*/
void mat_mmul(double a[4][4],double b[4][4],double c[4][4],int n)
{
   int i,j,k;
   double somme,r[4][4];

   for (i=0;i<n;i++)
     for (j=0;j<n;j++)
     {
		somme=0.0;
		for (k=0;k<n;k++) 
 			somme += a[k][i] * b[j][k] ;
		r[j][i]=somme;
     }
     mat_mcopy(r,c,n);
}  
/*
##---------------------------------------------- 
##		mat_vmulm(a,v,w,n)  
##              ---------------
##	   double v[4],w[4],a[n,n];
##         produit  vecteur_matrice w = v * a
##
##---------------------------------------------- 
*/
void mat_vmulm(double a[4][4],double v[4],double w[4],int n)
{
    int i,j;
    double somme,r[4];
    
#if DBG_MOVE
fprintf(f_dbg,"mat_vmulm matrice* vecteur \n");
mat_mimp(a,4);
mat_vimp(v,4);
#endif

    for (i=0;i<n;i++)
    {
    	somme=0.0;
	for (j=0;j<n;j++) somme += (a[i][j] * v[j]);
	r[i]=somme;
    }
    mat_tcopy(w,r,n);

#if DBG_MOVE
fprintf(f_dbg,"mat_vmulm vecteur resultat \n");
mat_vimp(w,4);
#endif
}
/*
##---------------------------------------------- 
##		mat_mrotx(rx,cosax,sinax,inverse)
##              -------------------------------
## rx matrice rotation autour de x   
##
##---------------------------------------------- 
*/
void mat_mrotx(double rx[4][4],double cosax,double sinax,int inverse)
{
#if DBG_MAT
	fprintf(f_dbg,"matrotx SIN COS %f %f \n",sinax,cosax);
#endif
	mat_mat1(rx,4);
	rx[1][1]=cosax;
	if (inverse) 
		{rx[2][1]= sinax; rx[1][2]= -sinax;}
		else
		{rx[2][1]= -sinax; rx[1][2]= sinax;}
	rx[2][2]=cosax;
#if DBG_MAT
mat_mimp(rx,4);
#endif
}
/*
##---------------------------------------------- 
##		mat_pt(v,w)
##              ---------------
##	   double v[3],w[3],mat[16]
##         produit  vecteur_matrice w = v * mat
##
##---------------------------------------------- 
*/
double *mat_pt(double mat[4][4],double *v,double *w,int dim)
{
	int i,j;
	double somme;
	double p[4];

	geo_egalp(p,v);
	p[dim-1]=1.;
	for (i=0;i<dim-1;i++)
	{
		somme=0.0;
		for (j=0;j<dim;j++) 
			somme += mat[i][j] * p[j];
// fprintf(f_dbg,"%.3f ",somme);FF
		w[i]=somme;
	}
// fprintf(f_dbg,"MAT_PT \n");FF
	return(w);
}
double *mat_pt2d(double mat[4][4],double *v,double *w)
{
	int i,j;
	double somme;
	double p[3];

	geo_egalp(p,v);
	p[2]=1.;
	for (i=0;i<2;i++)
	{
		somme=0.0;
		for (j=0;j<3;j++) 
			somme += mat[i][j] * p[j];
// fprintf(f_dbg,"%.3f ",somme);FF
		w[i]=somme;
	}
// fprintf(f_dbg,"MAT_PT \n");FF
	return(w);
}
/*
##------------------------------------------------------------------* 
##C matrice rotation vecteur normal
##N		int rot_scrx(rx,sx,cx,va)
##              ------------------------------
##Q	utilisee par rot_vec et rot_plan
##------------------------------------------------------------------* 
*/
void rot_scrx(double rx[4][4],double *sx,double *cx,
double *sy,double *cy,double *va,double *obs)
{
	double v[4];
	double n,l,geo_norm2(double *);

	geo_egalp(v,va);
#if DBG_ROT
fprintf(f_dbg,"rot vec -------------------------\n");
fprintf(f_dbg,"v %7.1f %7.1f %7.1f \n",v[X],v[Y],v[Z]);
#endif
	n= -geo_norm2(v);
	if (n != 0.) {*sx = -v[X]/n; *cx = v[Y]/n;} 
	else {*sx=0.;*cx=1.;}
	mat_mrotz(rx,*cx,*sx,FALSE);
	mat_pt(rx,v,v,4);
	l=geo_norm2(&v[Y]);
	if (l != 0.) {*sy= -v[Y]/l;*cy=v[Z]/l;} 
	else {*sy=0.;*cy=1.;}
#if DBG_ROT
fprintf(f_dbg,"v tourne %7.1f %7.1f %7.1f \n",v[X],v[Y],v[Z]);
fprintf(f_dbg,"norme x y %7.1f \n",n);
fprintf(f_dbg,"sinx=%6.3f cosx=%6.3f \n",*sx,*cx);
fprintf(f_dbg,"norme y z %7.1f \n",l);
fprintf(f_dbg,"siny=%6.3f cosy=%6.3f \n",*sy,*cy);
#endif
}
/*
##------------------------------------------------------------------* 
##C matrice rotation vecteur normal
##N		void rot_vect_inv(MAT,MINV,V0,VA)
##              ------------------------------
##Q	affectation des coefficients des matrices(4*4) de rotation MAT
##Q	et MINV telles que le vecteur VA soit apres multiplication par
##Q	MAT vertical et positif.
##Q	Utilise pour ammener une face dans le plan horizontal a partir
##Q	de sont vecteur normal.
##Q	V0 est le point origine de rotation
##
##D	double *mat,*minv,va[],v0[];
##------------------------------------------------------------------* 
*/
void rot_vect_inv(double mat[4][4],double minv[4][4],double *v0,double *va)
{
	double cosax,sinax;
	double cosay,sinay;
	double rx[4][4],ry[4][4];
	
	mat_mat1(mat,4);
	mat[0][3]= -v0[X];
	mat[1][3]= -v0[Y];
	mat[2][3]= -v0[Z];
	rot_scrx(rx,&sinax,&cosax,&sinay,&cosay,va,v0);
	mat_mmul(mat,rx,mat,4);
	mat_mrotx(ry,cosay,sinay,FALSE);
	mat_mmul(mat,ry,mat,4);

	mat_mrotz(rx,cosax,sinax,TRUE);
	mat_mat1(minv,4);
	mat_mrotx(ry,cosay,sinay,TRUE);
	mat_mmul(minv,ry,minv,4);
	mat_mmul(minv,rx,minv,4);
	minv[0][3]= v0[X];
	minv[1][3]= v0[Y];
	minv[2][3]= v0[Z];
#if DBG_MAT
fprintf(f_dbg,"rot vec rx ------\n");
mat_mimp(rx,4);
fprintf(f_dbg,"rot vec ry ------\n");
mat_mimp(ry,4);
fprintf(f_dbg,"rot vec mat -----\n");
mat_mimp(mat,4);
fprintf(f_dbg,"rot vec inv -----\n");
mat_mimp(minv,4);
double p[3];
p[X]=p[Y]=p[Z]=0.0;
print_po("rot_vect_inv test mat p",p);
mat_pt(mat,p,p);
print_po("test p",p);
mat_pt(minv,p,p);
print_po("test minv p",p);
#endif
}
/*
##------------------------------------------------------------------* 
##C matrice rotation vecteur normal
##N		int rot_vect(MAT,MINV,V0,VA)
##              ------------------------------
##Q	affectation des coefficients de la matrices(4*4) de rotation MAT
##Q	telle que le vecteur VA soit apres multiplication par
##Q	MAT vertical et positif.
##Q	Utilise pour ammener une face dans le plan horizontal a partir
##Q	de sont vecteur normal.
##
##D	double *mat,va[];
##------------------------------------------------------------------* 
*/
void rot_vect(double mat[4][4],double *va,double *obs)
{
	double cosax,sinax;
	double cosay,sinay;
	double rx[4][4],ry[4][4];
	
	rot_scrx(rx,&sinax,&cosax,&sinay,&cosay,va,obs);
	mat_mrotx(ry,cosay,sinay,FALSE);
	mat_mmul(rx,ry,mat,4);
}

[A voir en vidéo sur Futura]

[inviteadaf7cef]

j'ai oublier de préciser que je ne suis pas ce que l'on appel un calée en math ^^

avec une formule avec des variables plus claire m'aiderais a comprendre ^^

merci pour le code en c++

si tu pourrais simplifier la formule ex:

x2 = cos(X1) ...
y2 = ...
z2 = ...

je t'en serais reconnaissant ^^

[sylvainc2]

L'objet semble être en mouvement accélé uniforme selon ta description. Alors on a besoin d'un vecteur vitesse V. Je vais supposer que la vitesse S c'est la norme de V, et que les deux angles a1 et a2 décrivent la direction de V dans l'espace: a1 est mesuré dans le plan Oxy par rapport à l'axe x, et a2 est mesuré par rapport au plan Oxy (c'est comme la longitude et latitude sur la terre, en coordonées sphériques). Alors il faut calculer:

Vx = S * cos(a1)*cos(a2)
Vy = S * sin(a1)*cos(a2)
Vz = S * sin(a2)

et la nouvelle position (x2,y2,z2) est:
x2 = x1 + Vx
y2 = y1 + Vy
z2 = z1 + Vz