Refactoring. Starting work with OpenCV
This commit is contained in:
davpapp
parent
90c8cbb33b
commit
1a03890095
BIN
bin/Cursor.class
BIN
bin/Cursor.class
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
BIN
bin/main.class
BIN
bin/main.class
Binary file not shown.
|
|
@ -18,14 +18,10 @@ import java.util.regex.Pattern;
|
|||
|
||||
public class Cursor {
|
||||
|
||||
public static final int NUMBER_OF_DISTANCES = 1000;
|
||||
public static final int NUMBER_OF_DISTANCES = 2203; // For 1080p screen
|
||||
public static final int MINIMUM_CLICK_LENGTH = 120;
|
||||
public static final int MAXIMUM_CLICK_LENGTH = 240;
|
||||
|
||||
public static final int GAME_WINDOW_OFFSET_WIDTH = 100; // top left corner of main game screen, from top left corner of screen
|
||||
public static final int GAME_WINDOW_OFFSET_HEIGHT = 81;
|
||||
|
||||
|
||||
private Robot robot;
|
||||
private Randomizer randomizer;
|
||||
private Random random;
|
||||
|
|
@ -96,38 +92,39 @@ public class Cursor {
|
|||
leftClickCursor();
|
||||
}
|
||||
|
||||
public void moveAndRightClickAtCoordinates(Point goalPoint) throws InterruptedException {
|
||||
moveCursorToCoordinates(goalPoint);
|
||||
rightClickCursor();
|
||||
}
|
||||
|
||||
public Point moveAndLeftClickAtCoordinatesWithRandomness(Point goalPoint, int xTolerance, int yTolerance) throws InterruptedException {
|
||||
Point randomizedGoalPoint = randomizePoint(goalPoint, xTolerance, yTolerance);
|
||||
moveCursorToCoordinates(randomizedGoalPoint);
|
||||
leftClickCursor();
|
||||
return randomizedGoalPoint; // Return the point in case we need precise movement afterwards
|
||||
}
|
||||
|
||||
public void moveAndRightClickAtCoordinates(Point goalPoint) throws InterruptedException {
|
||||
moveCursorToCoordinates(goalPoint);
|
||||
rightClickCursor();
|
||||
return randomizedGoalPoint; // Return the point we moved to in case we need precise movement afterwards
|
||||
}
|
||||
|
||||
public Point moveAndRightlickAtCoordinatesWithRandomness(Point goalPoint, int xTolerance, int yTolerance) throws InterruptedException {
|
||||
Point randomizedGoalPoint = randomizePoint(goalPoint, xTolerance, yTolerance);
|
||||
moveCursorToCoordinates(randomizedGoalPoint);
|
||||
rightClickCursor();
|
||||
return randomizedGoalPoint; // Return the point in case we need precise movement afterwards
|
||||
return randomizedGoalPoint; // Return the point we moved to in case we need precise movement afterwards
|
||||
}
|
||||
|
||||
public void moveCursorToCoordinates(Point goalPoint) throws InterruptedException {
|
||||
Point startingPoint = getCurrentCursorPoint();
|
||||
int distanceToMoveCursor = getDistanceBetweenPoints(startingPoint, goalPoint);
|
||||
double angleToRotateCursorPathTo = getThetaBetweenPoints(startingPoint, goalPoint);
|
||||
System.out.println("R:" + distanceToMoveCursor + ", theta:" + angleToRotateCursorPathTo);
|
||||
if (distanceToMoveCursor == 0) {
|
||||
return;
|
||||
}
|
||||
double angleToMoveCursor = getThetaBetweenPoints(startingPoint, goalPoint);
|
||||
|
||||
CursorPath cursorPathToFollow = chooseCursorPathToFollowBasedOnDistance(distanceToMoveCursor);
|
||||
|
||||
double angleToTranslatePathBy = angleToMoveCursor - cursorPathToFollow.getCursorPathTheta();
|
||||
|
||||
followCursorPath(startingCursorPoint, angleToTranslatePathBy, cursorPathToFollow);
|
||||
CursorPath cursorPathWithDistanceSet = chooseCursorPathToFollowBasedOnDistance(distanceToMoveCursor);
|
||||
CursorPath cursorPathWithDistanceAndAngleSet = cursorPathWithDistanceSet.getRotatedCopyOfCursorPath(angleToRotateCursorPathTo);
|
||||
System.out.println("Rotated the points: ");
|
||||
//cursorPathWithDistanceAndAngleSet.displayCursorPoints();
|
||||
followCursorPath(cursorPathWithDistanceAndAngleSet, startingPoint);
|
||||
}
|
||||
|
||||
public int getDistanceBetweenPoints(Point startingPoint, Point goalPoint) {
|
||||
|
|
@ -135,14 +132,14 @@ public class Cursor {
|
|||
}
|
||||
|
||||
public double getThetaBetweenPoints(Point startingPoint, Point goalPoint) {
|
||||
return Math.atan2(goalPoint.x - startingPoint.x, goalPoint.y - startingPoint.y);
|
||||
return Math.atan2((goalPoint.x - startingPoint.x), (goalPoint.y - startingPoint.y));
|
||||
}
|
||||
|
||||
private void followCursorPath(Point startingCursorPoint, double angleToTranslatePathBy, CursorPath cursorPathToFollow) throws InterruptedException {
|
||||
for (CursorPoint untranslatedCursorPoint : cursorPathToFollow.getCursorPathPoints()) {
|
||||
Point translatedPointToClick = translatePoint(startingCursorPoint, angleToTranslatePathBy, untranslatedCursorPoint);
|
||||
private void followCursorPath(CursorPath cursorPathToFollow, Point startingPoint) throws InterruptedException {
|
||||
for (CursorPoint cursorPoint : cursorPathToFollow.getCursorPathPoints()) {
|
||||
Point translatedPointToClick = new Point(cursorPoint.x + startingPoint.x, cursorPoint.y + startingPoint.y);
|
||||
robotMouseMove(translatedPointToClick);
|
||||
Thread.sleep(untranslatedCursorPoint.delay);
|
||||
Thread.sleep(cursorPoint.delay);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -153,11 +150,13 @@ public class Cursor {
|
|||
private CursorPath chooseCursorPathToFollowBasedOnDistance(int distanceToMoveCursor) {
|
||||
int newDistanceToMoveCursor = findNearestPathLengthThatExists(distanceToMoveCursor);
|
||||
double scaleToFactorBy = getScaleToFactorBy(newDistanceToMoveCursor, distanceToMoveCursor);
|
||||
|
||||
System.out.println("new distance to follow cursor is: " + newDistanceToMoveCursor);
|
||||
ArrayList<CursorPath> cursorPathsWithSameDistance = cursorPathsByDistance.get(newDistanceToMoveCursor);
|
||||
int indexOfRandomPathToFollow = random.nextInt(cursorPathsWithSameDistance.size());
|
||||
ArrayList<CursorPoint> scaledCursorPath = cursorPathsWithSameDistance.get(indexOfRandomPathToFollow).getScaledCopyOfCursorPath(scaleToFactorBy);
|
||||
return scaledCursorPath;
|
||||
//CursorPath scaledCursorPath = cursorPathsWithSameDistance.get(indexOfRandomPathToFollow).getScaledCopyOfCursorPath(scaleToFactorBy);
|
||||
//System.out.println("Chose the following path: ");
|
||||
//scaledCursorPath.displayCursorPoints();
|
||||
return cursorPathsByDistance.get(newDistanceToMoveCursor).get(indexOfRandomPathToFollow);//scaledCursorPath;
|
||||
}
|
||||
|
||||
private int findNearestPathLengthThatExists(int distanceToMoveCursor) {
|
||||
|
|
@ -188,7 +187,7 @@ public class Cursor {
|
|||
}
|
||||
|
||||
public void displayCursorPaths() {
|
||||
for (int i = 0; i < 200; i++) {
|
||||
for (int i = 0; i < 1000; i++) {
|
||||
System.out.println("There are " + cursorPathsByDistance.get(i).size() + " paths of size " + i);
|
||||
}
|
||||
System.out.println("--------------");
|
||||
|
|
|
|||
|
|
@ -26,8 +26,8 @@ public class CursorDataFileParser {
|
|||
String line;
|
||||
CursorPoint lastCursorPoint = new CursorPoint(0, 0, 0);
|
||||
int numberOfRepeats = 0;
|
||||
ArrayList<CursorPoint> currentCursorPath = new ArrayList<CursorPoint>();
|
||||
currentCursorPath.add(lastCursorPoint);
|
||||
ArrayList<CursorPoint> currentCursorPoints = new ArrayList<CursorPoint>();
|
||||
currentCursorPoints.add(lastCursorPoint);
|
||||
|
||||
while ((line = bufferedReader.readLine()) != null) {
|
||||
if (lineMatchesPattern(line)) {
|
||||
|
|
@ -35,14 +35,14 @@ public class CursorDataFileParser {
|
|||
if (cursorPointsHaveEqualCoordinates(newCursorPoint, lastCursorPoint)) {
|
||||
numberOfRepeats++;
|
||||
if (numberOfRepeats == 20) {
|
||||
CursorPath newCursorPath = new CursorPath(currentCursorPath);
|
||||
CursorPath newCursorPath = new CursorPath(currentCursorPoints);
|
||||
cursorPaths.add(newCursorPath);
|
||||
currentCursorPath.clear();
|
||||
currentCursorPoints.clear();
|
||||
}
|
||||
}
|
||||
else {
|
||||
numberOfRepeats = 0;
|
||||
currentCursorPath.add(newCursorPoint);
|
||||
currentCursorPoints.add(newCursorPoint);
|
||||
lastCursorPoint = newCursorPoint;
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -19,22 +19,32 @@ public class CursorPath {
|
|||
this.timespan = calculateCursorPathTimespan();
|
||||
}
|
||||
|
||||
public CursorPath(ArrayList<CursorPoint> cursorPoints, boolean setInitializiationOff)
|
||||
{
|
||||
this.cursorPoints = cursorPoints;
|
||||
this.distance = calculateCursorPathDistance();
|
||||
this.theta = calculateCursorPathTheta();
|
||||
this.timespan = calculateCursorPathTimespan();
|
||||
}
|
||||
|
||||
private ArrayList<CursorPoint> initializePathOfCursorPoints(ArrayList<CursorPoint> cursorPoints) {
|
||||
CursorPoint startingCursorPoint = cursorPoints.get(0);
|
||||
ArrayList<CursorPoint> translatedCursorPoints = getTranslatedCopyOfCursorPath(cursorPoints, startingCursorPoint);
|
||||
ArrayList<CursorPoint> normalizedDelayCursorPoints = getNormalizedDelayCopyOfCursorPath(translatedCursorPoints);
|
||||
ArrayList<CursorPoint> translatedCursorPoints = getTranslatedListOfCursorPoints(cursorPoints, startingCursorPoint);
|
||||
ArrayList<CursorPoint> normalizedDelayCursorPoints = getNormalizedDelayListOfCursorPoints(translatedCursorPoints);
|
||||
return normalizedDelayCursorPoints;
|
||||
}
|
||||
|
||||
private CursorPath getTranslatedCopyOfCursorPath(ArrayList<CursorPoint> cursorPoints, CursorPoint cursorPointToTranslateBy) {
|
||||
ArrayList<CursorPoint> offsetCursorPath = new ArrayList<CursorPoint>();
|
||||
// util
|
||||
private ArrayList<CursorPoint> getTranslatedListOfCursorPoints(ArrayList<CursorPoint> cursorPoints, CursorPoint cursorPointToTranslateBy) {
|
||||
ArrayList<CursorPoint> translatedCursorPath = new ArrayList<CursorPoint>();
|
||||
for (CursorPoint cursorPoint : cursorPoints) {
|
||||
offsetCursorPath.add(cursorPoint.getCursorPointTranslatedBy(cursorPointToTranslateBy));
|
||||
translatedCursorPath.add(cursorPoint.getCursorPointTranslatedBy(cursorPointToTranslateBy));
|
||||
}
|
||||
return new CursorPath(offsetCursorPath);
|
||||
return translatedCursorPath;
|
||||
}
|
||||
|
||||
private CursorPath getNormalizedDelayCopyOfCursorPath(ArrayList<CursorPoint> cursorPoints) {
|
||||
//util
|
||||
private ArrayList<CursorPoint> getNormalizedDelayListOfCursorPoints(ArrayList<CursorPoint> cursorPoints) {
|
||||
ArrayList<CursorPoint> normalizedDelayCursorPoints = new ArrayList<CursorPoint>();
|
||||
for (int i = 0; i < cursorPoints.size() - 1; i++) {
|
||||
CursorPoint cursorPoint = cursorPoints.get(i);
|
||||
|
|
@ -42,24 +52,27 @@ public class CursorPath {
|
|||
normalizedDelayCursorPoints.add(cursorPoint.getCursorPointWithNewDelay(nextCursorPoint.delay - cursorPoint.delay));
|
||||
}
|
||||
normalizedDelayCursorPoints.add(cursorPoints.get(cursorPoints.size() - 1).getCursorPointWithNewDelay(0));
|
||||
return new CursorPath(normalizedDelayCursorPoints);
|
||||
return normalizedDelayCursorPoints;
|
||||
}
|
||||
|
||||
|
||||
public CursorPath getScaledCopyOfCursorPath(ArrayList<CursorPoint> cursorPoints, double factorToScaleBy) {
|
||||
//util
|
||||
public CursorPath getScaledCopyOfCursorPath(double factorToScaleBy) {
|
||||
ArrayList<CursorPoint> scaledCursorPath = new ArrayList<CursorPoint>();
|
||||
for (CursorPoint cursorPoint : cursorPoints) {
|
||||
for (CursorPoint cursorPoint : this.cursorPoints) {
|
||||
scaledCursorPath.add(cursorPoint.getCursorPointScaledBy(factorToScaleBy));
|
||||
}
|
||||
return new CursorPath(scaledCursorPath);
|
||||
return new CursorPath(scaledCursorPath, true);
|
||||
}
|
||||
|
||||
public CursorPath getRotatedCopyOfCursorPath(ArrayList<CursorPoint> cursorPoints, double angleToRotateBy) {
|
||||
//util
|
||||
public CursorPath getRotatedCopyOfCursorPath(double angleToRotateTo) {
|
||||
ArrayList<CursorPoint> rotatedCursorPath = new ArrayList<CursorPoint>();
|
||||
for (CursorPoint cursorPoint : cursorPoints) {
|
||||
double angleToRotateBy = this.theta - angleToRotateTo;
|
||||
System.out.println("Rotating points by: " + angleToRotateBy);
|
||||
for (CursorPoint cursorPoint : this.cursorPoints) {
|
||||
rotatedCursorPath.add(cursorPoint.getCursorPointRotatedBy(angleToRotateBy));
|
||||
}
|
||||
return new CursorPath(rotatedCursorPath);
|
||||
return new CursorPath(rotatedCursorPath, true);
|
||||
}
|
||||
|
||||
private int calculateCursorPathTimespan() {
|
||||
|
|
@ -71,12 +84,11 @@ public class CursorPath {
|
|||
}
|
||||
|
||||
private int calculateCursorPathDistance() {
|
||||
return (int) (getStartingCursorPoint().getDistanceFrom(getEndingCursorPoint()));
|
||||
return (int) (getEndingCursorPoint().getDistanceFromOrigin());
|
||||
}
|
||||
|
||||
private double calculateCursorPathTheta() {
|
||||
CursorPoint endingCursorPoint = getEndingCursorPoint();
|
||||
return Math.atan2(endingCursorPoint.y, endingCursorPoint.x);
|
||||
return getEndingCursorPoint().getThetaFromOrigin();
|
||||
}
|
||||
|
||||
public CursorPoint getStartingCursorPoint() {
|
||||
|
|
@ -102,7 +114,7 @@ public class CursorPath {
|
|||
}
|
||||
|
||||
private boolean isCursorPathNumPointsReasonable() {
|
||||
return (this.cursorPoints.size() > 0 && this.cursorPoints.size() < 50);
|
||||
return (this.cursorPoints.size() > 0 && this.cursorPoints.size() < 80);
|
||||
}
|
||||
|
||||
public ArrayList<CursorPoint> getCursorPathPoints() {
|
||||
|
|
@ -122,7 +134,7 @@ public class CursorPath {
|
|||
for (CursorPoint p : this.cursorPoints) {
|
||||
p.display();
|
||||
}
|
||||
System.out.println("Number of points:" + this.cursorPoints.size() + ", Timespan:" + this.timespan);
|
||||
System.out.println("Number of points:" + this.cursorPoints.size() + ", Timespan:" + this.timespan + ", Distance: " + this.distance + ", Theta: " + this.theta);
|
||||
System.out.println("~~~~~~~~~~~~~~~~~~~~~~~~~~ End of Path ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~");
|
||||
}
|
||||
}
|
||||
|
|
@ -10,21 +10,30 @@ class CursorPathTest {
|
|||
|
||||
|
||||
@Test
|
||||
void testCursorPathOffset() {
|
||||
void testCursorPaths() {
|
||||
initializeCursorPath();
|
||||
|
||||
for (CursorPath cursorPath : cursorPaths) {
|
||||
cursorPath.displayCursorPoints();
|
||||
|
||||
testCursorPathStartsAtOrigin(cursorPath);
|
||||
testEndingCursorPointInCursorPathHasZeroDelay(cursorPath);
|
||||
testCursorPathDistance(cursorPath);
|
||||
testCursorPathTheta(cursorPath);
|
||||
//testCursorPathLocations(cursorPath);
|
||||
|
||||
testCursorPathRotation(cursorPath, Math.PI);
|
||||
testCursorPathRotation(cursorPath, 7 / 4 * Math.PI);
|
||||
testCursorPathScaling(cursorPath, 1.15);
|
||||
cursorPath.displayCursorPoints();
|
||||
|
||||
testCopyTime(cursorPath);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
private void initializeCursorPath() {
|
||||
CursorDataFileParser cursorDataFileParser = new CursorDataFileParser("/home/dpapp/eclipse-workspace/RunescapeAI/testfiles/cursorPathTest.txt");
|
||||
this.cursorPaths = cursorDataFileParser.getArrayListOfCursorPathsFromFile();
|
||||
}
|
||||
|
||||
private void testCursorPathStartsAtOrigin(CursorPath cursorPath) {
|
||||
CursorPoint startingCursorPoint = cursorPath.getStartingCursorPoint();
|
||||
assertTrue(startingCursorPoint.x == 0 && startingCursorPoint.y == 0);
|
||||
|
|
@ -32,63 +41,58 @@ class CursorPathTest {
|
|||
|
||||
private void testEndingCursorPointInCursorPathHasZeroDelay(CursorPath cursorPath) {
|
||||
CursorPoint endingCursorPoint = cursorPath.getEndingCursorPoint();
|
||||
assertEquals(endingCursorPoint.delay, 0);
|
||||
assertEquals(0, endingCursorPoint.delay);
|
||||
}
|
||||
|
||||
private void testCursorPathDistance(CursorPath cursorPath) {
|
||||
int distance = cursorPath.getCursorPathDistance();
|
||||
int cursorPathDistance = cursorPath.getCursorPathDistance();
|
||||
CursorPoint startingCursorPoint = cursorPath.getStartingCursorPoint();
|
||||
CursorPoint endingCursorPoint = cursorPath.getEndingCursorPoint();
|
||||
|
||||
int actualDistance = (int) Math.hypot(startingCursorPoint.x - endingCursorPoint.x, startingCursorPoint.y - endingCursorPoint.y);
|
||||
assertEquals(distance, actualDistance);
|
||||
startingCursorPoint.display();
|
||||
endingCursorPoint.display();
|
||||
int expectedDistance = (int) Math.hypot(startingCursorPoint.x - endingCursorPoint.x, startingCursorPoint.y - endingCursorPoint.y);
|
||||
assertEquals(expectedDistance, cursorPathDistance);
|
||||
}
|
||||
|
||||
private void testCursorPathTheta(CursorPath cursorPath) {
|
||||
double theta = cursorPath.getCursorPathTheta();
|
||||
CursorPoint startingCursorPoint = cursorPath.getStartingCursorPoint();
|
||||
CursorPoint endingCursorPoint = cursorPath.getEndingCursorPoint();
|
||||
double actualTheta = Math.atan2(endingCursorPoint.y, endingCursorPoint.x);
|
||||
double actualTheta = Math.atan2(endingCursorPoint.x - startingCursorPoint.x, endingCursorPoint.y - startingCursorPoint.y);
|
||||
assertEquals(theta, actualTheta);
|
||||
}
|
||||
/*private void testCursorPathLocations(CursorPath cursorPath) {
|
||||
|
||||
}*/
|
||||
|
||||
void testCursorPathRotation(CursorPath cursorPath, double angleToRotateBy) {
|
||||
void testCursorPathRotation(CursorPath cursorPath, double angleToRotateTo) {
|
||||
CursorPath rotatedCursorPath = cursorPath.getRotatedCopyOfCursorPath(angleToRotateTo);
|
||||
assertEquals(angleToRotateTo, rotatedCursorPath.getCursorPathTheta());
|
||||
|
||||
ArrayList<CursorPoint> cursorPoints = cursorPath.getCursorPathPoints();
|
||||
ArrayList<CursorPoint> rotatedCursorPoints = cursorPath.getRotatedCopyOfCursorPath(angleToRotateBy);
|
||||
ArrayList<CursorPoint> rotatedCursorPoints = rotatedCursorPath.getCursorPathPoints();
|
||||
assertEquals(cursorPoints.size(), rotatedCursorPoints.size());
|
||||
for (int i = 1; i < cursorPoints.size(); i++) {
|
||||
double originalThetaOfCursorPoint = cursorPoints.get(i).getTheta();
|
||||
double rotatedThetaOfCursorPoint = rotatedCursorPoints.get(i).getTheta();
|
||||
System.out.println((originalThetaOfCursorPoint + angleToRotateBy) % (Math.PI) + "," + rotatedThetaOfCursorPoint);
|
||||
//assertInRangeByAbsoluteValue(originalThetaOfCursorPoint + angleToRotateBy, rotatedThetaOfCursorPoint, 3);
|
||||
}
|
||||
}
|
||||
|
||||
void testCursorPathScaling(CursorPath cursorPath, double factorToScaleBy) {
|
||||
ArrayList<CursorPoint> cursorPoints = cursorPath.getCursorPathPoints();
|
||||
ArrayList<CursorPoint> scaledCursorPoints = cursorPath.getScaledCopyOfCursorPath(factorToScaleBy);
|
||||
assertEquals(cursorPoints.size(), scaledCursorPoints.size());
|
||||
CursorPoint startingPoint = cursorPoints.get(0);
|
||||
for (int i = 0; i < cursorPoints.size(); i++) {
|
||||
double originalDistanceOfCursorPoint = cursorPoints.get(i).getDistanceFrom(startingPoint);
|
||||
double scaledDistanceOfCursorPoint = scaledCursorPoints.get(i).getDistanceFrom(startingPoint);
|
||||
assertInRangeByAbsoluteValue(originalDistanceOfCursorPoint * factorToScaleBy, scaledDistanceOfCursorPoint, 3);
|
||||
}
|
||||
}
|
||||
|
||||
void initializeCursorPath() {
|
||||
CursorDataFileParser cursorDataFileParser = new CursorDataFileParser("/home/dpapp/eclipse-workspace/RunescapeAI/testfiles/cursorPathTest.txt");
|
||||
this.cursorPaths = cursorDataFileParser.getArrayListOfCursorPathsFromFile();
|
||||
|
||||
}
|
||||
|
||||
void assertInRangeByRatio(double expected, double actual, double toleranceRatio) {
|
||||
assertTrue((actual <= (expected * (1.0 + toleranceRatio))) && (actual >= (expected * (1.0 - toleranceRatio))));
|
||||
void testCopyTime(CursorPath cursorPath) {
|
||||
CursorPath rotatedCursorPath = cursorPath.getRotatedCopyOfCursorPath(2.3 / 9.0 * Math.PI);
|
||||
ArrayList<CursorPoint> cursorPoints = cursorPath.getCursorPathPoints();
|
||||
ArrayList<CursorPoint> rotatedCursorPoints = rotatedCursorPath.getCursorPathPoints();
|
||||
assertEquals(cursorPoints.size(), rotatedCursorPoints.size());
|
||||
for (int i = 0; i < cursorPoints.size(); i++) {
|
||||
assertEquals(cursorPoints.get(i).delay, rotatedCursorPoints.get(i).delay);
|
||||
}
|
||||
}
|
||||
|
||||
void testCursorPathScaling(CursorPath cursorPath, double factorToScaleBy) {
|
||||
CursorPath scaledCursorPath = cursorPath.getScaledCopyOfCursorPath(factorToScaleBy);
|
||||
|
||||
ArrayList<CursorPoint> cursorPoints = cursorPath.getCursorPathPoints();
|
||||
ArrayList<CursorPoint> scaledCursorPoints = scaledCursorPath.getCursorPathPoints();
|
||||
assertEquals(cursorPoints.size(), scaledCursorPoints.size());
|
||||
}
|
||||
|
||||
void assertInRangeByAbsoluteValue(double valueToTest, double expectation, double toleranceAbsolute) {
|
||||
assertTrue((valueToTest <= (expectation + toleranceAbsolute)) && (valueToTest >= (expectation * (1 - toleranceAbsolute))));
|
||||
void assertInRangeByTolerance(double expected, double actual, double tolerance) {
|
||||
assertTrue((actual <= (expected + tolerance)) && (actual >= (expected - tolerance)));
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -12,26 +12,26 @@ public class CursorPoint {
|
|||
this.delay = delay;
|
||||
}
|
||||
|
||||
public double getDistanceFrom(CursorPoint b) {
|
||||
return Math.hypot(this.x - b.x, this.y - b.y);
|
||||
public double getDistanceFromOrigin() {
|
||||
return Math.hypot(this.x, this.y);
|
||||
}
|
||||
|
||||
public double getTheta() {
|
||||
return Math.atan2(this.y, this.x);
|
||||
public double getThetaFromOrigin() {
|
||||
return Math.atan2(this.x, this.y);
|
||||
}
|
||||
|
||||
public CursorPoint getCursorPointTranslatedBy(CursorPoint startingCursorPoint) {
|
||||
return new CursorPoint(this.x - startingCursorPoint.x, this.y - startingCursorPoint.y, this.delay - startingCursorPoint.delay);
|
||||
return new CursorPoint(x - startingCursorPoint.x, y - startingCursorPoint.y, delay - startingCursorPoint.delay);
|
||||
}
|
||||
|
||||
public CursorPoint getCursorPointScaledBy(double scaleFactor) {
|
||||
return (new CursorPoint((int) (this.x * scaleFactor), (int) (this.y * scaleFactor), (int) (this.delay * scaleFactor)));
|
||||
return (new CursorPoint((int) (this.x * scaleFactor), (int) (this.y * scaleFactor), (int) (delay * scaleFactor)));
|
||||
}
|
||||
|
||||
public CursorPoint getCursorPointRotatedBy(double angleOfRotation) {
|
||||
int rotatedX = (int) (Math.cos(angleOfRotation) * this.x - Math.sin(angleOfRotation) * this.y);
|
||||
int rotatedY = (int) (Math.sin(angleOfRotation) * this.x + Math.cos(angleOfRotation) * this.y);
|
||||
return (new CursorPoint(rotatedX, rotatedY, this.delay));
|
||||
return (new CursorPoint(rotatedX, rotatedY, delay));
|
||||
}
|
||||
|
||||
public CursorPoint getCursorPointWithNewDelay(int delay) {
|
||||
|
|
|
|||
|
|
@ -5,17 +5,34 @@ import org.junit.jupiter.api.Test;
|
|||
class CursorPointTest {
|
||||
|
||||
@Test
|
||||
void testDistanceFrom() {
|
||||
void testDistanceFromOrigin() {
|
||||
CursorPoint a = new CursorPoint(0, 0, 0);
|
||||
CursorPoint b = new CursorPoint(3, 4, 0);
|
||||
CursorPoint c = new CursorPoint(500, 750, 0);
|
||||
CursorPoint d = new CursorPoint(284, 848, 0);
|
||||
|
||||
assertTrue(withinRangeByRatio(a.getDistanceFrom(b), 5, 0.0001));
|
||||
assertTrue(withinRangeByRatio(a.getDistanceFrom(c), 901.387818866, 0.0001));
|
||||
assertTrue(withinRangeByRatio(a.getDistanceFrom(d), 894.293016857, 0.0001));
|
||||
assertTrue(withinRangeByRatio(b.getDistanceFrom(c), 896.395560007, 0.0001));
|
||||
assertTrue(withinRangeByRatio(c.getDistanceFrom(d), 237.191905427, 0.0001));
|
||||
assertEquals(0, a.getDistanceFromOrigin());
|
||||
assertTrue(withinRangeByRatio(a.getDistanceFromOrigin(), 901.387818866, 0.0001));
|
||||
assertTrue(withinRangeByRatio(a.getDistanceFromOrigin(), 894.293016857, 0.0001));
|
||||
assertTrue(withinRangeByRatio(b.getDistanceFromOrigin(), 896.395560007, 0.0001));
|
||||
assertTrue(withinRangeByRatio(c.getDistanceFromOrigin(), 237.191905427, 0.0001));
|
||||
}
|
||||
|
||||
@Test
|
||||
void testThetaFromOrigin() {
|
||||
CursorPoint a = new CursorPoint(0, 0, 0);
|
||||
CursorPoint b = new CursorPoint(3, 4, 0);
|
||||
CursorPoint c = new CursorPoint(500, 750, 0);
|
||||
CursorPoint d = new CursorPoint(284, 848, 0);
|
||||
CursorPoint e = new CursorPoint(10, 0, 0);
|
||||
CursorPoint f = new CursorPoint(0, 10, 0);
|
||||
|
||||
assertEquals(0, a.getThetaFromOrigin());
|
||||
assertEquals(0.6435011087932844, b.getThetaFromOrigin());
|
||||
assertEquals(0.5880026035475675, c.getThetaFromOrigin());
|
||||
assertEquals(0.32316498061040844, d.getThetaFromOrigin());
|
||||
assertEquals(1.5707963267948966, e.getThetaFromOrigin());
|
||||
assertEquals(0.0, f.getThetaFromOrigin());
|
||||
}
|
||||
|
||||
@Test
|
||||
|
|
@ -51,6 +68,8 @@ class CursorPointTest {
|
|||
assertTrue(h.x == -428 && h.y == -321);
|
||||
}
|
||||
|
||||
|
||||
|
||||
boolean withinRangeByRatio(double actual, double expectation, double toleranceRatio) {
|
||||
return ((actual <= (expectation * (1 + toleranceRatio))) && (actual >= (expectation * (1 - toleranceRatio))));
|
||||
}
|
||||
|
|
|
|||
|
|
@ -12,23 +12,28 @@ class CursorTest {
|
|||
|
||||
void initialize() throws AWTException {
|
||||
cursor = new Cursor();
|
||||
cursorTolerance = 3;
|
||||
cursorTolerance = 5;
|
||||
}
|
||||
|
||||
@Test
|
||||
void testMoveCursorToCoordinatesHelper() throws InterruptedException, AWTException {
|
||||
initialize();
|
||||
cursor.displayCursorPaths();
|
||||
|
||||
testThetaBetweenPoints();
|
||||
testMoveCursorToCoordinates();
|
||||
testRightClickCursor();
|
||||
//testRightClickCursor();
|
||||
}
|
||||
|
||||
@Test
|
||||
void testThetaBetweenPoints() {
|
||||
Point a = new Point(0, 0);
|
||||
Point b = new Point(10, 0);
|
||||
Point c = new Point(10, 10);
|
||||
Point d = new Point(20, 10);
|
||||
assertEquals(cursor.getThetaBetweenPoints(a, b), 0);
|
||||
assertEquals(degreesToRadians(90), cursor.getThetaBetweenPoints(a, b));
|
||||
assertEquals(degreesToRadians(45), cursor.getThetaBetweenPoints(a, c));
|
||||
assertEquals(1.1071487177940904, cursor.getThetaBetweenPoints(a, d));
|
||||
assertEquals(degreesToRadians(45), cursor.getThetaBetweenPoints(b, d));
|
||||
}
|
||||
|
||||
void testMoveCursorToCoordinates() throws InterruptedException {
|
||||
|
|
@ -52,7 +57,7 @@ class CursorTest {
|
|||
testMoveCursorToCoordinates(a, g);
|
||||
}
|
||||
|
||||
void testRightClickCursor() throws InterruptedException {
|
||||
/*void testRightClickCursor() throws InterruptedException {
|
||||
Point a = new Point(375, 600);
|
||||
Point b = new Point(952, 603);
|
||||
Point c = new Point(1025, 133);
|
||||
|
|
@ -61,21 +66,24 @@ class CursorTest {
|
|||
testMoveAndRightClickCursor(b, c);
|
||||
testMoveAndRightClickCursor(c, d);
|
||||
testMoveAndRightClickCursor(d, a);
|
||||
}
|
||||
}*/
|
||||
|
||||
void testMoveAndRightClickCursor(Point a, Point b) throws InterruptedException {
|
||||
/*void testMoveAndRightClickCursor(Point a, Point b) throws InterruptedException {
|
||||
cursor.robotMouseMove(a);
|
||||
cursor.moveAndRightClickAtCoordinates(b);
|
||||
Point point = cursor.getCurrentCursorPoint();
|
||||
System.out.println("Cursor ended up on " + point.x + "," + point.y);
|
||||
verifyCursorIsInCorrectPlace(point, b);
|
||||
// Way to verify that context menu is open?
|
||||
}
|
||||
}*/
|
||||
|
||||
void testMoveCursorToCoordinates(Point a, Point b) throws InterruptedException {
|
||||
cursor.robotMouseMove(a);
|
||||
cursor.moveCursorToCoordinates(b);
|
||||
Point point = cursor.getCurrentCursorPoint();
|
||||
System.out.println("Cursor ended up on " + point.x + "," + point.y);
|
||||
verifyCursorIsInCorrectPlace(point, b);
|
||||
Thread.sleep(500);
|
||||
}
|
||||
|
||||
void verifyCursorIsInCorrectPlace(Point actualPoint, Point expectedPoint) {
|
||||
|
|
@ -90,6 +98,10 @@ class CursorTest {
|
|||
void assertInRangeByAbsoluteValue(double valueToTest, double expectation, double toleranceAbsolute) {
|
||||
assertTrue((valueToTest <= (expectation + toleranceAbsolute)) && (valueToTest >= (expectation * (1 - toleranceAbsolute))));
|
||||
}
|
||||
|
||||
private double degreesToRadians(double degrees) {
|
||||
return degrees * Math.PI / 180.0;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
|
|
@ -0,0 +1,11 @@
|
|||
import org.opencv.core.Core;
|
||||
import org.opencv.core.CvType;
|
||||
import org.opencv.core.Mat;
|
||||
|
||||
public class OpenCVTest {
|
||||
public static void main( String[] args ) {
|
||||
System.loadLibrary(Core.NATIVE_LIBRARY_NAME);
|
||||
Mat mat = Mat.eye(3, 3, CvType.CV_8UC1);
|
||||
System.out.println("mat = " + mat.dump());
|
||||
}
|
||||
}
|
||||
|
|
@ -8,7 +8,7 @@ public class main {
|
|||
|
||||
public static void main(String[] args) throws AWTException, InterruptedException, IOException {
|
||||
|
||||
Cursor cursor = new Cursor();
|
||||
/*Cursor cursor = new Cursor();
|
||||
CursorTask cursorTask = new CursorTask();
|
||||
Inventory inventory = new Inventory();
|
||||
|
||||
|
|
@ -19,7 +19,7 @@ public class main {
|
|||
cursorTask.optimizedDropAllItemsInInventory(cursor, inventory);
|
||||
}
|
||||
Thread.sleep(100);
|
||||
}
|
||||
} */
|
||||
//cursor.moveCursorToCoordinates(new Point(620, 420));
|
||||
|
||||
}
|
||||
|
|
|
|||
Loading…
Reference in New Issue