Отрегулируйте размер изображения, чтобы полностью соответствовать jFrame

Question

Я хочу отрегулировать размер logo2.png так, чтобы он полностью соответствовал jFrame. Может кто-нибудь мне помочь?

jLabel2 = new javax.swing.JLabel(); 

jLabel2.setIcon(new javax.swing.ImageIcon(getClass().getResource("/Banking/logo2.png"))); // NOI18N 

JDesktopPane.add(jLabel2); 
jLabel2.setBounds(0, 0, 500, 290); 

Answer 1

Сначала получите Image, а затем использовать этот метод:

yourImage.getScaledInstance(newWidth, newHeight, Image.SCALE_DEFAULT); 

Вы можете получить ширину и высоту от JFrame. Затем вы можете преобразовать изображение в ImageIcon и добавить его.

Answer 2

JLabel не отмасштабировать его содержание (то есть изображение), для того, что вы будете иметь, чтобы получить вам руки немного грязные ...

Есть целый ряд способов для достижения этой цели. Лично я бы начал с пользовательского компонента, который простирается от чего-то вроде JPanel, который берет базовое изображение и способен масштабировать и рисовать его.

Посмотрите на Performing Custom Painting и Painting in AWT and Swing для получения дополнительной информации о выполнении пользовательской покраски.

Масштабирование изображения не так прямолинейно, как может показаться, в то время как Java действительно предоставляет некоторые API для масштабирования изображений, как правило, они не генерируют фантастических результатов. Взгляните на Quality of Image after resize very low -- Java и The Perils of Image.getScaledInstance() для более подробной информации.

Обычно я рекомендую взглянуть на библиотеку imgscalr, так как ее результаты в целом неплохие (лучше того, что предоставляет базовый Java API или я видел в большинстве других методов), но для этого примера, ve включил пример разделительного подхода.

Этот пример дает «масштаб для заполнения» реализации, это гарантирует, что полученное изображение всегда заполняет свободное пространство, сохраняя при этом его пропорции, см Java: maintaining aspect ratio of JPanel background image для более дискуссий по этому вопросу

import java.awt.Dimension; 
import java.awt.EventQueue; 
import java.awt.Graphics; 
import java.awt.Graphics2D; 
import java.awt.HeadlessException; 
import java.awt.RenderingHints; 
import java.awt.Transparency; 
import java.awt.image.BufferedImage; 
import java.io.File; 
import java.io.IOException; 
import javax.imageio.ImageIO; 
import javax.swing.JFrame; 
import javax.swing.JPanel; 
import javax.swing.UIManager; 
import javax.swing.UnsupportedLookAndFeelException; 

public class ScaledBackground { 

    public static void main(String[] args) { 
     new ScaledBackground(); 
    } 

    public ScaledBackground() { 
     EventQueue.invokeLater(new Runnable() { 
      @Override 
      public void run() { 
       try { 
        UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName()); 
       } catch (ClassNotFoundException | InstantiationException | IllegalAccessException | UnsupportedLookAndFeelException ex) { 
        ex.printStackTrace(); 
       } 

       try { 
        BufferedImage img = ImageIO.read(...); 

        JFrame frame = new JFrame("Testing"); 
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); 
        frame.add(new ImagePane(img)); 
        frame.pack(); 
        frame.setLocationRelativeTo(null); 
        frame.setVisible(true); 
       } catch (IOException exp) { 
        exp.printStackTrace(); 
       } 
      } 
     }); 
    } 

    public class ImagePane extends JPanel { 

     private BufferedImage original; 
     private BufferedImage scaled; 

     public ImagePane(BufferedImage img) { 
      original = img; 
      scaled = original; 
     } 

     @Override 
     public Dimension getPreferredSize() { 
      return original == null ? new Dimension(200, 200) : new Dimension(original.getWidth(), original.getHeight()); 
     } 

     @Override 
     public void invalidate() { 
      super.invalidate(); 
      generateScaledInstance(); 
     } 

     protected void generateScaledInstance() { 
      if (original != null) { 

       scaled = getScaledInstanceToFill(original, getSize()); 

      } 
     } 

     @Override 
     protected void paintComponent(Graphics g) { 
      super.paintComponent(g); 
      Graphics2D g2d = (Graphics2D) g.create(); 
      g2d.setRenderingHint(RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BILINEAR); 
      g2d.setRenderingHint(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_QUALITY); 
      g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON); 
      if (scaled != null) { 
       int x = (getWidth() - scaled.getWidth())/2; 
       int y = (getHeight() - scaled.getHeight())/2; 
       g2d.drawImage(scaled, x, y, this); 
      } 
      g2d.dispose(); 
     } 

     public BufferedImage getScaledInstanceToFill(BufferedImage img, Dimension size) { 
      float scaleFactor = getScaleFactorToFill(img, size); 
      return getScaledInstance(img, scaleFactor); 
     } 

     public float getScaleFactorToFill(BufferedImage img, Dimension size) { 
      float scale = 1f; 
      if (img != null) { 
       int imageWidth = img.getWidth(); 
       int imageHeight = img.getHeight(); 
       scale = getScaleFactorToFill(new Dimension(imageWidth, imageHeight), size); 
      } 
      return scale; 
     } 

     public float getScaleFactorToFill(Dimension original, Dimension toFit) { 
      float scale = 1f; 
      if (original != null && toFit != null) { 
       float dScaleWidth = getScaleFactor(original.width, toFit.width); 
       float dScaleHeight = getScaleFactor(original.height, toFit.height); 
       scale = Math.max(dScaleHeight, dScaleWidth); 
      } 
      return scale; 
     } 

     public float getScaleFactor(int iMasterSize, int iTargetSize) { 
      float scale = 1; 
      if (iMasterSize > iTargetSize) { 
       scale = (float) iTargetSize/(float) iMasterSize; 
      } else { 
       scale = (float) iTargetSize/(float) iMasterSize; 
      } 
      return scale; 
     } 

     public BufferedImage getScaledInstance(BufferedImage img, double dScaleFactor) { 
      BufferedImage imgBuffer = null; 
      imgBuffer = getScaledInstance(img, dScaleFactor, RenderingHints.VALUE_INTERPOLATION_BILINEAR, true); 
      return imgBuffer; 
     } 

     protected BufferedImage getScaledInstance(BufferedImage img, double dScaleFactor, Object hint, boolean higherQuality) { 

      BufferedImage scaled = img; 
      if (dScaleFactor != 1.0) { 
       if (dScaleFactor > 1.0) { 
        scaled = getScaledUpInstance(img, dScaleFactor, hint, higherQuality); 
       } else if (dScaleFactor > 0.0) { 
        scaled = getScaledDownInstance(img, dScaleFactor, hint, higherQuality); 
       } 
      } 

      return scaled; 

     } 

     protected BufferedImage getScaledDownInstance(BufferedImage img, double dScaleFactor, Object hint, boolean higherQuality) { 

      int targetWidth = (int) Math.round(img.getWidth() * dScaleFactor); 
      int targetHeight = (int) Math.round(img.getHeight() * dScaleFactor); 

      int type = (img.getTransparency() == Transparency.OPAQUE) 
          ? BufferedImage.TYPE_INT_RGB : BufferedImage.TYPE_INT_ARGB; 

      BufferedImage ret = (BufferedImage) img; 

      if (targetHeight > 0 || targetWidth > 0) { 
       int w, h; 
       if (higherQuality) { 
        w = img.getWidth(); 
        h = img.getHeight(); 
       } else { 
        w = targetWidth; 
        h = targetHeight; 
       } 

       do { 
        if (higherQuality && w > targetWidth) { 
         w /= 2; 
         if (w < targetWidth) { 
          w = targetWidth; 
         } 
        } 

        if (higherQuality && h > targetHeight) { 
         h /= 2; 
         if (h < targetHeight) { 
          h = targetHeight; 
         } 
        } 

        BufferedImage tmp = new BufferedImage(Math.max(w, 1), Math.max(h, 1), type); 
        Graphics2D g2 = tmp.createGraphics(); 
        g2.setRenderingHint(RenderingHints.KEY_INTERPOLATION, hint); 
        g2.drawImage(ret, 0, 0, w, h, null); 
        g2.dispose(); 

        ret = tmp; 
       } while (w != targetWidth || h != targetHeight); 
      } else { 
       ret = new BufferedImage(1, 1, type); 
      } 
      return ret; 
     } 

     protected BufferedImage getScaledUpInstance(BufferedImage img, 
         double dScaleFactor, 
         Object hint, 
         boolean higherQuality) { 

      int targetWidth = (int) Math.round(img.getWidth() * dScaleFactor); 
      int targetHeight = (int) Math.round(img.getHeight() * dScaleFactor); 

      int type = BufferedImage.TYPE_INT_ARGB; 

      BufferedImage ret = (BufferedImage) img; 
      int w, h; 
      if (higherQuality) { 

       w = img.getWidth(); 
       h = img.getHeight(); 

      } else { 

       w = targetWidth; 
       h = targetHeight; 

      } 

      do { 

       if (higherQuality && w < targetWidth) { 

        w *= 2; 
        if (w > targetWidth) { 

         w = targetWidth; 

        } 

       } 

       if (higherQuality && h < targetHeight) { 

        h *= 2; 
        if (h > targetHeight) { 

         h = targetHeight; 

        } 

       } 

       BufferedImage tmp = new BufferedImage(w, h, type); 
       Graphics2D g2 = tmp.createGraphics(); 
       g2.setRenderingHint(RenderingHints.KEY_INTERPOLATION, hint); 
       g2.drawImage(ret, 0, 0, w, h, null); 
       g2.dispose(); 

       ret = tmp; 
       tmp = null; 

      } while (w != targetWidth || h != targetHeight); 

      return ret; 

     } 

    } 

} 

Этот пример расти и уменьшаться, поскольку изображение в виде количества свободного места для панели изменяется

Answer 3

Вы можете использовать Stretch Icon на вашем JLabel.

Или вы можете использовать Background Panel, чтобы нарисовать изображение.

В обоих случаях изображение будет уменьшаться или увеличиваться по мере изменения размера рамки.