原文： https://zetcode.com/gfx/java2d/clipping/

在 Java 2D 教程的这一部分中，我们将讨论裁剪。

剪裁

剪裁将图形限制在某个区域。 这样做是出于效率原因并产生各种效果。 使用剪裁时，我们必须使用Graphics对象的副本，或者恢复原始的剪裁属性。 更改剪裁不会影响现有像素； 它仅影响将来的渲染。

在以下示例中，我们将图像裁剪为圆形。

ClippingEx.java

  1. package com.zetcode;
  3. import java.awt.Dimension;
  4. import java.awt.EventQueue;
  5. import java.awt.Graphics;
  6. import java.awt.Graphics2D;
  7. import java.awt.Image;
  8. import java.awt.event.ActionEvent;
  9. import java.awt.event.ActionListener;
  10. import java.awt.geom.Ellipse2D;
  11. import javax.swing.ImageIcon;
  12. import javax.swing.JFrame;
  13. import javax.swing.JPanel;
  14. import javax.swing.Timer;
  16. class Surface extends JPanel 
  17.         implements ActionListener {
  19.     private int pos_x = 8;
  20.     private int pos_y = 8;
  21.     private final int RADIUS = 90;
  22.     private final int DELAY = 35;
  24.     private Timer timer;
  25.     private Image image;
  27.     private final double delta[] = { 3, 3 };
  29.     public Surface() {
  31.         loadImage();
  32.         determineAndSetImageSize();
  33.         initTimer();
  34.     }
  36.     private void loadImage() {
  38.         image = new ImageIcon("mushrooms.jpg").getImage();
  39.     }
  41.     private void determineAndSetImageSize() {
  43.         int h = image.getHeight(this);
  44.         int w = image.getWidth(this);
  45.         setPreferredSize(new Dimension(w, h));        
  46.     }    
  48.     private void initTimer() {   
  50.         timer = new Timer(DELAY, this);
  51.         timer.start();
  52.     }
  54.     private void doDrawing(Graphics g) {
  56.         Graphics2D g2d = (Graphics2D) g.create();
  58.         g2d.clip(new Ellipse2D.Double(pos_x, pos_y, RADIUS, RADIUS));
  59.         g2d.drawImage(image, 0, 0, null); 
  61.         g2d.dispose();
  62.     }
  64.     @Override
  65.     public void paintComponent(Graphics g) {
  67.         super.paintComponent(g);
  68.         doDrawing(g);
  69.     }
  71.     @Override
  72.     public void actionPerformed(ActionEvent e) {
  74.         moveCircle();
  75.         repaint();
  76.     }
  78.     private void moveCircle() {
  80.         int w = getWidth();
  81.         int h = getHeight();
  83.         if (pos_x < 0) {
  85.             delta[0] = Math.random() % 4 + 5;
  86.         } else if (pos_x > w - RADIUS) {
  88.             delta[0] = -(Math.random() % 4 + 5);
  89.         }
  91.         if (pos_y < 0 ) {
  93.             delta[1] = Math.random() % 4 + 5;
  94.         } else if (pos_y > h - RADIUS) {
  96.             delta[1] = -(Math.random() % 4 + 5);
  97.         }
  99.         pos_x += delta[0];
  100.         pos_y += delta[1];
  101.     }       
  102. }
  104. public class ClippingEx extends JFrame {
  106.     public ClippingEx() {
  108.         initUI();
  109.     }
  111.     private void initUI() {
  113.         setTitle("Clipping");
  115.         add(new Surface());
  117.         pack();
  118.         setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  119.         setLocationRelativeTo(null);        
  120.     }
  122.     public static void main(String[] args) {
  124.         EventQueue.invokeLater(new Runnable() {
  126.             @Override
  127.             public void run() {
  128.                 ClippingEx cl = new ClippingEx();
  129.                 cl.setVisible(true);
  130.             }
  131.         });        
  132.     }
  133. }

屏幕上正在移动一个圆圈，并显示了一部分基础图像。 这就像我们从孔中看一样。

  1. Graphics2D g2d = (Graphics2D) g.create();

我们创建Graphics2D对象的副本。 因此，更改剪裁不会影响其他在Graphics2D对象被重用的 Swing 零件。

  1. g2d.clip(new Ellipse2D.Double(pos_x, pos_y, RADIUS, RADIUS));

clip()方法将现有剪裁与作为参数给出的形状结合在一起。 所得的相交设置为片段。 在我们的例子中，最终的剪裁是圆形。

  1. if (pos_x < 0) {
  3.     delta[0] = Math.random() % 4 + 5;
  4. } else if (pos_x > w - RADIUS) {
  6.     delta[0] = -(Math.random() % 4 + 5);
  7. }

如果圆碰到窗口的左侧或右侧，则圆的移动方向会随机变化。 顶部和底部也一样。

  1. g2d.dispose();

完成绘画后，我们必须释放Graphics2D对象的副本。

剪裁形状

在下面的示例中，我们将剪切到两个形状的交点：矩形和圆形。

ClippingShapesEx.java

  1. package com.zetcode;
  3. import java.awt.Color;
  4. import java.awt.EventQueue;
  5. import java.awt.Graphics;
  6. import java.awt.Graphics2D;
  7. import java.awt.Rectangle;
  8. import java.awt.RenderingHints;
  9. import java.awt.Shape;
  10. import java.awt.event.ActionEvent;
  11. import java.awt.event.ActionListener;
  12. import java.awt.geom.AffineTransform;
  13. import java.awt.geom.Ellipse2D;
  14. import java.awt.geom.GeneralPath;
  15. import javax.swing.JFrame;
  16. import javax.swing.JPanel;
  17. import javax.swing.Timer;
  19. class Surface extends JPanel
  20.         implements ActionListener {
  22.     private Timer timer;
  23.     private double rotate = 1;
  24.     private int pos_x = 8;
  25.     private int pos_y = 8;
  26.     private final double delta[] = {1, 1};
  28.     private final int RADIUS = 60;
  30.     public Surface() {
  32.         initTimer();
  33.     }
  35.     private void initTimer() {
  37.         timer = new Timer(10, this);
  38.         timer.start();
  39.     }
  41.     private void doDrawing(Graphics g) {
  43.         Graphics2D g2d = (Graphics2D) g;
  45.         g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
  46.                 RenderingHints.VALUE_ANTIALIAS_ON);
  48.         g2d.setRenderingHint(RenderingHints.KEY_RENDERING,
  49.                 RenderingHints.VALUE_RENDER_QUALITY);
  51.         Shape oldClip = g2d.getClip();
  53.         int w = getWidth();
  54.         int h = getHeight();
  56.         Rectangle rect = new Rectangle(0, 0, 200, 80);
  58.         AffineTransform tx = new AffineTransform();
  59.         tx.rotate(Math.toRadians(rotate), w / 2, h / 2);
  60.         tx.translate(w / 2 - 100, h / 2 - 40);
  62.         Ellipse2D circle = new Ellipse2D.Double(pos_x, pos_y,
  63.                 RADIUS, RADIUS);
  65.         GeneralPath path = new GeneralPath();
  66.         path.append(tx.createTransformedShape(rect), false);
  68.         g2d.clip(circle);
  69.         g2d.clip(path);
  71.         g2d.setPaint(new Color(110, 110, 110));
  72.         g2d.fill(circle);
  74.         g2d.setClip(oldClip);
  76.         g2d.draw(circle);
  77.         g2d.draw(path);
  78.     }
  80.     @Override
  81.     public void paintComponent(Graphics g) {
  82.         super.paintComponent(g);
  84.         doDrawing(g);
  85.     }
  87.     public void step() {
  89.         int w = getWidth();
  90.         int h = getHeight();
  92.         rotate += 1;
  94.         if (pos_x < 0) {
  96.             delta[0] = 1;
  97.         } else if (pos_x > w - RADIUS) {
  99.             delta[0] = -1;
  100.         }
  102.         if (pos_y < 0) {
  104.             delta[1] = 1;
  105.         } else if (pos_y > h - RADIUS) {
  107.             delta[1] = -1;
  108.         }
  110.         pos_x += delta[0];
  111.         pos_y += delta[1];
  112.     }
  114.     @Override
  115.     public void actionPerformed(ActionEvent e) {
  117.         step();
  118.         repaint();
  119.     }
  120. }
  122. public class ClippingShapesEx extends JFrame {
  124.     public ClippingShapesEx() {
  126.         initUI();
  127.     }
  129.     private void initUI() {
  131.         setTitle("Clipping shapes");
  133.         add(new Surface());
  135.         setSize(350, 300);
  136.         setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  137.         setLocationRelativeTo(null);
  138.     }
  140.     public static void main(String[] args) {
  142.         EventQueue.invokeLater(new Runnable() {
  144.             @Override
  145.             public void run() {
  146.                 ClippingShapesEx ex = new ClippingShapesEx();
  147.                 ex.setVisible(true);
  148.             }
  149.         });
  150.     }
  151. }

在我们的示例中，我们有一个弹跳的圆和一个旋转的矩形。 当这些形状重叠时，结果区域将充满颜色。

  1. Shape oldClip = g2d.getClip();

由于我们没有创建Graphics2D对象的副本，因此我们将存储旧剪裁以供以后使用。 最后，我们必须将剪裁重置为原始剪裁。

  1. Rectangle rect = new Rectangle(0, 0, 200, 80);
  3. AffineTransform tx = new AffineTransform();
  4. tx.rotate(Math.toRadians(rotate), w / 2, h / 2);
  5. tx.translate(w / 2 - 100, h / 2 - 40);

矩形正在旋转。 它始终位于面板的中间。

  1. GeneralPath path = new GeneralPath();
  2. path.append(tx.createTransformedShape(rect), false);

在这里，我们得到了旋转矩形的形状。

  1. g2d.clip(circle);
  2. g2d.clip(path);
  4. g2d.setPaint(new Color(110, 110, 110));
  5. g2d.fill(circle);

在这里，我们将绘图限制为两个形状的交点。 如果它们重叠，则结果形状的内部将充满颜色。 clip()方法将初始剪裁（组件的客户区域）与给定的两个形状组合在一起。

  1. g2d.setClip(oldClip);

使用setClip()方法，我们在绘制形状之前将剪裁区域重置为旧剪裁。 与clip()方法不同，setClip()不合并剪切区域。 它将剪裁重置到新区域。 因此，此方法应专门用于还原旧剪裁。

剪裁 - 图1

图：剪裁形状

在 Java 2D 教程的这一部分中，我们讨论了剪裁。