Coordonnées des pixels de type double Résolu

Question

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 
Configuration: Windows 7 / Chrome 23.0.1271.97

KX · Answer

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"));
    }
}

Coordonnées des pixels de type double

1 réponse

Votre réponse

Discussions similaires

Newsletters