जावा रोबोट क्लास मानव माउस आंदोलन अनुकरण

Question

मैं रिमोट कंट्रोल के बारे में एक परियोजना पर काम कर रहा हूं, क्लाइंट से सर्वर पर कर्सर के समन्वय एक्स और वाई भेजें।

लेकिन

robot.mouseMove(x,y); 

केवल कर्सर प्रपत्र मूल बिंदु

मैं इस सरल algorthim माउस के सतत आंदोलन अनुकरण करने के लिए लगता है है ले जाए बिना विशेष बात करने के लिए कर्सर ले जाने के होगा

for (int i=0; i<100; i++){ 
    int x = ((end_x * i)/100) + (start_x*(100-i)/100); 
int y = ((end_y * i)/100) + (start_y*(100-i)/100); 
robot.mouseMove(x,y); 
} 

लेकिन यह अल्गौर्थिम अभी भी बहुत आसान है, यह धीरे-धीरे एक बिंदु से दूसरे बिंदु पर धीरे-धीरे चलता है, जो अभी भी मानव व्यवहार के विपरीत है।

मैं वेब से रिमोट कंट्रोल के बारे में कुछ खुले soruce कोड को पढ़ लिया है, और मैं MouseListener वर्ग से विधि कॉल MosueMovement, जो वे "खींच" प्रदर्शन करने के लिए का उपयोग उपयोग कर रहा है इस परियोजना http://code.google.com/p/java-remote-control/ पाते हैं।

मुझे यह जानना अच्छा है कि कोई ऐसा करने का बेहतर तरीका जानता है?

Answer 1

कुछ बातों पर विचार करने के लिए आप कृत्रिम आंदोलन प्राकृतिक बनाना चाहते हैं तो कर रहे हैं, मुझे लगता है कि:

1. मानव माउस आंदोलन क्योंकि कलाई चारों ओर माउस हाथ pivots के एक मामूली चाप में आमतौर पर है। इसके अलावा चाप लंबवत की तुलना में क्षैतिज आंदोलनों के लिए अधिक स्पष्ट है।
2. मनुष्य सामान्य दिशा में जाते हैं, अक्सर लक्ष्य को ओवरहूट करते हैं और फिर वास्तविक लक्ष्य पर वापस जाते हैं।
3. लक्ष्य की ओर प्रारंभिक गति काफी तेज़ है (इसलिए उपर्युक्त ओवरहूट) और फिर सटीक लक्ष्यीकरण के लिए थोड़ा धीमा है। हालांकि, अगर कर्सर लक्ष्य के करीब है तो शुरुआत में त्वरित कदम नहीं होता है (और न ही ओवरशूट करता है)।

हालांकि यह एल्गोरिदम में फ़ॉर्मूलेट करने के लिए थोड़ा जटिल है।

Answer 2

मैंने लिखा इस उदाहरण में एक नज़र डालें। जॉय ने जो कहा वह अनुकरण करने के लिए आप इसे बेहतर बना सकते हैं। मैंने इसे बहुत तेज़ लिखा और ऐसी कई चीजें हैं जिन्हें बेहतर किया जा सकता है (एल्गोरिदम और क्लास डिज़ाइन)। ध्यान दें कि मैं केवल बाएं से दाएं आंदोलनों से निपटता हूं।

import java.awt.AWTException; 
import java.awt.MouseInfo; 
import java.awt.Point; 
import java.awt.Robot; 

public class MouseMoving { 

    public static void main(String[] args) { 
     new MouseMoving().execute(); 
    } 

    public void execute() { 
     new Thread(new MouseMoveThread(100, 50, 50, 10)).start(); 
    } 

    private class MouseMoveThread implements Runnable { 

     private Robot robot; 
     private int startX; 
     private int startY; 
     private int currentX; 
     private int currentY; 
     private int xAmount; 
     private int yAmount; 
     private int xAmountPerIteration; 
     private int yAmountPerIteration; 
     private int numberOfIterations; 
     private long timeToSleep; 

     public MouseMoveThread(int xAmount, int yAmount, 
       int numberOfIterations, long timeToSleep) { 

      this.xAmount = xAmount; 
      this.yAmount = yAmount; 
      this.numberOfIterations = numberOfIterations; 
      this.timeToSleep = timeToSleep; 

      try { 

       robot = new Robot(); 

       Point startLocation = MouseInfo.getPointerInfo().getLocation(); 
       startX = startLocation.x; 
       startY = startLocation.y; 

      } catch (AWTException exc) { 
       exc.printStackTrace(); 
      } 

     } 

     @Override 
     public void run() { 

      currentX = startX; 
      currentY = startY; 

      xAmountPerIteration = xAmount/numberOfIterations; 
      yAmountPerIteration = yAmount/numberOfIterations; 

      while (currentX < startX + xAmount && 
        currentY < startY + yAmount) { 

       currentX += xAmountPerIteration; 
       currentY += yAmountPerIteration; 

       robot.mouseMove(currentX, currentY); 

       try { 
        Thread.sleep(timeToSleep); 
       } catch (InterruptedException exc) { 
        exc.printStackTrace(); 
       } 

      } 

     } 

    } 

}