जावा: मूल अंकन, एक बिंदु/डॉट/पिक्सेल

Question

मैं सिर्फ एक पैनल की जो मैं आकर्षित करने के लिए सक्षम होगा अंदर की आवश्यकता ड्राइंग। मैं पिक्सेल द्वारा पिक्सेल खींचने के लिए सक्षम होना चाहता हूं।

ps: मुझे अन्य प्राइमेटिव्स/लाइनों की आवश्यकता नहीं है। पीपीएस: ग्राफिक्स लाइब्रेरी वास्तव में कोई फर्क नहीं पड़ता, यह बहुत अच्छा हो सकता है, स्विंग, क्यूटी .. कुछ भी। मैं बस कुछ ऐसा करना चाहता हूं जिसे आमतौर पर बुफर्डिमेज या somethign द्वारा दर्शाया जाता है, जहां आप एकल पिक्सल के रंग सेट करते हैं और फिर इसे स्क्रीन पर प्रस्तुत करते हैं।

Answer 1

BufferedImage का प्रतिनिधित्व करती ..

मुझे लगता है कि के लिए एक BufferedImage प्रदर्शित सुझाव है ..

..or की तरह है कि जहां एक पिक्सल के रंग सेट और फिर इसे प्रस्तुत करना कुछ स्क्रीन पर।

.. JLabel में - जैसा कि this answer में देखा गया है।

बेशक

, एक बार हम BufferedImage का एक उदाहरण है, हम setRGB(..) कर सकते हैं।

Answer 2

आप ईमानदारी से पिक्सेल द्वारा पिक्सेल रेंडर करने के लिए की जरूरत है, मैं सॉफ्टवेयर मैं एक शोध प्रयोगशाला के लिए लिखा था की हॉटस्पॉट दृश्य टुकड़े के लिए पर-लंबाई यह किया है।

आप क्या चाहते हैं BufferedImage.setRGB(..) - यदि आप पिक्सेल-बाय-पिक्सेल ड्राइंग कर रहे हैं, तो मुझे लगता है कि आपने एक एल्गोरिदम लागू किया है जो प्रत्येक पिक्सेल के लिए आरजीबी मान प्रस्तुत करेगा (जैसा कि हमने गर्मी-मानचित्रों के साथ किया था)। यह वही है जो हमने पुराने आईई-संगत एप्लेट में दिन में वापस उपयोग किया था। एक आकर्षण की तरह काम किया और यह अपेक्षाकृत तेज़ था कि यह क्या कर रहा था।

दुर्भाग्य से जब भी आप किसी BufferedImage में सीधे आरजीबी मूल्यों में हेरफेर, यह समर्थन वीडियो स्मृति द्वारा uncached बन जाएगा।

जावा 7 के बाद से, मैंने सुना है कि अंतर्निहित जे 2 डी कार्यान्वयन एक बार मैनिप्लेशंस स्टॉप और प्रतिपादन बार-बार किया जाता है - उदाहरण के लिए, अंतर्निहित जे 2 डी कार्यान्वयन वीडियो मेमोरी में छवि को फिर से कैशिंग करने का प्रयास करेगा। गर्मी के नक्शे को प्रतिपादित कर रहे हैं, यह तेज़ नहीं है, लेकिन एक बार इसे प्रस्तुत करने के बाद, जब आप खिड़की को खींचते हैं और ऐप के साथ काम करते हैं, तो बैकिंग छवि डेटा पुनः-त्वरित हो सकता है।

Answer 3

एक ही रास्ता का एक उदाहरण यह करने के लिए: ओवरराइड paintComponent (ग्राफिक्स जी)

((Graphics2D)g).drawImage(img, <args>) 

Answer 4

आप कुछ जल्दी करना चाहते हैं, आप कर सकते हैं के भीतर से

// Create the new image needed 
img = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB); 

for (int rc = 0; rc < height; rc++) { 
    for (int cc = 0; cc < width; cc++) { 
    // Set the pixel colour of the image n.b. x = cc, y = rc 
    img.setRGB(cc, rc, Color.BLACK.getRGB()); 
    }//for cols 
}//for rows 

और फिर बस ग्राफिक्स विधियों सेट रंग और drawLine का उपयोग करें। उदाहरण के लिए:

public void paintComponent(Graphics g) { 
    super.paintComponent(g);  

    // Set the colour of pixel (x=1, y=2) to black 
    g.setColor(Color.BLACK); 
    g.drawLine(1, 2, 1, 2); 
} 

मैंने इस तकनीक का उपयोग किया है और यह बहुत धीमी नहीं थी। मैंने BufferedImage ऑब्जेक्ट्स का उपयोग करने के लिए इसकी तुलना नहीं की है।

Answer 5

एक छोटी सी देर यहाँ, लेकिन आप इसे जिस तरह से जावा खेल प्रोग्रामर करते हैं हमेशा सकता है, एक Screen वर्ग के साथ:

public class Screen { 

    private int width, height; 

    public int[] pixels; 

    public Screen(int width, int height) { 
     this.width = width; 
     this.height = height; 

     pixels = new int[width * height]; 
    } 

    public void render() { 
     for(int y = 0; y < height; y++) { 
      for(int x = 0; x < width; x++) { 
       pixels[x + y * width] = 0xFFFFFF; //make every pixel white 
      } 
     } 
    } 

public void clear() { 
      for(int i = 0; i < pixels.length; i++) { 
        pixels[i] = 0; //make every pixel black 
      } 
    } 

} 

और फिर अपने मुख्य वर्ग में:

private Screen screen; 

    private BufferedImage image = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB); 
    private int[] pixels = ((DataBufferInt) image.getRaster().getDataBuffer()).getData(); 

    public void render() { 
     BufferStrategy bs = getBufferStrategy(); 
     if (bs == null) { 
      createBufferStrategy(3); 
      return; 
     } 

     screen.clear(); 
     screen.render(); 

     for(int i = 0; i < pixels.length; i++) { 
      pixels[i] = screen.pixels[i]; 
     } 

     Graphics g = bs.getDrawGraphics(); 
     g.drawImage(image, 0, 0, getWidth(), getHeight(), null); 
     g.dispose(); 
     bs.show(); 
} 

यही चाहिए काम, मुझे लगता है।