Bonjour,  
 
J'ai à ma disposition un tableau de byte, chaque case contenant les valeurs d'un pixel d'une image de vidéo. Je voudrai prendre une partie de ce tableau pour l'agrandir en dupliquant les pixels.  
La contrainte c'est qu'il faut que le tableau d'arrivé est la même taille que le tableau d'origine. Avez-vous une idée, un algo pour réaliser cela?  
Merci d'avance!

donc en gros tu veux afficher 2 fois plus de pixels que sur l'image originale en en utilisant pas plus, c'est ça?

il se pourrait tres bien que je n'ai pas du tout compris (je suis pas tres fut-fut), pas la peine de s'exciter hein

 
je garde ca en souvenir

moi je le sais au moins

lol nan c'est pas tout à fait ca :-) je prends une sous partie z du tableau x. Il faudrait que le tableau z est la même taille que le tableau original x en duppliquant les valeurs de z. ceci pour créer un effet de zoom j'ai été assez clair la? :-)

ben euh tu fais une bete boucle quoi

lol si c'était si simple je serai preneur le problème c'est trouver le nombre de pixels que tu dois duppliquer et dans quel proportions...

ha euh ok j'etais parti sur l'idée que tu faisais du 200%
 
bah regle de 3

la règle de 3?

ben faut faire ta grande matrice de point, et remplir les vides en interpolant, apres, a toi de choisir si tu fais du lineaire, du carre, du cubique etc...
 
y a ca aussi, ca peut peut-etre t'aider :  
 http://www.tsi.enst.fr/tsi/enseign [...] terpol_tv/

En gros, tu crées un nouveau tableau de la taille de l'ancien, tu y met les points d'origine de ton image, qui étaient situés dans la zone à agrandir. Par contre, tu ne les metpas n'importe où : il faut les répartir équitablement dans ta nouvelle image.Donc,; si ton image d'origine mesurait "x*y" et que la zone à zoomer mesure "zx*zy", tu met une ligne de points toutes les "(int) y/zy" pixels, et une colonne de pixels tous les "(int) z/zx"  
 
Tu obtiens donc un tableau avec des cases vides, et des pixels "colorés" sur un maillage de "(int) y/zy" pixels en vertical, et "(int) z/zx" en horizontal : il ne te reste donc plus qu'à boucher les trous par interpolation, comme l'a judicieusement suggéré Souk..
 
Le problème, c'est de faire l'interpolation avec un tableau mono-dimensionnel : si ton tableau n'a qu'une 'ligne' pour représenter ton image, tu vas être embêté pour l'interpolation (enfin, pas vraiment, mais au niveau des calculs des indices des cases à utiliser pour calculer la couleur des points environnants, ça va être galère)
 
Ouala ouala.

 
Paf, planté !

c'est un nouvel algo qui vient de sortir
 
(c'est pour rigoler, hein)

 
mais...mais...beuuuuuh!! J'te mewde, d'abord!!
 
(T'en a déjà vu, des argumentations comme ça?? Noooon mais, attends avant 9h du mat, je demande un droit de plantage!)

Attention au phénomène de "pixellisation" si le facteur de zoom demandé est trop grand. Je ne sais pas si ce phénomène a du sens dans ton cas, mais s'il en a, il va falloir non pas simplement recopier les valeurs, mais en créer en interpolant les valeurs existantes.

c'est un peu ce que gfive a dit non ??

pour une interpollation bicubique, y a mon pote google qui m'a trouve ca, y a la formule toute faite pour combler les vides de la grande matrice
 
 http://astronomy.swin.edu.au/~pbourke/colour/bicubic/
 
en esperant que ca t'aide  

Euuh, bah non, je parlais du problème en cas de structure de données à la con :  
 
J'ai vu des gens coder des images comme ça :  
 
[cpp]
byte[] pixels;
int width;
/cpp]  
 
Du coup, le tableau pixels fait width*height cases....Avec un bordel de ce genre, le calcul de la case où mettre une valeur d'interpolation, et celui des cases où prendre les valeurs de base poour l'interpolation est plus prise de tête que l'interpolation elle même, je suis sûr!!
 
Attends....Pour la case i, le pixel du dessus est à la case i-width, le pixel de droite est à i+1, sauf si (i mod (width - 1)) = 0 (bord de droit de l'image)....et width-1 parce que les indices commencent à 0..
 
Bref, le bonheur, quoi!!

bha ....

Merci à toi, souk : lL'interpolation bicubique est un algorithme classique très performant (c'est celui qu'on trouve dans Photoshop par exemple), et il marche beaucoup beaucoup mieux qu'une bête interpolation linéaire. A savoir quand même qu'il ne marche bien que jusqu'à un facteur de zoom 4x (2x en largeur, 2 fois en hauteur). Au-delà, l'effet de zoom se voit malgré tout, et il faut passer à des algorithmes beaucoup plus compliqués (genre ce que fait Genuine Fractals), mais là, je doute que tu trouves un algo dans le domaine public : tout doit être soumis à brevet dans tous les sens !    
 
benou> Ton code ne compile pas, il manque un "int" dans le prototype...

n'empeche l'explication de gfive, certes plus comprehensible, est basée sur une regle de 3

ha oui tiens ...

 
pour ceux qui ont acces a de la litterature y'a un tres bon article dans graphics gem III pour ce genre de sport. C ce que j'ai utilise pour ma routine et ca me refile de tres bon resultats

Hé ben vous êtes super actif sur ce forum c'est cool!  
Merci pour votre aide à tous !

 
Ah ouais....:D Kelkon!!

 
bof, pas tant que ca, moi aussi j'ai toujours les boules de ce genre de chose, c'est tellement facile de se planter  

 
Ben ouais, mais mon truc sert juste à calculer les positions des points qui serviront de base à l'interpolation.....

mais j'ai pas dit que j'avais répondu quelquechose de très intelligent non plus

 
D Et pourtant, on est ni lundi, ni vendredi!! On bosse trop....

Sinon pour info, on peut faire ce genre de chose avec l'API standard mais ce sera du bilinéaire (un peu moins bon que le bicubique mais plus rapide).
 
En gros la démarche est la suivante :
 
- créer un WritableRaster à partir de la sélection de l'image de départ (rasterSource)
- créer un second WritableRaster à partir du premier mais avec les dimensions de l'image (rasterDestination)
- créer un objet AffineTransform qui se charge de transformer une image 2D en une autre image 2D (c'est une bête matrice 3x3)
- créer un objet AffineTransformOp qui se chargera d'appliquer le filtre sur rasterSource pour obtenir rasterDestination. C'est là qu'on choisit le mode d'interpolation : nearest neighbor (bof) ou bilinear.
- modifier l'image de départ avec rasterDestination.
 
 
J'avais fait un projet il y a quelques temps qui utilisait tout cela. Si ça t'intéresse je peux coller le code ici.
 
 
Edit: sinon il est sûrement possible de faire du bicubique avec JAI. A vérifier.