libimage  0.25.4
 Tout Classes Espaces de nommage Fichiers Fonctions Variables Énumérations Macros Pages
Fonctions membres publiques | Fonctions membres privées | Attributs privés | Liste de tous les membres
Référence de la classe ReprojectedImage

Manipulation d'image reprojetée. Plus de détails...

#include <ReprojectedImage.h>

Graphe d'héritage de ReprojectedImage:
Inheritance graph
Graphe de collaboration de ReprojectedImage:
Collaboration graph

Fonctions membres publiques

 ReprojectedImage (Image *image, BoundingBox< double > bbox, Grid *grid, Interpolation::KernelType KT=Interpolation::LANCZOS_2, bool bMask=false)
 Crée un objet ReprojectedImage à partir de tous ses éléments constitutifs, sauf les résolutions (calculées)
 ReprojectedImage (Image *image, BoundingBox< double > bbox, double resx, double resy, Grid *grid, Interpolation::KernelType KT=Interpolation::LANCZOS_2, bool bMask=false)
 Crée un objet ReprojectedImage à partir de tous ses éléments constitutifs.
void initialize ()
 Initialise les buffers de calcul.
int getline (float *buffer, int line)
 Retourne une ligne en flottant 32 bits. Les canaux sont entrelacés. Si les données ne sont pas intrinsèquement codées sur des flottants 32 bits, une conversion est effectuée.
int getline (uint8_t *buffer, int line)
 Retourne une ligne en entier 8 bits. Les canaux sont entrelacés. ATTENTION : si les données ne sont pas intrinsèquement codées sur des entiers 8 bits, il n'y a pas de conversion (une valeur sur 32 bits occupera 4 "cases" sur 8 bits).
int getline (uint16_t *buffer, int line)
 Retourne une ligne en entier 16 bits. Les canaux sont entrelacés. ATTENTION : si les données ne sont pas intrinsèquement codées sur des entiers 16 bits, il n'y a pas de conversion (une valeur sur 32 bits occupera 2 "cases" sur 16 bits).
 ~ReprojectedImage ()
 Destructeur par défaut.
void print ()
 Sortie des informations sur l'image reprojetée.
- Fonctions membres publiques inherited from Image
void makeMask ()
 Définit l'image comme un masque.
int getWidth ()
 Retourne la largeur en pixel de l'image.
int getHeight ()
 Retourne la hauteur en pixel de l'image.
void setBbox (BoundingBox< double > box)
 Définit l'emprise rectangulaire de l'image et calcule les résolutions.
bool setDimensions (int w, int h, BoundingBox< double > box, double rx, double ry)
 Définit les dimensions de l'image, en vérifiant leurs cohérences.
BoundingBox< double > getBbox () const
 Retourne l'emprise rectangulaire de l'image.
void setCRS (CRS srs)
 Définit le SRS de l'emprise rectangulaire.
CRS getCRS () const
 Retourne le SRS de l'emprise rectangulaire de l'image.
double getXmin () const
 Retourne le xmin de l'emprise rectangulaire.
double getYmax () const
 Retourne le ymax de l'emprise rectangulaire.
double getXmax () const
 Retourne le xmax de l'emprise rectangulaire.
double getYmin () const
 Retourne le ymin de l'emprise rectangulaire.
double getResX () const
 Retourne la résolution dans le sens des X.
double getResY () const
 Retourne la résolution dans le sens des Y.
ImagegetMask ()
 Retourne le masque de donnée associé à l'image.
bool setMask (Image *newMask)
 Définit le masque de donnée et contrôle la cohérence avec l'image.
int x2c (double x)
 Conversion de l'abscisse terrain vers l'indice de colonne dans l'image.
int y2l (double y)
 Conversion de l'ordonnée terrain vers l'indice de ligne dans l'image.
double c2x (int c)
 Conversion de l'indice de colonne dans l'image vers l'abscisse terrain du centre du pixel.
double l2y (int l)
 Conversion de l'indice de ligne dans l'image vers l'ordonnée terrain du centre du pixel.
double getPhaseX ()
 Calcul de la phase dans le sens des X.
double getPhaseY ()
 Calcul de la phase dans le sens des Y.
bool isCompatibleWith (Image *pImage)
 Détermine la compatibilité avec une autre image, en comparant phases et résolutions.
 Image (int width, int height, int channels, double resx, double resy, BoundingBox< double > bbox)
 Crée un objet Image à partir de tous ses éléments constitutifs.
 Image (int width, int height, int channels)
 Crée une Image sans préciser de géoréférencement, ni résolutions, ni rectangle englobant.
 Image (int width, int height, int channels, BoundingBox< double > bbox)
 Crée une Image sans préciser les résolutions.
 Image (int width, int height, int channels, double resx, double resy)
 Crée un objet Image sans préciser le rectangle englobant.
virtual ~Image ()
 Destructeur par défaut.
virtual void printTFW ()
 Sortie du tfw de l'image.

Fonctions membres privées

float * computeDestLine (int line)
 Retourne une ligne entièrement reprojetée, flottante.
int getSourceLineIndex (int line)
 Retourne l'index dans le buffer src_image_buffer (et src_mask_buffer) de la ligne source voulue.

Attributs privés

ImagesourceImage
 Image source, à réechantillonner.
bool useMask
 Précise si les masques doivent intervenir dans l'interpolation (lourd)
const KernelK
 Noyau d'interpolation à utiliser.
int Kx
 Nombre de pixels source intervenant dans l'interpolation, dans le sens des X.
int Ky
 Nombre de pixels source intervenant dans l'interpolation, dans le sens des Y.
double ratioX
 Rapport des résolutions source et finale, dans le sens des X.
double ratioY
 Rapport des résolutions source et finale, dans le sens des Y.
Gridgrid
 Grille de reprojection.
float * __buffer
 Buffer général.
int memorizedLines
 Nombre de lignes source que l'on va mémoriser, pour l'image et le masque.
int * src_line_index
 Indexation des lignes sources mémorisées.
float ** src_image_buffer
 Buffer de stockage des lignes de l'image source.
float ** src_mask_buffer
 Buffer de stockage des lignes du masque source.
int dst_line_index
 Index des lignes reprojetées.
float * dst_image_buffer [4]
 4 lignes d'image entièrement reprojetées
float * mux_dst_image_buffer
 4 lignes d'image entièrement reprojetées, multiplexées
float * dst_mask_buffer [4]
 4 lignes de masque entièrement reprojetées
float * mux_dst_mask_buffer
 4 lignes de masque entièrement reprojetées, multiplexées
float * X [4]
 Coordonnées X en pixel source des pixels de la ligne à reprojeter.
float * Y [4]
 Coordonnées Y en pixel source des pixels de la ligne à reprojeter.
float * Wx [1024]
 Poids pré-calculé, dans le sens des X.
float * Wy [1024]
 Poids pré-calculé, dans le sens des Y.
float * WWx
 Poids dans le sens des X utilisés pour le calcul des 4 pixels en cours, multiplexés.
float * WWy
 Poids dans le sens des Y utilisés pour le calcul des 4 pixels en cours, multiplexés.
int xmin [1024]
 Premiers pixels sources à utiliser, dans le sens des X, pré-calculé
int ymin [1024]
 Premiers pixels sources à utiliser, dans le sens des Y, pré-calculé
float * tmp1Img
 Pixels sources à utiliser pour les 4 pixels en cours, multiplexés.
float * tmp2Img
 4 pixels interpolés dans le sens des X , multiplexés
float * tmp1Msk
 Pixels du masque source à utiliser pour les 4 pixels en cours, multiplexés.
float * tmp2Msk
 4 pixels du masque, interpolé dans le sens des X , multiplexés

Additional Inherited Members

- Fonctions membres publiques statiques inherited from Image
static bool dimensionsAreConsistent (double resolution_x, double resolution_y, int w, int h, BoundingBox< double > bounding_box)
 Vérifie la cohérence des dimensions d'image fournies.
- Attributs publics inherited from Image
const int channels
 Nombre de canaux de l'image.
- Fonctions membres protégées inherited from Image
void computeResolutions ()
 Calcul des resolutions en x et en y, calculées à partir des dimensions et de la bouding box.
- Attributs protégés inherited from Image
int width
 Largeur de l'image en pixel.
int height
 Hauteur de l'image en pixel.
bool isMask
 L'image est-ell un masque ?
BoundingBox< double > bbox
 Emprise rectangulaire au sol de l'image.
CRS crs
 CRS du rectangle englobant de l'image.
Imagemask
 Masque de donnée associé à l'image, facultatif.
double resx
 Resolution de l'image, dans le sens des X.
double resy
 Resolution de l'image, dans le sens des Y.

Description détaillée

Manipulation d'image reprojetée.

Auteur
Institut national de l'information géographique et forestière

Cette classe permet de reprojeter une image lorsque celle ci n'est pas dans le bon système spatial. Pour calculer la valeur d'un pixel de l'image reprojetée, on peut utiliser plusieurs interpolations, implémentées dans les différentes classes héritant de Kernel. La reprojection s'appuie principalement sur l'utilisation d'une grille de reprojection (objet de la classe Grid), qui permet de connaître le pixel source correspondant à chacun des pixels reprojetés.

Les calculs étant lourds, on va optimiser le calcul :

Du fait de la reprojection (aucun alignement), les calculs réalisés pour un pixel ne peuvent être réutilisés pour un autre pixel. Cette différence avec le simple réechnatillonnnage rend les calculs beaucoup plus lourds

Pour augmenter les performances de la reprojection avec les instructions SSE, on est amené :

On peut également tenir compte du masque associé à l'image source, pour limiter l'interpolation aux valeurs réelles. Cela ajoute non seulement de la complexité aux calculs, mais prend également plus de place. On va donc limiter cette utilisation aux cas vraiment nécessaires : si l'image source possède un masque (image pas pleine) et si l'utilisateur spécifie qu'il veut l'utiliser dans la reprojection.

Enfin, lors de la reprojection, on ne tient pas compte du propre masque. C'est à dire qu'on remplit un pixel reprojeté avec de la donnée à partir du moment où un pixel de donnée source appartenait au noyau d'interpolation. Si on veut utiliser cette image sans avoir un "gonflement" artificiel des données, on devra la lire en parallèle de son masque (interpolé en plus proche voisin) pour la restreindre à l'étendue réelle des données (cela peut se faire avec ExtendedCompoundImage).

Documentation des constructeurs et destructeur

ReprojectedImage::ReprojectedImage ( Image image,
BoundingBox< double >  bbox,
Grid grid,
Interpolation::KernelType  KT = Interpolation::LANCZOS_2,
bool  bMask = false 
)
inline

Crée un objet ReprojectedImage à partir de tous ses éléments constitutifs, sauf les résolutions (calculées)

Paramètres
[in]imageimage source
[in]bboxemprise rectangulaire de l'image reprojetée
[in]gridgrille de reprojection à utiliser
[in]KTnoyau d'interpolation à utiliser pour la reprojection
[in]bUseMaskprécise si la reprojection doit tenir compte des masques

Voici le graphe d'appel pour cette fonction :

ReprojectedImage::ReprojectedImage ( Image image,
BoundingBox< double >  bbox,
double  resx,
double  resy,
Grid grid,
Interpolation::KernelType  KT = Interpolation::LANCZOS_2,
bool  bMask = false 
)
inline

Crée un objet ReprojectedImage à partir de tous ses éléments constitutifs.

Paramètres
[in]imageimage source
[in]bboxemprise rectangulaire de l'image reprojetée
[in]resxrésolution dans le sens des X
[in]resyrésolution dans le sens des Y
[in]gridgrille de reprojection à utiliser
[in]KTnoyau d'interpolation à utiliser pour la reprojection
[in]bUseMaskprécise si la reprojection doit tenir compte des masques

Voici le graphe d'appel pour cette fonction :

ReprojectedImage::~ReprojectedImage ( )
inline

Destructeur par défaut.

Désallocation de la mémoire :

Et suppression de sourceImage.

Documentation des fonctions membres

float * ReprojectedImage::computeDestLine ( int  line)
private

Retourne une ligne entièrement reprojetée, flottante.

Paramètres
[in]lineIndice de la ligne à retourner (0 <= line < height)
Renvoie
Tableau contenant la ligne reprojetée

Voici le graphe d'appel pour cette fonction :

Voici le graphe des appelants de cette fonction :

int ReprojectedImage::getline ( float *  buffer,
int  line 
)
virtual

Retourne une ligne en flottant 32 bits. Les canaux sont entrelacés. Si les données ne sont pas intrinsèquement codées sur des flottants 32 bits, une conversion est effectuée.

Paramètres
[in,out]bufferTableau contenant au moins 'width * channels' flottant sur 32 bits
[in]lineIndice de la ligne à retourner (0 <= line < height)
Renvoie
taille utile du buffer, 0 si erreur

Implémente Image.

Voici le graphe d'appel pour cette fonction :

int ReprojectedImage::getline ( uint8_t *  buffer,
int  line 
)
virtual

Retourne une ligne en entier 8 bits. Les canaux sont entrelacés. ATTENTION : si les données ne sont pas intrinsèquement codées sur des entiers 8 bits, il n'y a pas de conversion (une valeur sur 32 bits occupera 4 "cases" sur 8 bits).

Paramètres
[in,out]bufferTableau contenant au moins 'width * channels * sizeof(sample)' entier sur 8 bits
[in]lineIndice de la ligne à retourner (0 <= line < height)
Renvoie
taille utile du buffer, 0 si erreur

Implémente Image.

Voici le graphe d'appel pour cette fonction :

int ReprojectedImage::getline ( uint16_t *  buffer,
int  line 
)
virtual

Retourne une ligne en entier 16 bits. Les canaux sont entrelacés. ATTENTION : si les données ne sont pas intrinsèquement codées sur des entiers 16 bits, il n'y a pas de conversion (une valeur sur 32 bits occupera 2 "cases" sur 16 bits).

Paramètres
[in,out]bufferTableau contenant au moins 'width * channels * sizeof(sample) * 2' entier sur 16 bits
[in]lineIndice de la ligne à retourner (0 <= line < height)
Renvoie
taille utile du buffer, 0 si erreur

Implémente Image.

Voici le graphe d'appel pour cette fonction :

int ReprojectedImage::getSourceLineIndex ( int  line)
private

Retourne l'index dans le buffer src_image_buffer (et src_mask_buffer) de la ligne source voulue.

On ne mémorise que memorizedLines lignes sources. Lorsque l'on a besoin d'une ligne source, on en demande l'index. Si cette ligne est déjà chargée dans le buffer, on retourne directement l'index. Sinon, on récupère la ligne de sourceImage, on la stocke, on met à jour la table des index src_line_index, et on retourne l'index de la ligne voulue.

Paramètres
[in]lineIndice de la ligne source dont on veut l'indice
Renvoie
Indice de la ligne voulue dans le buffer des sources

Voici le graphe d'appel pour cette fonction :

Voici le graphe des appelants de cette fonction :

Documentation des données membres

float* ReprojectedImage::__buffer
private

Buffer général.

Il regroupe :

  • les buffers de mémorisation des lignes sources (image et masque)
  • les buffers intermédiaires de calcul (image et masque)
  • les buffers des poids de l'interpolation
  • le buffer d'indexation des données
int ReprojectedImage::dst_line_index
private

Index des lignes reprojetées.

Les lignes de l'image reprojetée sont calculées 4 par 4. On veut donc mémoriser les lignes qui sont déjà calculées et présentes dans le buffer dst_image_buffer (et le masque dans dst_mask_buffer) pour pouvoir les retourner directement.

dst_line_index contient le résultat de la division entière de l'indice de la ligne reprojetée par 4, et la place de la ligne dans le buffer sera l'indice de ligne modulo 4.

Grid* ReprojectedImage::grid
private

Grille de reprojection.

La grille est utilisée pour connaître le pixel source correspondant à celui de l'image reprojetée. Celle-ci doit déjà avoir subi toutes les transformations nécessaires (reprojection et transformation affine. La grille ne sera pas modifiée lors des calculs de reprojection de l'image, c'est pourquoi elle peut être utilisée par plusieurs images, si elles ont les mêmes dimensions (largeur, hauteur et bbox). Typiquement, une image reprojetée et son masque associé peuvent utiliser la même grille.

int ReprojectedImage::memorizedLines
private

Nombre de lignes source que l'on va mémoriser, pour l'image et le masque.

On ne veut pas charger l'intégralité de l'image source en mémoire vive, c'est pourquoi on ne va en stocker qu'un certain nombre :

  • ni trop faible car on ne doit pas être amené à demander une même ligne source plusieurs fois, pour des raisons de performances.
  • ni trop élevé, pour ne pas surcharger le mémoire.

Du fait de la reprojection, 2 pixels sur la même ligne reprojetée vont correspondre à deux lignes potentiellement différentes dans l'image source. On va donc quantifier cet écart (Grid::deltaY) et l'utiliser pour définir le nombre de lignes sources mémorisée dans src_image_buffer (et src_mask_buffer) : memorizedLines = Grid::deltaY + 2 x Ky

double ReprojectedImage::ratioX
private

Rapport des résolutions source et finale, dans le sens des X.

Ratio de rééchantillonage en X = résolution X cible / résolution X source

double ReprojectedImage::ratioY
private

Rapport des résolutions source et finale, dans le sens des Y.

Ratio de rééchantillonage en Y = résolution Y cible / résolution Y source

float** ReprojectedImage::src_image_buffer
private

Buffer de stockage des lignes de l'image source.

On stocke memorizedLines lignes

int* ReprojectedImage::src_line_index
private

Indexation des lignes sources mémorisées.

Elle permet de convertir un indice de la ligne de l'image source en indice dans le tableau des lignes mémorisées (dans src_image_buffer et src_mask_buffer).

float** ReprojectedImage::src_mask_buffer
private

Buffer de stockage des lignes du masque source.

On stocke memorizedLines lignes

float* ReprojectedImage::Wx[1024]
private

Poids pré-calculé, dans le sens des X.

Du fait de la reprojection, tous les pixels à reprojeter sont décalés en X par rapport aux pixels sources d'une manière différente. Pour des raisons de performance, on ne peut pas calculer pour chaque pixel le tableau des poids correspondant. On va donc préalablement calculer 1024 possibilités de poids, qui seront utilisés pour l'ensemble de l'image reprojetée.

float* ReprojectedImage::Wy[1024]
private

Poids pré-calculé, dans le sens des Y.

Du fait de la reprojection, tous les pixels à reprojeter sont décalés en Y par rapport aux pixels sources d'une manière différente. Pour des raisons de performance, on ne peut pas calculer pour chaque pixel le tableau des poids correspondant. On va donc préalablement calculer 1024 possibilités de poids, qui seront utilisés pour l'ensemble de l'image reprojetée.

int ReprojectedImage::xmin[1024]
private

Premiers pixels sources à utiliser, dans le sens des X, pré-calculé

Du fait de la reprojection, tous les pixels à reprojeter sont décalés en X par rapport aux pixels sources d'une manière différente. Pour des raisons de performance, on ne peut pas calculer pour chaque pixel le premier pixel source à utiliser. On va donc préalablement calculer 1024 possibilités de premier pixel, qui seront utilisés pour l'ensemble de l'image reprojetée.

int ReprojectedImage::ymin[1024]
private

Premiers pixels sources à utiliser, dans le sens des Y, pré-calculé

Du fait de la reprojection, tous les pixels à reprojeter sont décalés en Y par rapport aux pixels sources d'une manière différente. Pour des raisons de performance, on ne peut pas calculer pour chaque pixel le premier pixel source à utiliser. On va donc préalablement calculer 1024 possibilités de premier pixel, qui seront utilisés pour l'ensemble de l'image reprojetée.


La documentation de cette classe a été générée à partir des fichiers suivants :