[Java] Déformation d'une image, redimension. [J2ME]

Twub Messages postés 16 Date d'inscription lundi 31 mars 2008 Statut Membre Dernière intervention 21 avril 2009 - 2 mai 2008 à 16:57
Twub Messages postés 16 Date d'inscription lundi 31 mars 2008 Statut Membre Dernière intervention 21 avril 2009 - 9 mai 2008 à 11:58
Bonjour a tous

Voila comme indiqué, je souhaite pouvoir déformer une image (dans mon cas c'est une texture), pour cela j'ai fais se code (Si vous avez des question hésitez pas ^^ ):

public void addTexture(Image _texture, Point _pGHaut, Point _pDHaut, int _yBas, boolean _transform)
    {

        if(_pGHaut.getX()>_pDHaut.getX())
        {
            Point BufPoint = _pDHaut;
            _pDHaut = _pGHaut;
            _pGHaut = BufPoint;
            _texture = Image.createImage(_texture, 0, 0, _texture.getWidth(), _texture.getHeight(), Sprite.TRANS_MIRROR);
        }
        
        if(_pGHaut.getY()>_yBas || _pDHaut.getY()>_yBas || _yBas > this.__height)
        {
            return;
        }
        else
        {
            if(_transform==true)
                _texture = Image.createImage(_texture, 0, 0, _texture.getWidth(), _texture.getHeight(), Sprite.TRANS_MIRROR);
            
            Image textDeforme = deformerImage(_texture, _pDHaut.getX()-_pGHaut.getX(), _yBas-_pGHaut.getY(), _yBas-_pDHaut.getY());
            int x = _pGHaut.getX();
            int y = 0;
            
            if(_pGHaut.getY()>_pDHaut.getY())
                y = _pDHaut.getY();
            else 
                y = _pGHaut.getY();
            
            afficherImage(textDeforme, x, y);
        }
    }
    
    public Image deformerImage(Image _image, int _largeur, int _hauteur1, int _hauteur2)
    {
        
        int oldWidth = _image.getWidth();
        int oldHeight = _image.getHeight();    
        int[] oldImage = readImage(_image);
        
        int cas = 0;
        double dy = 0.0;    
        int air = 0;
        int larg = 0;
        
        if(_hauteur1>_hauteur2)
        {
            cas = 1;
            dy = ((double)_hauteur1-(double)_hauteur2)/(double)oldWidth;    
            air = oldWidth*_hauteur1;
            larg = (oldWidth*(_hauteur1-1));                
        }
        else
        {
            dy = ((double)_hauteur2-(double)_hauteur1)/(double)oldWidth;    
            air = oldWidth*_hauteur2;    
            larg = (oldWidth*(_hauteur2-1));
        }
        
        int lon = (oldWidth*(oldHeight-1)); 
        double newHauteur = (double)_hauteur1;
        int[] newImage = new int[air];
        int[] bufImTab = null;
        Image newIMAGE = null;
        
        for(int i=0; i<oldWidth; i++)
        {
            bufImTab = new int[oldHeight];
            
            //recupe tout une bande de hauteur
            for(int j=0;j<oldHeight;j++)
                bufImTab[j] = oldImage[i+lon -(j*oldWidth)];
            
            //On la redimensionne
            bufImTab = readImage(redimImage(Image.createRGBImage(bufImTab, 1, oldHeight, true), 1, (int)newHauteur));
            
            //On la place dans la nouvelle image
            for(int k=0;k<(int)newHauteur;k++)
            {
                if(newImage[k]==0)
                    newImage[k] = defineColor(0,0,0,0);
                    
                newImage[i+larg-(k*oldWidth)] = bufImTab[k];
            }
            
            if(cas == 0)
                newHauteur +=dy;
            else
                newHauteur -=dy;
        
        }
        
        if(cas==1)
        {
            return redimImage(Image.createRGBImage(newImage, oldWidth, _hauteur1, true),_largeur, _hauteur1);
        }
        else
        {
            return redimImage(Image.createRGBImage(newImage, oldWidth, _hauteur2, true),_largeur, _hauteur2);    
        }
            
    }
    
    public Image redimImage(Image _image, int _longueur, int _hauteur)
    {
        int sourceWidth = _image.getWidth();
        int sourceHeight = _image.getHeight();
        int redimWidth = _longueur;
        int redimHeight = _hauteur;
        
        int[] oldImage = readImage(_image);
        int[] newImage = new int[redimWidth*redimHeight];
        int compteur =0;
        Image redimImage = Image.createImage(redimWidth, redimHeight);
        
        if(redimWidth > __width)
            redimWidth = __width;
            
        if(redimHeight > __height)
            redimHeight = __height;
        
        if (redimHeight < 0)
            redimHeight = redimWidth * sourceHeight / sourceWidth;
        
        for (int y = 0; y < redimHeight; y++)
        {
            for (int x = 0; x < redimWidth; x++)
            {

                int dx = x * sourceWidth / redimWidth;
                int dy = y * sourceHeight / redimHeight;
                newImage[compteur] = oldImage[dx+dy*sourceWidth];
                compteur++;
            }
        }
       
        redimImage = Image.createRGBImage(newImage, redimWidth, redimHeight, true);
       
        return redimImage;
    }
    
    public void afficherImage(Image _image, int _x, int _y)
    {
    
        int[] imData = readImage(_image);
        int width = _image.getWidth();
        int height = _image.getHeight();
        int compteurX = 0;
        int compteurY = 0;
        
        for(int i=_y;i<(height+_y);i++)
        {
            
            for(int j=_x;j<(width+_x);j++)
            {
                if(0 <= j &amp;&amp; j <= this.__width &amp;&amp; 0 <= i &amp;&amp; i <= this.__height)
                    this.__tabJeux[j+(i*this.__width)] = imData[compteurX+compteurY*width];
                compteurX++;
            }
            
            compteurX = 0;
            compteurY++;
        }
    }
    
    public int[] readImage(Image _image)
    {
        int[] argbdata = new int[_image.getWidth()*_image.getHeight()];
        
        _image.getRGB( argbdata, 0,  _image.getWidth(),  0,  0,  _image.getWidth(),  _image.getHeight());
        
        return argbdata;
    }   


Je pense que mon algo n'est pas le plus optimisé...   j'aimerais beaucoup un coup de main pour sa

Merci ;)

Twub

8 réponses

cs_DARKSIDIOUS Messages postés 15814 Date d'inscription jeudi 8 août 2002 Statut Membre Dernière intervention 4 mars 2013 130
2 mai 2008 à 17:04
Salut,

As-tu jeté un oeil sur ma source DKS_Warp_Editor ?

Je pense qu'elle pourrait t'intéresser !
______________________________________
DarK Sidious
0
Twub Messages postés 16 Date d'inscription lundi 31 mars 2008 Statut Membre Dernière intervention 21 avril 2009
2 mai 2008 à 17:10
Euh, je cherche mais je trouve pas ^^

Tu pourrais m'indiquer ou le télécharger stp ^^

merci a toi je vais y jeter un coup d'oeil
0
Twub Messages postés 16 Date d'inscription lundi 31 mars 2008 Statut Membre Dernière intervention 21 avril 2009
2 mai 2008 à 17:20
En fait c'est bon j'ai trouvé ^^

Je regarde ce que t'as fais, mais la déformation que je fais est beaucoup moins poussé que la tienne.
Je travaille pour ma part sur le tableau de pixel de l'image que je veux déformer, et mes actions reste assez simple, mais il me semble que j'ai du faire 2/3 erreurs d'algorithme. non?

En fait je cherche a optimiser mon code, et l'améliorer bien sur
Je vais regarder ce que tu as fais plus en détail, mais si jamais tu as une idée pour mon code, n'hésite pas ;)

Merci
Twub
0
cs_DARKSIDIOUS Messages postés 15814 Date d'inscription jeudi 8 août 2002 Statut Membre Dernière intervention 4 mars 2013 130
2 mai 2008 à 17:38
Salut,

Ben disont que j'ai pas vraiment regardé ton algo, vu le nombre de ligne, j'ai la flemme de voir à quoi il sert. Explique moi quel type de transformation du veux faire.

L'API que j'utilise pour faire le warp (JAI) permet de manipuler les images de façon très efficace (il y a un wrapper pour des accès système sous forme de dll, ce qui optimise les performances), et c'est pensé pour faire des manipulations de pixels, ou d'images de manière efficace.
______________________________________
DarK Sidious
0

Vous n’avez pas trouvé la réponse que vous recherchez ?

Posez votre question
Twub Messages postés 16 Date d'inscription lundi 31 mars 2008 Statut Membre Dernière intervention 21 avril 2009
5 mai 2008 à 09:40
Bonjour,

en fait le bout de code permet d'aprés une image existante (texture pour mon cas) de la transformer, c'est a dire je lui donne le point gauche en haut(x et y), le point droit en haut (x et y) et le y du bas, donc l'image va s'allonger du coté gauche ou droit en hauteur.
Le warp semble trés complet seulement mon programme qui utilise en autre la déformation de ma texture doit etre utilisable sur téléphone portable, je ne peux donc pas utiliser une API tel que JAI qui n'est présente sur aucun téléphone.

Merci en tout cas de te pencher sur mon probleme ^^

Twub
0
cs_DARKSIDIOUS Messages postés 15814 Date d'inscription jeudi 8 août 2002 Statut Membre Dernière intervention 4 mars 2013 130
5 mai 2008 à 12:42
Salut,

Ok, c'est un simple étirrement ? Ettirer la taille de la texture ?

Tu as les fonctions standard de Graphics2D pour faire cà.

Si c'est étirer dans une direction, c'est le share (toujours de Graphics2D) qu'il faut utiliser (pas sûr de la nomenclature).
______________________________________
DarK Sidious
0
Twub Messages postés 16 Date d'inscription lundi 31 mars 2008 Statut Membre Dernière intervention 21 avril 2009
5 mai 2008 à 14:26
Bonjour,

Pas exactement, mon image gardera une base plate, mais la hauteur de gauche et de droite pourra varier, former un trapeze avec une image d'origine rectangulaire.

Autre soucis, je suis sous j2me et je ne possede pas cette librairie la...
Je fais donc de telle fonction moi meme.

Mais la je bloque, je suis sur que je pourrais mieux faire, mais comment? ^^

Twub
0
Twub Messages postés 16 Date d'inscription lundi 31 mars 2008 Statut Membre Dernière intervention 21 avril 2009
9 mai 2008 à 11:58
Bonjour,

Je pense avoir résolu mon probleme merci de tes infos ;)

A plus,
Twub
0
Rejoignez-nous