2015-02-08 9 views
6

Jestem nowicjuszem w Javie i postanowiłem stworzyć program, który: ustawia punkt w oknie po kliknięciu lewym przyciskiem myszy. A potem kolejny punkt, gdy klikniesz ponownie. I tak dalej ... Potem łączy wszystkie punkty z linii i odcieni bok linii w zależności od tego, ile punktów znajdują się na stronie linii (tak) enter image description herePrzejrzystość pikseli pod myszą - Java JFrame

PYTANIE zaczyna się tutaj.

Teraz potrzebuję jeszcze jednej funkcji. Kiedy kliknę prawym przyciskiem, chcę, aby pojawiła się przezroczystość piksela na współrzędnych myszy. Kiedy klikniesz w środku, pokaże mi, że jest bardziej przezroczysty (lub ciemniejszy) niż wtedy, gdy klikam prawym przyciskiem myszy obszary światła.

Zrobiłem trochę googlowania, ale nie mogłem znaleźć odpowiedzi. Najbliżej było stworzyć zrzut ekranu z robotem i użyć go jako obrazu bufora, a następnie przeanalizować piksele w ten sposób. Jednak wydaje mi się, że nie działa, ponieważ gdziekolwiek prawym kliknięciem otrzymuję 255,255,255,255 dla ARGB. I czasami dziwne rzeczy jak 255,234,236,245 dla AGBA.

Mam nadzieję, że możesz wykonać to, co próbuję zrobić.

Oto mój kod.

Główny klasa którym gwiazdy program tworzy okno i robi interfejs myszy:

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; 
    } 

} 
} 

i mojej klasy Graphics, która zajmuje się cieniowania i rysowanie linii itd ... (większość z nich powtarza się dla każdy przypadek z cieniowaniem, dzięki czemu nie trzeba czytać całość)

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)); 

      } 
     } 
    } 
    } 

Odpowiedz

1

to dość trudno powiedzieć przejrzystości piksela, ponieważ nie ma jednego razu, że został sporządzony ...

Przezroczystość działa tylko, gdy narysujesz piksel: narysujesz określony kolor z pewną alfą na pewnym tle. wynik, sam piksel ma alfa więcej raz została opracowana ...

co masz:

  • można łatwo uzyskać wartości RGB piksela (masz już ten kod w ciągu Twój kod) ...
  • możesz również uzyskać kolor rysowania, którego zwykle używasz (np. Color.RED) ...
  • możesz również uzyskać kolor tła (jak Color.WHITE) ...

co trzeba zrobić

  • korzystając z danych powyżej, musisz obliczyć wartość alfa!

na przykład: czerwony piksel (oryginalna 0xFF0000) jest 0x7F0000 na białym (0xFFFFFF) tło oznacza, że ​​masz przejrzystość 0x7F (50%)

ale tutaj brakuje moją wiedzą na pewno ... Potrafię tworzyć własne obliczenia dla przejrzystości, naprawdę mam nadzieję, że^^