एक बड़े BufferedImage का हिस्सा कैसे आकर्षित करें?</p> <p><code>x, y, width, height</code>:

Question

मैं एक 10000x10000 BufferedImage है और मैं एक Canvas करने के लिए इसे का ही हिस्सा आकर्षित करने के लिए देख रहा हूँ, वहाँ इस तरह के रूप आर्ग का उपयोग कर यह करने के लिए एक तरीका है?

तो उदाहरण के लिए, ड्राइमेज (आईएमजी, एक्स, वाई, चौड़ाई, ऊंचाई) छवि (x, y) से शुरू होने वाली छवि से आयताकार (आयाम, ऊंचाई) आयाम के रूप में एक आयताकार खींच लेगा?

संपादित करें:

मैं शब्द इस सवाल फिर से करने जा रहा हूँ:

मैं एक 10000x10000 छवि है और मैं केवल स्क्रीन पर के एक हिस्से को, बस इसे offsetting के साथ समस्या यह प्रदर्शित करना चाहते हैं एक्स और वाई द्वारा यह है कि यह अभी भी अंतराल का कारण बनता है क्योंकि पूरी छवि को प्रस्तुत किया जा रहा है, बस इसमें से अधिकांश कैनवास से बाहर हैं। मैं मूल रूप से इसे कैसे बना सकता हूं ताकि पूरी छवि प्रस्तुत की जा सके लेकिन मैं कैनवास को अंतराल के बिना इसके चारों ओर स्क्रॉल कर सकता हूं?

Answer 1

मैं एक 10000x10000 BufferedImage और मैं एक कैनवास के लिए केवल इसका हिस्सा आकर्षित करने के लिए देख रहा हूँ है, वहाँ इस तरह के रूप आर्ग का उपयोग कर यह करने के लिए एक तरीका है:

1. जावा में कस्टम पेंटिंग के लिए कैनवास का उपयोग न करें। इसके बजाय JComponent या JPanel का उपयोग करें। यह एक अच्छा समारोह paintComponent(Graphics g) है, यह ओवरराइड और g.drawImage(x, y, width, height, observer) के साथ अंदर अपनी छवि रंग;

2. स्विंग ग्राफिक्स में Graphics.clipRect(int x, int y, int width, int height) क्षेत्र आयताकार को बाध्य करने के लिए है जिसे आप छवि को चित्रित करने से पहले आकर्षित करना चाहते हैं।

संपादित करें (आपकी संपादित प्रश्न के उत्तर में):

पहले दृष्टिकोण BufferedImage..getSubimage(x, y, width, height) उपयोग करने के लिए निर्दिष्ट आयत क्षेत्र के साथ एक उप छवि प्राप्त करने के लिए है। यह तेज़ है।

BufferedImage img = ImageIO.read(new File("file")); 
    img = img.getSubimage(50, 50, 500, 500); // 500 x 500 

इस समारोह अपनी मूल छवि के rectangle(x, y, width, height) आपके द्वारा निर्दिष्ट के साथ काटी आप एक नई छवि दे देंगे। अपने घटक पर आकर्षित करने के लिए लौटाई गई छवि का उपयोग करें।

ट्यूटोरियल संसाधन:Clipping the Drawing Region

---

डेमो:

import java.awt.*; 
import java.awt.event.*; 
import java.awt.image.BufferedImage; 
import java.io.IOException; 
import java.net.URL; 
import java.util.*; 
import java.util.logging.*; 
import javax.imageio.ImageIO; 
import javax.swing.*; 
import javax.swing.Timer; 

class MyCanvas extends JPanel implements ActionListener 
{ 
    public BufferedImage buffImg; 
    public Rectangle rectangle; 
    Random random; 
    long lastTimeChanged; 
    int dirX = 1, dirY = 1; 
    volatile static boolean imageLoading = true; 
    public MyCanvas() { 
     random = new Random(); 
     rectangle = new Rectangle(50, 50, 250, 250); 
     lastTimeChanged = System.currentTimeMillis(); 
     setBackground(Color.WHITE); 
    } 


    @Override 
    protected void paintComponent(Graphics g) { 
     super.paintComponent(g); 

     if(imageLoading) 
     { 
      showWaitForLoading(g); 
      return; 
     } 

     g.clipRect(rectangle.x, rectangle.y, rectangle.width, rectangle.height); 
     g.drawImage(buffImg, 0, 0, getWidth(), getHeight(), this); 

    } 


    public void showWaitForLoading(Graphics g) 
    { 
     Graphics2D g2d = (Graphics2D)g.create(); 
     g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON); 
     g2d.setColor(Color.DARK_GRAY); 
     g2d.fillRoundRect(getWidth()/2-100, getHeight()/2-15, 200, 30, 30, 30); 
     g2d.setColor(Color.WHITE); 
     g2d.drawString("Loading image...", getWidth()/2 - 45, getHeight()/2 + 3); 
     g2d.dispose(); 
    } 

    @Override 
    public void actionPerformed(ActionEvent e) { 

     long endTime = System.currentTimeMillis(); 
     if(endTime - lastTimeChanged > 500) 
     { 
      dirX = random.nextInt(2) == 0 ? -1 : 1; 
      dirY = random.nextInt(2) == 0 ? -1 : 1; 
      lastTimeChanged = endTime; 
     } 

     if(rectangle.x < 0)dirX = 1; 
     else if(rectangle.x + rectangle.width > getWidth())dirX = -1; 

     if(rectangle.y < 0)dirY = 1; 
     else if(rectangle.y + rectangle.height > getHeight())dirY = -1; 

     rectangle.x = rectangle.x + dirX * 10; 
     rectangle.y = rectangle.y + dirY * 10;; 

     repaint(); 
    } 

} 
public class CustomPainting { 


    public static void main(String[] args) throws IOException { 

     SwingUtilities.invokeLater(new Runnable() { 

      @Override 
      public void run() { 
       final MyCanvas canvas = new MyCanvas(); 
       JFrame frame = new JFrame(); 
       frame.setSize(new Dimension(500, 500)); 
       frame.add(canvas); 
       frame.setVisible(true); 
       frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); 

       Timer timer = new Timer(200, canvas); 
       timer.start(); 
       new Thread() 
       { 
        public void run() 
        { 
         try { 
          canvas.buffImg = ImageIO.read(new URL("http://images6.fanpop.com/image/photos/33400000/Cute-Panda-beautiful-pictures-33434826-500-500.jpg")); 
          MyCanvas.imageLoading = false; 
         } catch (IOException ex) { 
          Logger.getLogger(CustomPainting.class.getName()).log(Level.SEVERE, null, ex); 
         } 
        } 
       }.start(); 
      } 
     }); 
    } 
} 

Answer 2

हाँ है: drawImage(Image img, int x, int y, int width, int height, ImageObserver observer)

Answer 3

आप पैमाने या का उपयोग कर एक छवि का एक हिस्सा आकर्षित कर सकते हैं: एनिमेशन के साथ कतरन छवि दिखाते ग्राफिक्स.drawImage जैसा कि एक और उल्लेख किया है nswer और जावा प्रलेखन के अनुसार, BufferedImage के लिए ImageObserver तर्क की आवश्यकता नहीं है ताकि आप बस शून्य हो सकें।

http://docs.oracle.com/javase/7/docs/api/java/awt/Graphics.html

हालांकि, मेरी पसंद कतरन छवि के क्षेत्र ड्राइंग के बजाय होगा। यहां एक उदाहरण है जिसे आप आजमा सकते हैं:

Graphics2D g = BufferedImage.getGraphics; 
g.setClip(x, y, width, height); 
g.drawImage(sx, sy, x - sx, y - sy, null);