21

私のJFrameでは、次のコードを使用してパネルに画像を表示しています。

  ImageIcon img= new ImageIcon("res.png");
  jLabel.setIcon(img);

ラベルの画像を「自動サイズ変更」したいと思います。実際、画像サイズが数ピクセルしかない場合もあれば、それ以上の場合もあります。

ラベルのサイズを設定してから、ラベル内の画像のサイズを自動化する方法はありますか?

4

7 に答える 7

42

これは難しい質問です。を使用して画像を表示しているという事実を強調しますJLabel。これは標準的な方法ですが、JLabelはテキスト、アイコン、テキストの配置と配置を伴う複雑で小さな獣です。

余分な機能がすべて必要ない場合は、スケーリングされた画像をペイントできるカスタム コンポーネントを自分で作成するだけです...

次の質問は、画像をどのようにスケーリングするかです。画像の縦横比を維持しますか? 使用可能なスペースに画像を「合わせる」か「埋める」か。

@デビッドは正しいです。これは最速ではないため、可能な限り避けるべきですImage#getScaledInstanceが、さらに重要なことに、一般的に、最高の品質も得られません。

フィット vs フィル

ここに画像の説明を入力

次の例はかなり単純です (そして、私のコード ライブラリから大量に借用しているため、おそらく少し複雑でもあります ;))。バックグラウンド スケーリング スレッドから使​​用することもできますが、元の画像の潜在的なサイズに基づいて決定します。

public class ResizableImage {

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

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

                try {
                    BufferedImage image = ImageIO.read(new File("/path/to/your/image"));

                    JFrame frame = new JFrame("Test");
                    frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
                    frame.setLayout(new BorderLayout());
                    frame.add(new ScalablePane(image));
                    frame.pack();
                    frame.setLocationRelativeTo(null);
                    frame.setVisible(true);
                } catch (Exception exp) {
                    exp.printStackTrace();
                }
            }
        });
    }

    public class ScalablePane extends JPanel {

        private Image master;
        private boolean toFit;
        private Image scaled;

        public ScalablePane(Image master) {
            this(master, true);
        }

        public ScalablePane(Image master, boolean toFit) {
            this.master = master;
            setToFit(toFit);
        }

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

        @Override
        protected void paintComponent(Graphics g) {
            super.paintComponent(g);
            Image toDraw = null;
            if (scaled != null) {
                toDraw = scaled;
            } else if (master != null) {
                toDraw = master;
            }

            if (toDraw != null) {
                int x = (getWidth() - toDraw.getWidth(this)) / 2;
                int y = (getHeight() - toDraw.getHeight(this)) / 2;
                g.drawImage(toDraw, x, y, this);
            }
        }

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

        public boolean isToFit() {
            return toFit;
        }

        public void setToFit(boolean value) {
            if (value != toFit) {
                toFit = value;
                invalidate();
            }
        }

        protected void generateScaledInstance() {
            scaled = null;
            if (isToFit()) {
                scaled = getScaledInstanceToFit(master, getSize());
            } else {
                scaled = getScaledInstanceToFill(master, getSize());
            }
        }

        protected BufferedImage toBufferedImage(Image master) {
            Dimension masterSize = new Dimension(master.getWidth(this), master.getHeight(this));
            BufferedImage image = createCompatibleImage(masterSize);
            Graphics2D g2d = image.createGraphics();
            g2d.drawImage(master, 0, 0, this);
            g2d.dispose();
            return image;
        }

        public Image getScaledInstanceToFit(Image master, Dimension size) {
            Dimension masterSize = new Dimension(master.getWidth(this), master.getHeight(this));
            return getScaledInstance(
                            toBufferedImage(master),
                            getScaleFactorToFit(masterSize, size),
                            RenderingHints.VALUE_INTERPOLATION_BILINEAR,
                            true);
        }

        public Image getScaledInstanceToFill(Image master, Dimension size) {
            Dimension masterSize = new Dimension(master.getWidth(this), master.getHeight(this));
            return getScaledInstance(
                            toBufferedImage(master),
                            getScaleFactorToFill(masterSize, size),
                            RenderingHints.VALUE_INTERPOLATION_BILINEAR,
                            true);
        }

        public Dimension getSizeToFit(Dimension original, Dimension toFit) {
            double factor = getScaleFactorToFit(original, toFit);
            Dimension size = new Dimension(original);
            size.width *= factor;
            size.height *= factor;
            return size;
        }

        public Dimension getSizeToFill(Dimension original, Dimension toFit) {
            double factor = getScaleFactorToFill(original, toFit);
            Dimension size = new Dimension(original);
            size.width *= factor;
            size.height *= factor;
            return size;
        }

        public double getScaleFactor(int iMasterSize, int iTargetSize) {
            return (double) iTargetSize / (double) iMasterSize;
        }

        public double getScaleFactorToFit(Dimension original, Dimension toFit) {
            double dScale = 1d;
            if (original != null && toFit != null) {
                double dScaleWidth = getScaleFactor(original.width, toFit.width);
                double dScaleHeight = getScaleFactor(original.height, toFit.height);
                dScale = Math.min(dScaleHeight, dScaleWidth);
            }
            return dScale;
        }

        public double getScaleFactorToFill(Dimension masterSize, Dimension targetSize) {
            double dScaleWidth = getScaleFactor(masterSize.width, targetSize.width);
            double dScaleHeight = getScaleFactor(masterSize.height, targetSize.height);

            return Math.max(dScaleHeight, dScaleWidth);
        }

        public BufferedImage createCompatibleImage(Dimension size) {
            return createCompatibleImage(size.width, size.height);
        }

        public BufferedImage createCompatibleImage(int width, int height) {
            GraphicsConfiguration gc = getGraphicsConfiguration();
            if (gc == null) {
                gc = GraphicsEnvironment.getLocalGraphicsEnvironment().getDefaultScreenDevice().getDefaultConfiguration();
            }

            BufferedImage image = gc.createCompatibleImage(width, height, Transparency.TRANSLUCENT);
            image.coerceData(true);
            return image;
        }

        protected BufferedImage getScaledInstance(BufferedImage img, double dScaleFactor, Object hint, boolean bHighQuality) {
            BufferedImage imgScale = img;
            int iImageWidth = (int) Math.round(img.getWidth() * dScaleFactor);
            int iImageHeight = (int) Math.round(img.getHeight() * dScaleFactor);

            if (dScaleFactor <= 1.0d) {
                imgScale = getScaledDownInstance(img, iImageWidth, iImageHeight, hint, bHighQuality);
            } else {
                imgScale = getScaledUpInstance(img, iImageWidth, iImageHeight, hint, bHighQuality);
            }

            return imgScale;
        }

        protected BufferedImage getScaledDownInstance(BufferedImage img,
                        int targetWidth,
                        int targetHeight,
                        Object hint,
                        boolean higherQuality) {

            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) {
                    // Use multi-step technique: start with original size, then
                    // scale down in multiple passes with drawImage()
                    // until the target size is reached
                    w = img.getWidth();
                    h = img.getHeight();
                } else {
                    // Use one-step technique: scale directly from original
                    // size to target size with a single drawImage() call
                    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,
                        int targetWidth,
                        int targetHeight,
                        Object hint,
                        boolean higherQuality) {

            int type = BufferedImage.TYPE_INT_ARGB;

            BufferedImage ret = (BufferedImage) img;
            int w, h;
            if (higherQuality) {
                // Use multi-step technique: start with original size, then
                // scale down in multiple passes with drawImage()
                // until the target size is reached
                w = img.getWidth();
                h = img.getHeight();
            } else {
                // Use one-step technique: scale directly from original
                // size to target size with a single drawImage() call
                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;
        }
    }
}
于 2013-01-27T22:21:39.770 に答える
25

ラベルのサイズを設定する方法はありますか

必要な をオーバーライドgetPreferredSize()JLabelて返しDimensionますが、 aJLabelはコンテンツに合わせてサイズを変更するため、 に追加する画像のサイズを変更するだけで済みますJLabel

ラベルの画像を自動サイズ調整するには?

必要な幅と高さに応じて画像のサイズを変更する必要があります (単純に に追加するのではなく、画像に合わせてサイズを変更JLabelしますJLabel)。

Image.getScaledInstance(..)詳細については、ここを読むことはお勧めしません。

Image.getScaledInstance()完成したスケーリングされたイメージを返しません。後で画像ピクセルが使用されるときに、スケーリング作業の多くを残します。

によって作成された問題を回避するために私が使用しているカスタムメソッドは次のgetScaledInstanceとおりです。

public static BufferedImage resize(BufferedImage image, int width, int height) {
    BufferedImage bi = new BufferedImage(width, height, BufferedImage.TRANSLUCENT);
    Graphics2D g2d = (Graphics2D) bi.createGraphics();
    g2d.addRenderingHints(new RenderingHints(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_QUALITY));
    g2d.drawImage(image, 0, 0, width, height, null);
    g2d.dispose();
    return bi;
}

次の方法で、必要なサイズの画像を作成します。

BufferedImage image=ImageIO.read(..);
BufferedImage resizedImage=resize(image,100,100);//resize the image to 100x100
于 2013-01-27T17:36:42.210 に答える
7

paintComponentのメソッドをオーバーライドして、幅と高さを のようにJLabel描画することによっても実行できます。また、親のサイズが変更されたときにイメージのサイズを変更する場合は、親コンテナーのサイズが変更されるたびに、親コンテナーとインスタンスにを適用できます。デモは次のとおりです。imageJLabelcontainerWindowListenerrepaintJlabel

import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.ImageIcon;
import javax.swing.SwingUtilities;
import java.awt.Graphics;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;


public class  LabelDemo extends JFrame
{
    ImageIcon imageIcon;
    MyJLabel jLabel ;
    public LabelDemo ()
    {
        super("JLabel Demo");
    }
    public void createAndShowGUI()
    {
        imageIcon = new ImageIcon("apple.png");
        jLabel = new MyJLabel(imageIcon);
        getContentPane().add(jLabel);
        addWindowListener( new WindowAdapter()
        {
            public void windowResized(WindowEvent evt)
            {
                jLabel.repaint();
            }
        });
        setSize(300,100);
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        setVisible(true);
        jLabel.repaint();
    }
    public static void main(String st[])
    {
        SwingUtilities.invokeLater( new Runnable()
        {
            @Override
            public void run()
            {
                LabelDemo demo = new LabelDemo();
                demo.createAndShowGUI();
            }
        });
    }
}
class MyJLabel extends JLabel
{
    ImageIcon imageIcon;
    public MyJLabel(ImageIcon icon)
    {
        super();
        this.imageIcon = icon;
    }
    @Override
    public void paintComponent(Graphics g)
    {
        super.paintComponent(g);
        g.drawImage(imageIcon.getImage(),0,0,getWidth(),getHeight(),this);
    }
}
于 2013-01-27T16:47:39.123 に答える
0

この機能を試してください:

public static BufferedImage resize(BufferedImage image, int width, int height) {
    BufferedImage bi = new BufferedImage(width, height, BufferedImage.TRANSLUCENT);
    Graphics2D g2d = (Graphics2D) bi.createGraphics();
    g2d.addRenderingHints(new RenderingHints(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_QUALITY));
    g2d.drawImage(image, 0, 0, width, height, null);
    g2d.dispose();
    return bi;
}

BufferedImage image1=ImageIO.read(url.openStream());
     BufferedImage resizedImage=resize(image,100,100);
     System.out.println("Load image into frame...");
      icon=new ImageIcon(resizedImage);
于 2016-06-01T14:01:31.210 に答える