mon programme donne frame vide

voila mon programme qui donne frame vide   import java.awt.* ;
import java.awt.event.* ;
import javax.swing.*  ;
import java.io.*;
import javax.imageio.* ;
import java.awt.image.* ;
import java.awt.image.BufferedImage;

 

public class FiltreImage {

   static Tableau frame ;
       public static void main ( String[] args ) {
       frame = new Tableau() ;
       frame.setVisible(true) ;
       }
       }
    class Tableau extends JFrame {
     //private static final long serialVersionUID = -1654172985512850048L;
 
      static final Dimension screensize =
      Toolkit.getDefaultToolkit().getScreenSize();
       static final int largeurEcran = screensize.width;
       static final int hauteurEcran = screensize.height + 2;
      // static final int largeurEcran = 1024;
        //static final int hauteurEcran = 768;
     
     int l = 400 ;
      int h = 300 ;
      Container pane ;
     
      public Tableau() {
       super() ;
       pane = getContentPane();
       pane.setLayout(new FlowLayout());
       this.addWindowListener(new WindowAdapter() {
        public void windowClosing(WindowEvent e)  {
         System.exit(0) ;
        }});
      setBounds ((largeurEcran -l) / 2,
                      (hauteurEcran-h) / 2,l,h);
       
                      
              PhotoCanvas photo = new PhotoCanvas("box.gif") ;
              l = photo.getWidth();
    h = photo.getHeight();
    setBounds((largeurEcran - l) / 2,
(hauteurEcran - h) / 2, l, h);
              pane.add(photo);
       }
}

class PhotoCanvas extends JPanel {
     private static final long serialVersionUID = -425196446497911425L ;
     Image img ;
 
    public PhotoCanvas ( String s )  {
         setSize (400,300 );
         img = getToolkit().getImage(s) ;
         MediaTracker tracker = new MediaTracker(this);
        tracker.addImage(img, 0);
        try {
            tracker.waitForAll();
        } catch(InterruptedException e) {
            System.err.println(e);
        }
        setSize(img.getWidth(this),
        img.getHeight(this));
    }
   
   
   
    // on applique notre filtre
    public static BufferedImage contour(BufferedImage img){
        float[] filter = { 0f, -1f, 0f, -1f, 4f, -1f, 0f, -1f, 0f };
        Kernel kernel = new Kernel(3, 3, filter);
        ConvolveOp op = new ConvolveOp(kernel);
        return op.filter(img, null);
    }

    public void paintComponent(Graphics g)  {
       try{
         g.drawImage(contour(createBufferedImage(img)),0,0,this);
        }catch(OutOfMemoryError e){
          System.err.println("Pass assez de mémoire !!!");
        }
   }

    /**
     * Transforme une image en bufferedImage
     * @param image l'image a transformer
     * @return Retourn l'image convertie ou null (si l'image source ete null)
     */
    public static BufferedImage createBufferedImage(Image img) throws OutOfMemoryError {
        if(img == null) return null;//si l'image est null pas besoin de continuer
        if (img instanceof BufferedImage)//si l'image est deja une instance de BufferedImage on la retourne
            return (BufferedImage) img;
      
        // On s'assure que l'image soit bien chargee
        img = new ImageIcon(img).getImage();

        //Determine si l'image contient ou non un pixel de transparence
        boolean hasAlpha = hasAlpha(img);

        int type;//type de couleur
      
        // On creer un BufferedImage ayant un format compatible avec l'environement graphique du pc
        BufferedImage bi = null;
        GraphicsEnvironment ge = GraphicsEnvironment.getLocalGraphicsEnvironment();
        try {
            //Maintenant on determine si le nouveau BufferedImage aura ou non un pixel de transparence
            type = Transparency.OPAQUE;
            if (hasAlpha) type = Transparency.BITMASK;

            // Creation de notre nouveau BufferedImage
            bi = ge.getDefaultScreenDevice()
                            .getDefaultConfiguration().
                                createCompatibleImage(
                                        img.getWidth(null), img .getHeight(null), type);
        } catch (HeadlessException e) {
            // Le systeme n'as pas d'ecran ?
        }

        if (bi == null) {
            // Si le BufferedImage precedement creer est null on en creer un avec un model par defaut
            type = BufferedImage.TYPE_INT_RGB;
            if (hasAlpha) type = BufferedImage.TYPE_INT_ARGB;
            bi = new BufferedImage(img.getWidth(null), img.getHeight(null), type);
        }

        // On copie l'image dans le BufferedImage
        Graphics g = bi.createGraphics();
        // maintenant on la dessine
       g.drawImage(img, 0, 0, null);
        g.dispose();
        return bi;
    }
  
    /**
     * Test si une image contient ou non un canal alpha
     * @param image l'image a tester
     * @return retourne vrai si elle en contien un
     */
    public static boolean hasAlpha(Image image) throws OutOfMemoryError {
        // si l'image et deja un BufferedImage alors pas besoin de checker le model de couleur
        if (image instanceof BufferedImage)
            return ((BufferedImage) image).getColorModel().hasAlpha();
        //utilisation d'un 'grabber' pour retrouver le model de couleur de l'image
        //normalement le grab du pixel en haut a gauche  est suffisant.
        PixelGrabber pg = new PixelGrabber(image, 0, 0, 1, 1, false);
        try {
            if(!pg.grabPixels()) return false;
        } catch (InterruptedException e) {
        }
        // on check si le model de couleur correspond ou non a un chanel alpha
        return pg.getColorModel().hasAlpha();
    }

}   

Ah oui, c'est une belle frame vide, c'est cool !

Mais sinon, qu'est-ce que tu veux qu'on fasse pour toi ?

reponse acceptée .

ja savais pas que je puisse un jour  reçevoir une telle reponse .

vous pouvez rien faire . je vous jure .

on est on forum d "echange!!!!

Mais mon pauvre ami, qu'est-ce que tu veux qu'on y fasse tu ne pose même pas une question !

C'est comme si tu va chez le garagiste, et que tu lui amène ta voiture sans rien lui dire... tu crois qu'il va vite aller décortiquer le moteur de ta voiture sans rien savoir toi ?

On n'est pas devin : On peut pas deviner ce que tu veux faire !

Donc oui, dans l'état actuel, on peut rien faire pour toi puisqu'on ne sais même pas quel est ton problème !

Je me doûte bien que tu ne souhaite pas obtenir une frame vide, cà je l'ai bien compris, mais explique nous qu'est-ce qui ne marche pas...

C'est le minimum pour qu'on puisse t'aider, tu crois pas ?

oui maintenant on est d accord,

mon probleme est :

-je declare une image ( image img) .
-je fais un filtre
 c pour cela j ai transformé mon image img en Bufferedimage (bi) .

c lors de l affichage que le problem

g.drawImage(img, 0, 0, null);
        g.dispose();
        return bi;

salut,
j'ai fais un programme dans ce cadre pour les appareils 3LCD j'ai défini les filtres et tout. tu dois juste l'adapter. a mon avis definit une zone de dessin avant genre JPanel définit tout ce que tu veux dedans, ce que tu veux déssiner et tout aprés c tt bon. si tu ve je pe te filer ce que j'ai fais comme boulot.
boncourage

salam ,
peux tu faire un filtre d une image blans et noir

j'ai pas tout compris . mais bon pe tu etre plus claire:
voila comment g défini les filtres :
public class FiltreDescription {
  /**
   * La matrice de convolution.
   */
  public double[][] matrice = new double[1][1];
  /**
   * Le diviseur du filtre.
   */
  public  double diviseur = 1;
  /**
   * Le décalage à appliquer au filtre (entre -255 et 255).
   */
  public  int decalage = 0;
  /**
   * Indique si le filtre s'applique sur la composante rouge.
   */
  public  boolean isRouge = true;
  /**
   * Indique si le filtre s'applique sur la composante vert.
   */
  public  boolean isVert = true;
  /**
   * Indique si le filtre s'applique sur la composante bleu.
   */
  public  boolean isBleu = true;

  /**
   * Construit un nouveau filtre par matrice de convolution.
   *
   */
  public FiltreDescription(double[][] matrice, double diviseur, int decalage, boolean isRouge, boolean isVert, boolean isBleu) {
    this.matrice = matrice;
    this.diviseur = diviseur;
    this.decalage = decalage;
    this.isRouge = isRouge;
    this.isVert = isVert;
    this.isBleu = isBleu;
  }
}
je défini comme ça le filtre . et pour filtrer ta la classe suivante:
import java.awt.*;
import java.awt.image.*;

public class FiltreImage{
  public FiltreDescription fil;
  public static final FiltreDescription FiltreRouge = new FiltreDescription(
    new double[][] {
      {1,2,1},
      {2,4,2},
      {1,2,1}},
      4, 0, true, false, false);
   public static final FiltreDescription FiltreVert = new FiltreDescription(
    new double[][] {
      {0,1,0},
      {1,4,1},
      {0,1,0}},
      4, 0, false, true, false);  
    public static final FiltreDescription FiltreBleu = new FiltreDescription(
    new double[][] {
      {1,2,1},
      {2,4,2},
      {1,2,1}},
      4, 0, false, false, true);
      public FiltreImage()
      {
          fil=new FiltreDescription(
    new double[][] {
      {1,2,1},
      {2,4,2},
      {1,2,1}},
      4, 0, true, false, false);
      }

 public BufferedImage filter(Image image, FiltreDescription filtre) {
    BufferedImage origine = new BufferedImage(image.getWidth(null), image.getHeight(null), BufferedImage.TYPE_INT_RGB);
    origine.getGraphics().drawImage(image, 0, 0, null);
    BufferedImage retour = new BufferedImage(origine.getWidth(), origine.getHeight(), BufferedImage.TYPE_INT_RGB);

    int pourcent = 0;
    int pixelsEffectues = 0;
    int maxPixels = retour.getWidth()*retour.getHeight();
    System.out.println(" on commence le filtrage");
    for (int x=0; x<origine.getWidth(); x++) {
      for (int y=0; y<origine.getHeight(); y++) {
        double newR = 0, newG = 0, newB = 0;
        for (int i=0; i<filtre.matrice.length; i++) {
          for (int j=0; j<filtre.matrice.length; j++) {
            int posx = x-i+(filtre.matrice.length+1)/2;
            int posy = y-j+(filtre.matrice.length+1)/2;
            if (posx <0) posx = 0;
            else if (posx >= origine.getWidth()) posx = origine.getWidth()-1;
            if (posy <0) posy = 0;
            else if (posy >= origine.getHeight()) posy = origine.getHeight()-1;

            int rgb = origine.getRGB(posx, posy);
            if (filtre.isRouge) newR = (int) (newR + ((rgb >> 16) & 0xFF) * filtre.matrice[i][j]);
            if (filtre.isVert) newG = (int) (newG + ((rgb >> 8) & 0xFF) * filtre.matrice[i][j]);
            if (filtre.isBleu) newB = (int) (newB + ((rgb) & 0xFF) * filtre.matrice[i][j]);
          }
        }
        newR = newR/filtre.diviseur + filtre.decalage;
        newG = newG/filtre.diviseur + filtre.decalage;
        newB = newB/filtre.diviseur + filtre.decalage;
        if (newR<0)newR = 0; if (newR > 255) newR = 255;
        if (newG<0) newG = 0; if (newG > 255) newG = 255;
        if (newB<0) newB = 0; if (newB > 255) newB = 255;
        if (!filtre.isRouge) newR = ((origine.getRGB(x, y) >> 16) & 0xFF);
        if (!filtre.isVert) newG = ((origine.getRGB(x, y) >> 8) & 0xFF);
        if (!filtre.isBleu) newB = ((origine.getRGB(x, y)) & 0xFF);
        retour.setRGB(x, y, 0xFF000000+((int) newR<<16)+((int)newG<<8)+(int)newB);
        pixelsEffectues++;
      }
    }
    System.out.println("fini le filtrage");
    return retour;
  }
}
si ça t'aide pas alors il faudrait que tu reformule ta question. j'espere t'avoir aidé.

la question est la suivante :

j ai une image blanc et noir et je dois faire un filtrage qui consiste a constituer une autre image tel que chaque pixel est egale la difference de 2 pixels successifs d image source

Salut,
c'est quoi deux pixels  successifs?. enfin que importe disons que dans le cadre de ce schéma :
p[i-1][j-1]  p[i][j-1] p[i+1][j-1]
p[i-1][j]  p[i][j] p[i+1][j]
p[i-1][j+1]  p[i][j+1] p[i+1][j+1]
supposons que tes deux pixels successifs sont :
 p[i-1][j-1]  p[i][j-1] et tu veux avoir la différence.
définit un type d'image qui te permet d'avoir accés a tes pixels.(ReadableImage avec la methode getPixel(x,y)).
faire des boucles de  parcours ( deux boucles) biensur en evitant les bords et les traitant a part.
tu prend la valeur en (i,j) et celle en (i+1,j) (dans ce que g compris en terme de pixels succesifs) et tu crée une image bufer pour mettre les valeurs. Franchement c pas la prog qui cause probleme c surtout comprendre ce qu'on veut programmer.
boncourage.