2015-02-08 5 views
6

मैं जावा के लिए नया हूँ और एक प्रोग्राम है जो बनाने का फैसला किया: खिड़की जब आप क्लिक छोड़ दिया में एक बिंदु तय करता है। और फिर एक और बिंदु जब आप फिर से क्लिक करें। और इतने पर ... तो यह सब अंक लाइनों के साथ (इस तरह) जुड़ जाता है और लाइन का एक पक्ष रंगों कितने अंक एक लाइन का एक पक्ष पर हैं पर निर्भर करता है enter image description hereपारदर्शिता - जावा JFrame

प्रश्न यहाँ से शुरू होता:।

अब मुझे एक और सुविधा की आवश्यकता है। जब मैं दायाँ क्लिक करता हूं, तो मैं माउस समन्वय में पिक्सेल की पारदर्शिता प्रकट करना चाहता हूं। तो जब बीच में क्लिक किया गया तो यह मुझे दिखाएगा कि जब मैं प्रकाश क्षेत्रों पर राइट क्लिक करता हूं तो यह अधिक पारदर्शी (या गहरा) होता है।

मैंने कुछ googling किया लेकिन जवाब नहीं मिला। निकटतम मुझे रोबोट के साथ एक स्क्रीनशॉट बनाया गया था और इसे एक बफरमेज के रूप में उपयोग करें और फिर पिक्सल का विश्लेषण करें। हालांकि, जहां भी मैं सही क्लिक करता हूं, मुझे काम नहीं लगता है, मुझे एआरजीबी के लिए 255,255,255,255 मिलते हैं। और कभी-कभी अजीब चीजें जैसे कि एजीबीए के लिए 255,234,236,245।

आशा है कि आप जो भी करने की कोशिश कर रहे हैं उसका पालन कर सकते हैं।

मेरा कोड यहां है।

मेरे मुख्य वर्ग जो कार्यक्रम सितारों विंडो बनाता है और माउस इंटरफ़ेस करता है:

import javax.swing.*; 

import java.awt.Dimension; 
import java.awt.Rectangle; 
import java.awt.Robot; 
import java.awt.event.*; 
import java.awt.image.BufferedImage; 

public class mouse { 
static DataTransfer data = new DataTransfer(); 
private static int x,y ; 
private static draw object = new draw(); 
public static int numPoints = 0; 
public static final int maxPoints = 4; 

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

     JFrame frame = new JFrame(); 
     Robot robot = new Robot(); 
     frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); 
     frame.setTitle("Drawing"); 
     frame.setSize(500, 400); 
     frame.setLocationRelativeTo(null); 
     frame.setVisible(true); 
     frame.add(object); 

     data.getRobot(robot,frame.getSize()); 
     object.addMouseListener(new AL()); 
} 


public static class AL extends MouseAdapter { 


    public void mouseClicked(MouseEvent e){ 


     if (e.getButton() == MouseEvent.BUTTON1) 
     { 
      if (numPoints < maxPoints){ 
      x = e.getX(); 
      y = e.getY(); 
      object.drawing(x,y,numPoints); 
      System.out.println("NUMBRER"+numPoints); 
      numPoints++; 
      } 
     } 
     if (e.getButton() == MouseEvent.BUTTON3) 
     { 
      x = e.getX(); 
      y = e.getY(); 

      int pixel = data.getScreen().getRGB(x, y); 

      int alpha = (pixel >> 24) & 0xff; 
      int red = (pixel >> 16) & 0xff; 
      int green = (pixel >> 8) & 0xff; 
      int blue = (pixel) & 0xff; 
      System.out.println("argb: " + alpha + ", " + red + ", " + green + ", " + blue); 


     } 



    } 

} 
// Here I tried to access the Robot in the mouse class, but I couldn't so I had to create this transition class in hope of it working 
public static class DataTransfer{ 

    BufferedImage screen ; 
    public void getRobot(Robot robot,Dimension size) 
    { 
     screen = robot.createScreenCapture(new Rectangle(size)); 
    } 
    public BufferedImage getScreen(){ 
     return screen; 
    } 

} 
} 

और मेरे ग्राफिक्स वर्ग जो छायांकन और रेखा खींचने आदि से संबंधित है ... (इसमें से अधिकांश के लिए ही दोहराता है छायांकन के प्रत्येक मामले है, तो आप पूरी बात)

import java.awt.Color; 
import java.awt.Graphics; 
import javax.swing.JPanel; 


@SuppressWarnings("serial") 
public class draw extends JPanel { 
    int[] polX = new int[5]; 
    int[] polY = new int[5]; 
    int[] aX = new int[mouse.maxPoints]; 
    int[] aY = new int[mouse.maxPoints]; 
    float m, c; 
    int corners; 
    //float triAng = 30; 
    float triAng = 255/(((mouse.maxPoints)*(mouse.maxPoints + 1))/2); 
    public void drawing(int xx, int yy, int Number) { 
     aX[Number] = xx; 
     aY[Number] = yy; 
     repaint(); 

    } 

    public void paintComponent(Graphics g){ 
     super.paintComponent(g); 
     g.setColor(new Color(0,255,0,255)); 

     g.setColor(new Color(255,0,0,(int)triAng)); 


     for(int i=0; i<mouse.numPoints;i++){ 

      for(int j = i+1; j < mouse.numPoints; j++) 
      { 

       // Shading the area 
       //1) finding the equation of the line 

       if(aX[i] != aX[j]){ 

        if(aY[i] != aY[j]){ 

         //Work out the Gradient 
         m = (float)(aY[j] - aY[i]) /(aX[j] - aX[i]); 
         c = ((float)aY[i]-(((float)aX[i])*m)); 
         for(int k=0;k<mouse.numPoints;k++){ 
         if(m<0){ 
          //Gradient is negative 
           if(k!= i && k!=j){ 

            //Below 
            if(aX[k]*m+c < aY[k]){ 
             //Clockwise from origin 
             // Left Right 
             // N - no additional corner 
             // Y- Additional Corner 

             // N N 
             if((c >= 400) && (500*m+c) >= 0) { 
              polX[1] = (int)((400-c)/m); 
              polY[1] = 400; 
              polX[2] = 500; 
              polY[2] = (int)(500*m+c); 
              corners = 3; 

             } 

             // N Y 
             else if(c >= 400 && (500*m+c) < 0) { 
              polX[1] = (int)((400-c)/m); 
              polY[1] = 400; 
              polX[2] = (int)((0-c)/m); 
              polY[2] = 0; 
              polX[3] = 500; 
              polY[3] = 0; 
              corners = 4; 
             } 
             // Y N 
             else if(c < 400 && (500*m+c) >= 0) { 
              polX[1] = 0; 
              polY[1] = 400; 
              polX[2] = 0; 
              polY[2] = (int)c; 
              polX[3] = 500; 
              polY[3] = (int)(500*m+c); 
              corners = 4; 
             } 
             // YY 
             else if(c < 400 && (500*m+c) < 0){ 
              polX[1] = 0; 
              polY[1] = 400; 
              polX[2] = 0; 
              polY[2] = (int)c; 
              polX[3] = (int)((0-c)/m); 
              polY[3] = 0; 
              polX[4] = 500; 
              polY[4] = 0; 
              corners = 5; 
             } 
             //Origin corners 
             polX[0] = 500; 
             polY[0] = 400; 


             g.fillPolygon(polX, polY, corners); 
            } 
            //I am here 
            ///////////////Above 
            if(aX[k]*m+c > aY[k]){ 
             //Clockwise from origin 
             // Left Right 
             // N - no additional corner 
             // Y- Additional Corner 

             // N N 
             if((c <= 400) && (500*m+c) <= 0) { 
              polX[1] = (int)((0-c)/m); 
              polY[1] = 0; 
              polX[2] = 0; 
              polY[2] = (int)(c); 
              corners = 3; 

             } 

             // N Y 
             else if(c <= 400 && (500*m+c) > 0) { 
              polX[1] = 500; 
              polY[1] = 0; 
              polX[2] = 500; 
              polY[2] = (int)(500*m+c); 
              polX[3] = 0; 
              polY[3] = (int)c; 
              corners = 4; 
             } 
             // Y N 
             else if(c > 400 && (500*m+c) <= 0) { 
              polX[1] = (int)((0-c)/m); 
              polY[1] = 0; 
              polX[2] = (int)((400-c)/m); 
              polY[2] = 400; 
              polX[3] = 0; 
              polY[3] = 400; 
              corners = 4; 
             } 
             // Y Y 
             else if(c > 400 && (500*m+c) > 0){ 
              polX[1] = 500; 
              polY[1] = 0; 
              polX[2] = 500; 
              polY[2] = (int)(500*m+c); 
              polX[3] = (int)((400-c)/m); 
              polY[3] = 400; 
              polX[4] = 0; 
              polY[4] = 400; 
              corners = 5; 
             } 
             //Origin corners 
             polX[0] = 0; 
             polY[0] = 0; 


             g.fillPolygon(polX, polY, corners); 
            } 
           } 
          } 

/////////////////////////////////////////////////////////////////////////////////////////////// 
         if(m>0){ 
          //Gradient is Positive 
           if(k!= i && k!=j){ 

            //Below 
            if(aX[k]*m+c < aY[k]){ 
             //Clockwise from origin 
             // Left Right 
             // N - no additional corner 
             // Y- Additional Corner 

             // N N 
             if((c >= 0) && (500*m+c) >= 400) { 
              polX[1] = 0; 
              polY[1] = (int)c; 
              polX[2] = (int)((400-c)/m); 
              polY[2] = 400; 
              corners = 3; 

             } 

             // N Y 
             else if(c >= 0 && (500*m+c) < 400) { 
              polX[1] = 0; 
              polY[1] = (int)c; 
              polX[2] = 500; 
              polY[2] = (int)(500*m+c); 
              polX[3] = 500; 
              polY[3] = 400; 
              corners = 4; 
             } 
             // Y N 
             else if(c < 0 && (500*m+c) >= 400) { 
              polX[1] = 0; 
              polY[1] = 0; 
              polX[2] = (int)((0-c)/m); 
              polY[2] = 0; 
              polX[3] = (int)((400-c)/m); 
              polY[3] = 400; 
              corners = 4; 
             } 
             // Y Y 
             else if(c < 0 && (500*m+c) < 400){ 
              polX[1] = 0; 
              polY[1] = 0; 
              polX[2] = (int)((0-c)/m); 
              polY[2] = 0; 
              polX[3] = 500; 
              polY[3] = (int)(500*m+c); 
              polX[4] = 500; 
              polY[4] = 400; 
              corners = 5; 
             } 
             //Origin corners 
             polX[0] = 0; 
             polY[0] = 400; 


             g.fillPolygon(polX, polY, corners); 
            } 
            ///////////////Above 
            if(aX[k]*m+c > aY[k]){ 
             //Clockwise from origin 
             // Left Right 
             // N - no additional corner 
             // Y- Additional Corner 

             // N N 
             if((c <= 0) && (500*m+c) <= 400) { 
              polX[1] = 500; 
              polY[1] = (int)(500*m+c); 
              polX[2] = (int)((0-c)/m); 
              polY[2] = 0; 
              corners = 3; 

             } 

             // N Y 
             else if(c <= 0 && (500*m+c) > 400) { 
              polX[1] = 500; 
              polY[1] = 400; 
              polX[2] = (int)((400-c)/m); 
              polY[2] = 400; 
              polX[3] = (int)((0-c)/m); 
              polY[3] = 0; 
              corners = 4; 
             } 
             // Y N 
             else if(c > 0 && (500*m+c) <= 400) { 
              polX[1] = 500; 
              polY[1] = (int)(500*m+c); 
              polX[2] = 0; 
              polY[2] = (int)c; 
              polX[3] = 0; 
              polY[3] = 0; 
              corners = 4; 
             } 
             // Y Y 
             else if(c > 0 && (500*m+c) > 40){ 
              polX[1] = 500; 
              polY[1] = 400; 
              polX[2] = (int)((400-c)/m); 
              polY[2] = 400; 
              polX[3] = 0; 
              polY[3] = (int)c; 
              polX[4] = 0; 
              polY[4] = 0; 
              corners = 5; 
             } 
             //Origin corners 
             polX[0] = 500; 
             polY[0] = 0; 


             g.fillPolygon(polX, polY, corners); 
            } 
           } 
          } 
         } 

        } 

        else{ 
         //code for horizontal line 
        } 


       } 

       else{ 
        //Vertical 

       } 




      } 
      } 

     g.setColor(new Color(0,255,0,255)); 
     for(int i=0; i<mouse.numPoints; i++){ 
      g.fillOval(aX[i] - 10,aY[i]-10,20,20); 
     } 


     // Drawing The Line ////// 
     for(int i=0; i<mouse.numPoints;i++){ 

      for(int j = i+1; j < mouse.numPoints; j++){ 
       g.setColor(new Color(0,255,0,255)); 
       g.drawLine(aX[i], aY[i], aX[j], aY[j]); 
       g.setColor(new Color(255,0,0,(int)triAng)); 

      } 
     } 
    } 
    } 

उत्तर

1

को पढ़ने के लिए यह एक पिक्सेल की पारदर्शिता को बताने के लिए बहुत मुश्किल है, क्योंकि यह एक बार इसे तैयार किया गया है नहीं है की जरूरत नहीं है ...

पारदर्शिता केवल तभी काम करती है जब आप एक पिक्सेल खींचते हैं: आप एक निश्चित पृष्ठभूमि पर एक निश्चित अल्फा के साथ एक निश्चित रंग खींचते हैं। परिणाम, पिक्सेल ही किसी भी अधिक बार यह तैयार किया गया है कोई अल्फा है ...

तुम्हारे पास क्या है:

  • आप आसानी से एक पिक्सेल से rgb मूल्यों को प्राप्त कर सकते हैं (आप पहले से ही भीतर है कि कोड है आपका कोड) ....
  • आप आमतौर पर ड्रॉ-रंग भी प्राप्त कर सकते हैं (जैसे Color.RED) ....
  • आप बैक-ग्राउंड-रंग का उपयोग भी प्राप्त कर सकते हैं (जैसे Color.WHITE) ....

आपको क्या करना है

  • डेटा ऊपर आप calculate अल्फा मूल्य के लिए है का उपयोग कर!
उदाहरण के लिए

: एक लाल पिक्सेल (मूल 0xFF0000) एक सफेद पर 0x7F0000 है (0xFFFFFF) पृष्ठभूमि निश्चित रूप से मतलब है कि आप 0x7F (50%) की एक पारदर्शिता

लेकिन यहाँ मेरी जानकारी का अभाव है ... आप पारदर्शिता के लिए अपनी गणना कर सकते हैं, मुझे उम्मीद है कि ^^