Réponse acceptée !
Ton image est probablement (quasi sur) stocké ligne par ligne en
partant du haut ou du bas (ca changera rien, au pire l'image sera a
l'envers, mais ca marchera). Le pb c'est que tu veux non seulement
découper ton image, mais suivant des blocs qui ne sont pas naturel pour
le buffer. Mais ca reste simple.
Une ligne de ton image représente 4096 pixel soit 4096*3*sizeof(float). (3 pour RGB).
Si tu veux une image de 1024*1024, il te faut un buffer de 1024*1024*3*sizeof(float) OCTETS donc:
(Utilise l'allocation du C++ plutot que du C).
float * sous_image = new float[1024*1024*3*sizeof(float))];
Et donc ca te donne un buffer de la taille correct, faut maitenant le remplir. On va procéder par ligne avec la commande:
memcpy(buffer cible, buffer source, nombre d'octet a copier);
ou plus précisement
memcpy(void * target, const void * src, unsigned int octet) // ou un truc du genre
Donc on copie 1024 ligne de 1024 pixel:
On définie size_of_line pour une meilleur lisibilité: unsigned int
size_of_line = 1024*3; C'est le nombre de floatant sur une ligne de la
sous image et non le nombre d'octet. On travail en nombre de floatant
puisque le pointeur (sous_image) est définie par float * et non char *.
De meme, on définie size_of_initial_line, cad le nombre de floatant sur une ligne de l'image initiale.
Admettons que l'on est
tableau de type float * qui contient l'image initiale.
for (int i = 0; i < 1024 ; i++)
{
memcpy(&sous_image[i*size_of_line], &tableau[i*size_of_initial_line], size_of_line * sizeof(float));
}
memcpy prend en 3eme argument le nombre d'octet, or comme size_of_line est le nombre de floatant...
Donc avec ca, tu copies la première image (celle de coordonnée 0,0). Tu
en as 15 autres a faire. Apres c'est juste un pb de décalage a ajouter
a &tableau[X]. Par exemple pour la deuxième image, il faut
"&tableau[i*size_of_initial_line + 1024*3]".
Bon j'ai ptet fait des erreurs, mais j'espère avoir expliqué relativement clairement le pb.