Coordonnées des pixels de type double

Résolu/Fermé
dadita
Messages postés
9
Date d'inscription
dimanche 30 décembre 2012
Statut
Membre
Dernière intervention
25 août 2013
- Modifié par dadita le 30/12/2012 à 09:38
dadita
Messages postés
9
Date d'inscription
dimanche 30 décembre 2012
Statut
Membre
Dernière intervention
25 août 2013
- 31 déc. 2012 à 17:47
Bonjour,
comment faire pour représenter une image avec des coordonnées de pixel de type double?
c'est à dire une image construite à partir des points comme

java.awt.geom.Point2D a = new Point2D.Double(13.1258,85.36985);

en effet j'ai deux tableaux de données
le premier tableau de type int, et contient les valeurs de pixels RGB

int[] pixels = image.getRGB(0,0, image.getWidth(), image.getHeight(), null, 0, image.getWidth());

j'ai un autre tableau de type double et contient les coordonnées des pixels de l'image originale après l'application d'une interpolation

gridValues = new Double[(xNumCells) * (yNumCells)]; 

        for (int i = 0; i < yNumCells; i++) { 
            for (int j = 0; j < xNumCells; j++) { 
// les points dp sont les points de l'image originale avec des coordonnées de type int (j,i) 
// getValue() est la fonction d'interpolation 
             Point dp = new Point(j,i); 
             int index = (i * (1 + xNumCells)) + j; 
             double value =  getValue(dp); 
                gridValues[index] = value; 
            } 
        }

maintenant je dois construire et afficher une image resultat de l'interpolation, avec les coordonnées:

java.awt.geom.Point2D a = new Point2D.Double(j+gridValues[j],i+gridValues[j])

Merciiiii
A voir également:

1 réponse

KX
Messages postés
16540
Date d'inscription
samedi 31 mai 2008
Statut
Modérateur
Dernière intervention
22 mai 2022
2 957
30 déc. 2012 à 16:50
Une image est nécessairement décrite par des pixels à coordonnées entières.
Donc tu dois transformer tes double en int (ce qui va nécessairement entrainer une perte de qualité de ton image) soit avec un cast, soit avec les méthodes Math.ceil, Math.round, Math.floor, ou autre...

Remarque : ton traitement de l'image avec un tableau à une dimension est un peu surprenant vu qu'on a des méthodes qui permettent de le faire en deux dimensions, ce qui est plus simple...

import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;

import javax.imageio.ImageIO;

/** Pixel construit par interpolation */
class Pixel
{
    /** abscisse après interpolation */
    public final double x;
    
    /** ordonnée après interpolation */
    public final double y;
    
    /** valeur du pixel */
    public final int rgb;
    
    // exemple de paramètres pour une interpolation linéaire
    private static double a=1, b=0.5, c=0, d=1; 
    
    /**
     * Construction du pixel par interpolation.
     * @param x abscisse initiale
     * @param y ordonée initiale
     * @param rgb valeur du pixel
     */
    public Pixel(int x,int y,int rgb)
    {
        // Enregistrement de la couleur
        this.rgb = rgb;
        
        // Calcul de l'interpolation    
        this.x = a*x + b*y;
        this.y = c*x + d*y;
    }
}

public class Test
{
    public static void interpoler(File imageSrcFile, File pngDstFile) throws IOException
    {
        // Lecture de l'image initiale
        BufferedImage image = ImageIO.read(imageSrcFile);
        int w = image.getWidth();
        int h = image.getHeight();
        
        // Stocke les pixels de la future image
        Pixel[] pixels = new Pixel[w*h];
        
        // Déterminent les dimensions de l'image finale
        double minX = Double.POSITIVE_INFINITY;
        double maxX = Double.NEGATIVE_INFINITY;
        double minY = Double.POSITIVE_INFINITY;
        double maxY = Double.NEGATIVE_INFINITY;
        
        // Construction des pixels de la future image
        for (int x=0, k=0; x<w; x++) 
        for (int y=0; y<h; y++, k++)
        {
            // Calcul de l'interpolation
            Pixel p = new Pixel(x,y,image.getRGB(x,y));
            pixels[k] = p;
            
            // Mise à jour des dimensions
            if (p.x<minX) minX=p.x;
            if (p.x>maxX) maxX=p.x;
            if (p.y<minY) minY=p.y;
            if (p.y>maxY) maxY=p.y;
        }
        
        // Calcul de la taille de la future image
        int w2 = (int) (maxX-minX+1);
        int h2 = (int) (maxY-minY+1);
        
        if (w2>10000 || h2>10000)
            throw new RuntimeException("Dimensions de l'image supérieure à 10000 px de côté");
        
        // Construction de la nouvelle image
        image = new BufferedImage(w2,h2,BufferedImage.TYPE_INT_ARGB);
        
        // Remplissage de la nouvelle image
        for (Pixel p : pixels)
        {
            int x = (int) (p.x - minX); // TODO : c'est ici qu'il faut choisir la conversion
            int y = (int) (p.y - minY); // TODO : (int), Math.floor, Math.ceil, Math.round, etc.
            image.setRGB(x, y, p.rgb);
        }
        
        // Ecriture de la nouvelle image
        ImageIO.write(image, "png", pngDstFile);
    }
    
    public static void main(String[] args) throws IOException
    {
        interpoler(new File("C:/test.png"),new File("C:/test2.png"));
    }
}
1
dadita
Messages postés
9
Date d'inscription
dimanche 30 décembre 2012
Statut
Membre
Dernière intervention
25 août 2013

31 déc. 2012 à 17:47
je vous remercie pour votre aide, l'idée de la class "Pixel" me facilite la procédure de récupération des pixels avec leurs coordonnées après interpolation.
Merciiiiiiiiiiiii
0