Bonjour!
 
Alors voilà, j'aimerais vos avis avant de me lancer dans un truc de malade pour mon projet!
 
Je voudrais donc pouvoir appliquer un traitement sur des pixels d'une image (et non pas sur toute l'image à la fois) ouverte par l'utilisateur. J'ai déja fait mon filechooser avec swing tout ça, mais maintenant je vais utiliser JAI pour le traitement de l'image.
 
Ma question est donc: quelle est la meilleure methode (y'en a à peu près 100000000) pour faire du traitement sur des pixels choisis par l'utilisateur? Je veux dire par là que l'utilisateur cliquera sur l'endroit de l'image qu'il veut traiter, et un traitement sera appliqué sur une zone définie par l'utilisateur (rayon) autour du pixel cliqué.
 
Je veux dire par là, une TiledImage est elle préférable? Si j'ai bien compris une PlanarImage de base ne permet que la lecture! Je suis en train de lire ça, mais c'est énorme:
 
http://java.sun.com/products/java- [...] guide-unc/
 
Je ne demande pas de code, rien de tout ça, juste un petit peu d'aide sur l'organisation à prévoir pour le traitement sur des pixels, car pour moi c'est tout nouveau JAI... J'ai vu que pleins d'opérateurs existaient pour les traitements, mais est-ce possible juste sur des pixels?
 
Autre question, est-il préférable de laisser l'image à 100% avec des scroll, pour que l'utilisateur clique sur l'endroit de l'image qu'il veut traiter, ou bien est-ce possible sur un resize de l'image, et dans ce cas est-ce précis? Je me doute bien que la taille resizée  de l'image de base doit jouer, mais que feriez vous?
 
Bref, vous l'aurez compris, j'ai besoin d'aide...
 
En vous remerciant d'avance, si vous avez besoin d'autres renseignements, je suis toute ouïe...
 

Ou alors, connaitriez-vous un code super bien commenté, ou même un tutorial basique utilistant JAI? Merci!

Personne fait de JAI?

Bon, je me permet de reposter, j'ai avancé dans mon projet, j'ai l'interface, et maintenant je voudrais faire le traitement de l'image.

En fait ce que je veux faire c'est un logiciel qui traite une image, regarde si  elle a des tâches ( notamment comme des poussières sur un scan de négatif ou des poussières sur le capteur d'un reflex numérique) et corrige ces tâches par des pixels calculés sur une approximation des pixels environnant la tâche.
Oui ça ressemble au tampon de photoshop, et au filtre dust&scratches, c'est ce que je veux reproduire, mais en libre

Par contre pour la methode, j'hésite!

Est-ce que je demande à l'utilisateur de cliquer sur la tâche, et je calcule les nouveaux pixels avec des paramètres rentrés par l'utilisateur? Ou bien j'essaye de detecter les tâches avec des seuils rentrés par l'utilisateur   Je pense par exemple à la transformation de Sobel, y'en a peut-être d'autres?

Je me demande si la 2ème possibilité est réellement faisable, peut-être ne me rends-je pas compte de la difficulté de la chose!!!

Au final, je devrais calculer les nouveaux pixels remplacant la tâche, je pensais utiliser la matrice de convolution, vous en pensez quoi?

Je suis assez perdu concernant la methode, toute aide (même un tout petit peu ) est bienvenue!

En esperant des réponses...

Up desesperé...

Up

Bonjour,  
je ne suis pas expert quant à la méthode dust&scratches mais je vais essayer d'exposer les méthode que j'utiliserais .
 
 
Si je me souviens bien Sobel va te donner une approximation assez bonne du gradien en 2 passes (la laplacien étant plus exacte en 1 seule passe), ce qui va faire ressortir chaque zone où il y a un changement brusque de couleur (c'est comme ça qu'on calcule les bump map en 3d). De ce fait il est pratiquement impossible de déterminer algorithmiquement ce qui est une tâche parasite ou une tâche "naturelle", sauf faire un arbre de décision tres complexe issu de statistiques poussées (on rentre dans l'IA là ...)
 
Pour la suppression d'une tâche, j'utiliserais une convolution toute simple de flou avec un poid de pixel faible pour chaque pixel ayant un gradient fort ...
 
Pour information tout ceci me parait largement faisable sans JAI, java2D le permettant.
 
   

Merci 1000 fois pour ta réponse!!!!!!!!!!!!!!!!!!

Pourrais tu m'expliquer ta phrase "Pour la suppression d'une tâche, j'utiliserais une convolution toute simple de flou avec un poid de pixel faible pour chaque pixel ayant un gradient fort ..." si possible?

La matrice de convolution je vois, mais je ne comprends pas ce que tu veux dire par un poids de pixel faible? Tu veux dire un pixel avec une couche alpha dont l'opacité est faible?
Et pour le gradient de pixels, tu veux dire quoi? Merci en tout cas.

Je vais opter pour la méthode "clic sur la tache sous forme de rond" finalement. Je me suis torturé l'esprit à essayer de penser comment j'allais faire ça, et j'ai pensé à ça:
- Je laisse l'utilisateur choisir le rayon de la tâche.
- Il clique sur la tâche, l'appli regarde les pixels les plus à l'exterieur du cercle cliqué, récupère leur valeur, fait une moyenne de tous ces pixels à l'exterieur, et donne cette même valeur aux pixels plus à l'interieur du cercle, plus éventuellement un flou pour homogeniser le tout...

Cela te semble-t-il une bonne méthode? Tu peux le dire si c'est carrément pas bon

En tout cas merci pour ton aide, c'est vraiment apprécié...

Pour ce qui est d'utiliser Java2D, j'ai déjà commencé en JAI, pour le moment j'ai  mon filechooser, j'ouvre l'image et je récupère les coordonnées que l'utilisateur double clique sur l'image (qui est dans un JScrollpane)... Ca parait rapide mais j'y ai mis le temps

Ce qu'il me reste à faire, juste pour info:

- faire l'interface utilisateur des options de "brosse", notamment le rayon, et peut-être autre chose, mais je vois pas pour le moment...
- L'algo de calcul des nouveaux pixels de la tâche, c'est le plus interessant sûrement
- un truc qui permet de revenir un pas en arrière
- La sauvegarde de l'image modifiée, qui ma foi n'a pas l'air bien dure, d'après ce que j'en ai vu.

Merci encore...

Voilà, ce que je ferais (ça n'engage que moi):
 
1ère étape:
l'utilisateur sélectionne une ou plusieur "tâches" (avec des carrés c'est plus pratique, mais on peut s'arranger avec des cercles)
 
2ème étape:
Calcul du gradient de l'image, c'est à dire pour faire simple qu'on fait ressortir tout les contours des éléments de l'image en niveau de gris. Les "taches" seront en blanc et les zones uniformes en noir.
Pour cela, il est hors de question de faire une somme de dérivées partielles (trop coûteux en temps), heureusement il existe une bonne approximation avec la matrice de convolution de Laplace : (version la plus simplifié et la plus efficace)
0  -1  0
-1  4  -1
0  -1  0
Il faut voir cela comme une grille de pixels, c'est à dire que chaque pixel recoit une valeur qui est fonction de ces 8 voisins.
Par exemple ici le pixel du centre à un poids de 4 et son voisin à droite un poids de -1.
En somme on se retrouve avec une image de la même taille que celle de départ mais en niveau de gris faisant ressortir les contours.
 
étape 3:
On applique un flou là où l'image des contours est blanche (et correspond à une zone de sélection de l'utilisateur).
Seulement ça ne denera pas un résultat propre, puisque les zones floutées le sont de manière homogènes.
Pour résoudre ce problème, il faut adapter le flou au niveau de gris du pixel qu'on est en train de traiter (images des contours). Si par exemple le pixel est blanc alors il faut augmenter le poids des pixel adjacents dans la matrice de convolution pour le faire disparaitre comme par exemple:
0 1/4 0
1/4 0 1/4
0 1/4 0
inversement si le pixel est noir on met tout ces voisins à 0 et il reste lui-même
s'il est gris, il faut trouver un bon compromis (en normalisant la matrice bien entendu).
 
Voilà j'espère avoir été compréhensible.

Salut,
 
est ce tu pourrais poster un exemple d'image et identifier dessus les "taches" que tu voudrais enlever ?
 
edit : le flou proposé par fab peut être une solution, mais ça va modifier toute ton image avec une impression de flou relativement désagréable pour l'utilisateur. décrit mieux ton problème tu trouveras plus facilement la solution.

Merci beaucoup pour ta réponse très détaillée.

J'ai pour le moment implémenté une selection par curseur sous forme de cercle, dont l'utilisateur peut faire varier le diamètre avec un slider.
Pour la transfo de Laplace, ça marcherait je pense, une fois ça fait j'aurai mon image en niveaux de gris donc.
Comme tu le dis bien, il y aura un problème pour les gris. Le compromis pourrait être un paramètre donné par l'utilisateur, ou pas? Pourrais-tu m'expliquer, dans ton 3ème point, comment tu trouves ta matrice
 0 1/4 0
1/4 0 1/4
0 1/4 0 ?

Tu parles de normaliser la matrice, je suis pas sûr de bien saisir en fait  

Epok, le traitement peut se faire sur une partie de l'image seulement, je choisirais sûrement un cercle, celà se fait avec des ROI (Region of Interest) sans problème normalement (j'y ai pas encore touché )

Un exemple de poussières sur une image:

Merci en tout cas.

 
tu veux corriger quoi sur cette image ?

Ben les 10000 poussières qu'il y a dessus

Rebonjour,

En fait maintenant j'aimerais dessiner un petit carré vide sur mon image, je m'explique...

En fait j'aimerais pouvoir dessiner la zone que je veux traiter sous la forme d'un cadre carré de la dimension choisie par l'utilisateur, et être capable de l'effacer, d'en refaire un... tout ça sur l'image.

Je ne sais pas trop comment faire, j'ai vu qu'il etait possible d'utiliser un objet graphics sur une BufferedImage, mais est-ce flexible? Je veux dire,  il me faudrait 2 couches en fait, une où je gère le carré de la taille choisie par l'utilisateur (la zone à traiter) et que l'utilisateur peut effacer, et refaire ailleurs, et l'autre avec l'image en-dessous, pour pouvoir voir où positionner le carré que l'utilisateur veut...

Quelqu'un aurait une idée de la methode préférable à utiliser?

Merci beaucoup...

Up!

Un JLayeredPane serait-il une bonne solution pour ça ou il y a-t-il plus simple?

Pour revenir au problème du traitement de l'image, la methode de Laplace donne les contours de la tâche, mais le centre de ma tâche sera noir, donc le traitement se fera sur les contours seulement... Ou bien je loupe quelquechose? Sobel a l'air de donner toute la tâche, je sais pas trop quoi utiliser.

Sinon, convertir l'image en niveaux de gris, et augmenter le contraste pour faire ressortir la tâche pourrait être une solution?

Sinon, comment generer du flou sur des pixels seulement, et pas sur toute l'image?

Je sais vraiment pas par quel bout prendre le problème là, surtout que ça commence à urger pour mon projet

Toute aide est précieuse... Merci!

Bon j'ai fait mon truc, j'ai utilisé Laplace .
 
Il me manque juste le flou sur des pixels choisis et non pas sur un rectangle...
 
Help!!!!

Hello!

Alors voilà j'ai fini mon programme (je dois rendre demain ), si ça interesse quelqu'un je pourrais mettre les sources sur mon FTP...

Faut juste me dire si ça vous interesse au cas où

(Pour l'info j'ai fait le flou manuellement à la bourrin avec la moyenne des 8 pixels environnant pour chaque pixel à traiter )

salut  
delantera
je me  demande si tu peux me donner les source de ton programme ca serai tres gentil
mon adresse et nonosa2000@hotmail.com