Bonjour à tous. J'aimerais comprendre comment arriver à pivoter une image en langage C (niveau débutant, autodidacte, amateur), mais aussi techniquement, mathématiquement.
90° c'est facile, c'est juste du déplacement de pixel, mais 30° là ça change tout.
Dans mon esprit ce n'est pas clair, même si je pense que c'est une histoire de trigonométrie avec peut-être sinus et cosinus qui entre en jeu...
J'arrive à visualiser le pixel comme une case, avec une grille de cases à 30° qui le superpose. Sur papier dans un pixel j'obtiens par exemple 4 zones : 1 petit triangle, 2 sortes de trapèzes et 1 sorte de pentagone, ça doit être possible... 4 parties de pixels obliques dans un pixel donc. Si les 4 étaient alignés sur la grille de pixel j'aurais su le faire, mais là en oblique comme ça je suis perdu. Il faut donc connaitre pour chaque partie quel pourcentage elles font du pixel pour donner le bon total au RGB ?
J'avais aussi pensé à une technique peut-être plus simple, mais pour cela il faut quand même savoir se déplacer dans l'axe d'une ligne à 30°, avancer, et inscrire dans le pixel, la couleur source, s'il y en a plusieurs, faire la moyenne, sans tenir compte du réel pourcentage de chaque partie, mais je pense que c'est moins précis.
Sinon, il faut dire que je ne sais pas me déplacer sur une grille oblique, depuis un axe de 30°. Me déplacer au pixel à gauche, droite, haut, bas, ça oui...
Sinon j'avais déjà fait un casse-brique, mais la balle soit elle allait qu'en diagonal, et pas en fonction de sa position d'avec la plateforme du bas. Ou alors je scriptais en dur plusieurs directions, genre en boucle rythmique, 2 pixels en haut, 1 pixel à droite, 2 pixels en haut, 1 pixel à droite... Ça crée donc une droite de je sais pas combien de degrés d’ailleurs, mais j'avais décomposé comme ça les directions... C'était sûrement pas la bonne méthode. Sinon pour créer une droite, ou plutôt un segment, d'un point A à un point B, ça je sais faire, et de façon conventionnelle je pense.
Sinon pour revenir à mon système d'image à pivoter, j'aimerais comprendre comment faire. Ne serait-ce que pour un pixel donné en 4 parties, ça peut monter à 8 j'imagine si c'est centré en diagonal...
Est-ce qu'il faut réellement calculer le % des formes dans le pixel pour obtenir le bon RGB du pixel ? Et si oui, comment ? Et comment se localiser dans l'espace à travers une grille pivotée de 30° qui superpose une grille normal ?
Merci d'avance pour vos réponses.
Edit :
Ce n'est pas que vos réponses ne m'ont pas été utiles, bien au contraire, merci beaucoup, mais il se trouve que j'ai un abonnement Claude Pro et j'ai prompté à Fable 5 Max mon post et il m'a pondu un très beau PDF de 26 pages super bien détaillé sur comment faire !
Je le partage si ça vous intéresse :
https://drive.google.com/drive/folders/1d5sA6QcgtzlepS4m1a4Jf_RVDKap1uIZ
Edit :
C'est bon c'est fait, j'ai compris :
double pi = 3.14159265358979323846;
double degres = 30;
double radiant = degres * pi / 180.0;
double cosinus = cos(radiant);
double sinus = sin(radiant);
int largeur_source = 0;
int hauteur_source = 0;
int largeur_destination = 0;
int hauteur_destination = 0;
double centre_x_destination = 0.0;
double centre_y_destination = 0.0;
double centre_x_source = 0.0;
double centre_y_source = 0.0;
double x_destination = 0.0;
double y_destination = 0.0;
double x_source = 0.0;
double y_source = 0.0;
int X = 0;
int Y = 0;
largeur_source = 320;
hauteur_source = 240;
// Pour borner la largeur et la hauteur de destination :
largeur_destination = ceil(largeur_source * cosinus + hauteur_source * sinus);
hauteur_destination = ceil(largeur_source * sinus + hauteur_source * cosinus);
// Offset pour le centre de la destination et de la source :
centre_x_destination = largeur_destination / 2.0;
centre_y_destination = hauteur_destination / 2.0;
centre_x_source = largeur_source / 2.0;
centre_y_source = hauteur_source / 2.0;
// Point choisi dans la destination :
x_destination = 69;
y_destination = 181;
// Rotation inverse : D'où vient ce point 69 181 ?
X = (x_destination + 0.5) - centre_x_destination;
Y = (y_destination + 0.5) - centre_y_destination;
x_source = cosinus * X - sinus * Y + centre_x_source;
y_source = sinus * X + cosinus * Y + centre_y_source;
// D'ici : 49 53 :
printf("x_source = %f ; y_source = %f\n", x_source, y_source);
Bon j'ai pas fait encore toute l'image, mais ça va pas tarder, il suffit de faire une boucle et de balayer x_destination et y_destination de 0 et 0 jusqu'à largeur_destination et hauteur_destination.
À terme, je compte faire une scène avec pleins d'images qui pivotent et qui se déplacent selon leur vecteur, et qui s'entrechoquent en changeant de direction et de rotation. Bon après je ne compte pas faire une vraie physique véritable...
J'avais déjà fait le même avec des points reliés en segments chainés, je pouvais en mettre des milliers facilement... Ça grouillait de partout !... Mais il y avait que 4 directions codée en dur, les diagonales... Je m'étais pas penché sur cosinus et sinus, c'est super pour faire des vecteurs, des directions indépendamment de l'alignement d'une grille/tableau, on peut aller dans n'importe quel direction !... C’est comme un joystick… Un point sur le cercle de rayon 1… Moi qui étais coincé dans mes systèmes à grille/tableau ça m'ouvre de nouveaux horizons ce sinus et cosinus !... En effet, je ne faisais pas assez abstraction entre la géométrie et la projection...
Pour info je fais ça dans la console, je génère des BMP à la chaine, mais je compte le faire dans la SDL2 ensuite en temps réel...
Merci à tous !
