Java redimensionner le centre de l'image

Question

Je regardais autre chose l'autre jour et je me sens comme je me souviens de courir à travers un moyen de redimensionner une image, mais en gardant une zone le long des côtés de l'image inchangée de sorte que les bords arrondis des images seront toujours regarder la même chose, peu importe la longueur de l'image mise à l'échelle. Après un peu de googling je ne peux pas trouver ce que je me souviens de voir donc je voudrais savoir si cela est possible et si quelqu'un a et info. En particulier, ce que j'ai est une bordure personnalisée avec ce qui est censé ressembler à une étiquette suspendue avec une étiquette dessus. L'image est carrée sur le dessus et arrondie sur les bords inférieurs. Je voudrais garder les coins arrondis du bas, peu importe la longueur des étiquettes, mais étirer le centre ~ 90% pour accommoder les grandes étiquettes. Je suppose que ce serait dans ce code quelque part où je peux entrer des encarts? dans la méthode de redimensionnement.

titleLabel = new JLabel(title){ 
      public void paint(Graphics g){ 
       g.drawImage(tabImg, 0, 0, this.getSize().width, this.getSize().height, null); 
       g.drawString(this.getText(), 1, this.getFont().getSize()); 
      } 
     }; 

Answer 1

OK, compte tenu de l'absence de méthode acceptée pour ce faire, je suis venu avec cette solution et je suis affichant le code pour quelqu'un d'autre qui voudrait faire quelque chose de similaire. Ce code prendra une image et la divisera en 9 sections. Les 4 coins seront laissés seuls. les milieux des 4 bords seront étirés ou comprimés le long du bord. La section centrale sera étirée ou comprimée dans les deux directions. Bien sûr, le but de cette classe pour moi était de compresser une image plus grande avec des coins arrondis mais garder les coins arrondis qui ont presque disparu lorsque l'image était simplement réduite. Évidemment, cela ne fera pas grand-chose avec une image comme une image, mais pour les composants avec une peinture personnalisée et des bords arrondis, cela semble fonctionner correctement.

Il n'y a pas de constructeur pour cette classe, vous pouvez tout simplement appeler pour une image modifiée. l'utilisation serait

StretchedImage.stretch(image, new Insets(t,l,b,r), new Dimension(w,h), BufferedImage.TYPE_INT_ARGB); 

Ceci renvoie une image étirée à la dimension souhaitée avec les coins restant le même et les côtés seulement être modifié dans une dimension à l'aide du paramètre empiècements pour déterminer le montant autour du bord qui est modifié dans une seule dimension. Il y a probablement une manière délicate d'itérer à travers les listes d'images mais de cette façon je pourrais mieux voir ce qui se passait.

public class StretchedImage{ 

public static Image stretch(Image image, Insets ins, Dimension dim, int hints){ 
    //debugcode 
    //System.out.println(dim); 

    //load image into bufferedImage 
    BufferedImage bi = toBufferedImage(image, hints); 

    //create 2d bufferedImage array to hold the 9 images 
    Image[][] img = new Image[3][3]; 

    //split Image into 9 subsections 
    img[0][0] = bi.getSubimage(0, 0, ins.left, ins.top); 
    img[0][1] = bi.getSubimage(ins.left, 0, bi.getWidth() - ins.left - ins.right, ins.top); 
    img[0][2] = bi.getSubimage(bi.getWidth() - ins.right, 0, ins.right, ins.top); 
    img[1][0] = bi.getSubimage(0, ins.top, ins.left, bi.getHeight() - ins.top - ins.bottom); 
    img[1][1] = bi.getSubimage(ins.left, ins.top, bi.getWidth() - ins.left - ins.right, bi.getHeight() - ins.top - ins.bottom); 
    img[1][2] = bi.getSubimage(bi.getWidth() - ins.right, ins.top, ins.right, bi.getHeight() - ins.top - ins.bottom); 
    img[2][0] = bi.getSubimage(0, bi.getHeight() - ins.bottom, ins.left, ins.bottom); 
    img[2][1] = bi.getSubimage(ins.left, bi.getHeight() - ins.bottom, bi.getWidth() - ins.left - ins.right, ins.bottom); 
    img[2][2] = bi.getSubimage(bi.getWidth() - ins.right, bi.getHeight() - ins.bottom, ins.right, ins.bottom); 

    //determine the width and height of the sections that will be stretched 
    //only the center section will have both dimensions changed 
    int w = dim.width - ins.left - ins.right; 
    int h = dim.height - ins.top - ins.bottom; 

    //Stretch the proper sections 
    img[0][1] = img[0][1].getScaledInstance(w, img[0][1].getHeight(null), hints); 
    img[1][0] = img[1][0].getScaledInstance(img[1][0].getWidth(null), h, hints); 
    img[1][1] = img[1][1].getScaledInstance(w, h, hints); 
    img[1][2] = img[1][2].getScaledInstance(img[1][2].getWidth(null), h, hints); 
    img[2][1] = img[2][1].getScaledInstance(w, img[2][1].getHeight(null), hints); 

    //for loop is debug code 
    //for(int i = 0; i < 3; i++){ 
    // for(int j = 0; j < 3; j++){ 
    //  System.out.println(i + " " + j + " " + img[i][j].getWidth() + "," + img[i][j].getHeight()); 
    // } 
    //} 

    //create a new bufferedImage to hold the final image 
    BufferedImage finalImage = new BufferedImage(dim.width, dim.height, hints); 
    Graphics g = finalImage.getGraphics(); 
    //draw the peices to the final image 
    g.drawImage(img[0][0], 0, 0, null); 
    g.drawImage(img[0][1], ins.left, 0, null); 
    g.drawImage(img[0][2], dim.width - ins.right, 0, null); 
    g.drawImage(img[1][0], 0, ins.top, null); 
    g.drawImage(img[1][1], ins.left, ins.top, null); 
    g.drawImage(img[1][2], dim.width - ins.right, ins.top, null); 
    g.drawImage(img[2][0], 0, dim.height - ins.bottom, null); 
    g.drawImage(img[2][1], ins.left, dim.height - ins.bottom, null); 
    g.drawImage(img[2][2], dim.width - ins.right, dim.height - ins.bottom, null); 

    return (Image)finalImage; 
} 

// This method returns a buffered image with the contents of an image 
public static BufferedImage toBufferedImage(Image image, int hints) { 

    BufferedImage bi = new BufferedImage(image.getWidth(null), image.getHeight(null), hints); 
    bi.getGraphics().drawImage(image, 0, 0, null); 

    return bi; 
} 

}