My program contains main shapes i.e square, rect, circle they work good ( for x2,y2 in those shapes I used absolute values e.g square( x, y, 5, 5) ), but when working with triangle shape,
Triangles in my program glitches.
below is the code of my program modules,
if (vehicleStyle.getVehicleShape().equals(VehicleShape.TRIANGLE)) {
processingVisualizer
.fill(vehicleStyle.getColor().red,
vehicleStyle.getColor().green,
vehicleStyle.getColor().blue);
processingVisualizer.strokeWeight(1 * vehicleSize);
//System.out.println(x + "-" + y);
//## to place face toward movement direction
/*
* -----<|----
* | |
* \/ /\
* | |
* -----|>----
*/
float x2, y2, x3, y3;
if (x == 100) {
System.out.println( "x==100");
x2 = x - 5;
y2 = y + 5;
x3 = x + 5;
y3 = y + 5;
processingVisualizer.triangle(x, y, x2, y2, x3, y3);
} else if (x == 20) {
System.out.println( "x==20");
x2 = x - 2;
y2 = y - 2;
x3 = x + 2;
y3 = y - 2;
processingVisualizer.triangle(x, y, x2, y2, x3, y3);
} else if (y == 100) {
System.out.println( "y ==100");
x2 = x - 2;
y2 = y - 2;
x3 = x - 2;
y3 = y + 2;
processingVisualizer.triangle(x, y, x2, y2, x3, y3);
} else if (y == 20) {
System.out.println( "y ==20");
x2 = x+5;//x - 2;
y2 = y-5;
x3 = x+5 ;//- 2;
y3 = y+5;
processingVisualizer.triangle(x, y, x2, y2, x3, y3);
}
}
processingVisualizer.strokeWeight(1);
}
Can't test your code, but my assumption is the "glitch" happens because you are rendering a triangle only when your 4 conditions are met. You should update the triangle's corner positions based on your conditions if you like, but render the triangle all time, even when the positions are out of date:
if (vehicleStyle.getVehicleShape().equals(VehicleShape.TRIANGLE)) {
processingVisualizer
.fill(vehicleStyle.getColor().red,
vehicleStyle.getColor().green,
vehicleStyle.getColor().blue);
processingVisualizer.strokeWeight(1 * vehicleSize);
//System.out.println(x + "-" + y);
//## to place face toward movement direction
/*
* -----<|----
* | |
* \/ /\
* | |
* -----|>----
*/
float x2, y2, x3, y3;
if (x == 100) {
System.out.println( "x==100");
x2 = x - 5;
y2 = y + 5;
x3 = x + 5;
y3 = y + 5;
} else if (x == 20) {
System.out.println( "x==20");
x2 = x - 2;
y2 = y - 2;
x3 = x + 2;
y3 = y - 2;
} else if (y == 100) {
System.out.println( "y ==100");
x2 = x - 2;
y2 = y - 2;
x3 = x - 2;
y3 = y + 2;
} else if (y == 20) {
System.out.println( "y ==20");
x2 = x+5;//x - 2;
y2 = y-5;
x3 = x+5 ;//- 2;
y3 = y+5;
}
processingVisualizer.triangle(x, y, x2, y2, x3, y3);
}
processingVisualizer.strokeWeight(1);
}
Also, you can easily compute the direction of motion, if you store the previous position, using the arc tangent function (atan2()):
float angle = atan2(currentY-previousY,currentX-previousX);
Here's a quick example:
float cx,cy,px,py;//current x,y, previous x,y
float len = 15;
void setup(){
size(200,200);
background(255);
}
void draw(){
//update position - chase mouse with a bit of easing
cx -= (cx - mouseX) * .035;
cy -= (cy - mouseY) * .035;
//find direction of movement based on the current position
float angle = atan2(cy-py,cx-px);
//store previous position
px = cx;
py = cy;
//render
fill(255,10);noStroke();
rect(0,0,width,height);
fill(127,32);stroke(0);
pushMatrix();
translate(cx,cy);
pushMatrix();
rotate(angle);
triangle(len,0,-len,-len,-len,len);
line(0,0,len,0);
popMatrix();
popMatrix();
}
Related
I have a Line(,) on canvas even it may be skewed, all i want to do is , to draw a new parallel line with respect to old Line(,) with equal Line Length.
Tried this one >>>>
double d = getLength(x1, y1, x2, y2);
double m = getSlope(x1, y1, x2, y2);
double r = Math.sqrt(1 + Math.pow(m, 2));
double endX = x + d / r;
double endY = y + ((d * m) / r);
return new double[]{x, y, endX, endY};
To make parallel segment, you need to build perpendicular vector of needed length.
Note that there are two solutions for both sided of segment
dx = x2 - x1
dy = y2 - y1
len = sqrt(dx*dx+dy*dy)
perpx = -dy * distance / len
perpy = dx * distance / len
// "left" line start
x1' = x1 + perpx
y1' = y1 + perpy
// "left" line end
x2' = x2 + perpx
y2' = y2 + perpy
// "right" line
x1'' = x1 - perpx
y1'' = y1 - perpy
x2'' = x2 - perpx
y2'' = y2 - perpy
Hi
I have a program where you drag and drop circles on a scene using JavaFX. I don't want circles to collide to each other so I added a collision algorithm to check that, which now works. What puzzles me is what I want to do afterwards.
If two circles overlap I want to make a vector between the middle of the two and transform the moved circle in the direction of the vector until they no longer overlap.
for (Stone stn:getCurrentScenario().getStones()) {
if (stn.circle == circle) continue;
double x1 = stn.circle.getTranslateX();
double y1 = stn.circle.getTranslateY();
double r1 = stn.circle.getRadius()+stn.circle.getStrokeWidth();
double x2 = circle.getTranslateX();
double y2 = circle.getTranslateY();
double r2 = circle.getRadius();
double distSq = (x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2);
double radSumSq = (r1 + r2) * (r1 + r2);
if (!(distSq != radSumSq && distSq > radSumSq)) {
System.out.println("Collision.");
// Transform "circle".
}
}
I ended up skipping the vector idea and went by angle instead. Going to keep the title if someone else runs into a similar issue:
double newX = circle.getTranslateX();
double newY = circle.getTranslateY();
for (Stone stn:getCurrentScenario().getStones()) {
if (stn.circle == circle) continue;
double x1 = stn.circle.getTranslateX();
double y1 = stn.circle.getTranslateY();
double r1 = stn.circle.getRadius()+stn.circle.getStrokeWidth();
double x2 = newX;
double y2 = newY;
double r2 = circle.getRadius();
double distSq = (x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2);
double radSumSq = (r1 + r2) * (r1 + r2);
if (!(distSq != radSumSq && distSq > radSumSq)) {
double angle = Math.atan2(x1-x2,y1-y2);
newX = x1 - Math.sin(angle) * (circle.getRadius() + circle.getStrokeWidth() + stn.circle.getRadius() + .01);
newY = y1 - Math.cos(angle) * (circle.getRadius() + circle.getStrokeWidth() + stn.circle.getRadius() + .01);
}
}
for (Stone stn:getCurrentScenario().getStones()) {
if (stn.circle == circle) continue;
double x1 = stn.circle.getTranslateX();
double y1 = stn.circle.getTranslateY();
double r1 = stn.circle.getRadius()+stn.circle.getStrokeWidth();
double x2 = newX;
double y2 = newY;
double r2 = circle.getRadius();
double distSq = (x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2);
double radSumSq = (r1 + r2) * (r1 + r2);
if (!(distSq != radSumSq && distSq > radSumSq)) {
newX = oldX;
newY = oldY;
break;
}
}
circle.setTranslateX(newX);
circle.setTranslateY(newY);
I made that piece of code just to make sure that it works as intended. Going to improve it now.
I am struggling to find a way to to get the nearest point of the coordinate x and coordinate Y to the right and below if they exist else print nothing.
public class CheckForIntersection {
double x1, x2, x3, x4, y1, y2, y3, y4, a, b, c, d, e, f, checkLinear, x, y;
CheckForIntersection(double x1, double y1, double x2, double y2, double x3, double y3, double x4, double y4) {
this.x1 = x1;
this.y1 = y1;
this.x2 = x2;
this.y2 = y2;
this.x3 = x3;
this.y3 = y3;
this.x4 = x4;
this.y4 = y4;
checkintersection();
}
public double getx() {
return x;
}
public double gety() {
return y;
}
public void checkintersection() {
a = y1 - y2;
b = -(x1 - x2);
c = y3 - y4;
d = -(x3 - x4);
e = (y1 - y2) * x1 - (x1 - x2) * y1;
f = (y3 - y4) * x3 - (x3 - x4) * y3;
checkLinear = (a * d) - (b * c);
x = ((e * d) - (b * f)) / checkLinear;
y = ((a * f) - (e * c)) / checkLinear;
System.out.println(a + " " + b + " " + c + " " + d + " " + e + " " + f);
checknearestNeighbour(x, y);
if (checkLinear == 0) {
System.out.println("the intersection is parallel");
} else {
System.out.println("X coordinate:" + x + " X coordinate:" + y);
}
}
}
the result for the follwoing args should be 2.88889, 1.1111.
Well I assume with "grid" you mean a structure like this:
x - x - x
| | |
x - o - o
| | |
o - x - x
Where x = node & o = no node
(assuming equal distances between all intersections)
To determine the coordinates of all notes you need a startpoint (coordinate origin).
This could be top left or bottom left of the grid, up to you to decide.
Then you could to loop line by line (one loop for the horizontal lines and one for the elements in each line), checking at each intersection if there is a node (this ofc requires a way to determine intersections). Since it is a grid (same distances) you can run a simple counter for your steps and to determine the coordinates for each intersection in one line. If you finde a node - store these information
You can now answer your questions while traversing the grid for efficiency, or do it in a seperate step after you gathered the information.
I am a first year computer programming student working on a project of Robots and Robot testing environment.
Although I'm new to Stackoverflow, I'm pretty aware that we are not supposed to help with assignments or homework.
I'm struggling to understand why such behavior is happening, so it would be really helpful just to understand why it's happening.
We are using Processing libraries to program in Java.
Our task is to create a robot testing environment and create three robots performing different movements.
The movement I'm trying to program is Patrol, which means just go around the edges of the screen.
The expected behavior is to go forward until it reaches a wall, turn left (90 degrees counter-clock wise), and go forward again.
This project is in conjunction with our Math class. That being said, we can't use methods like rotate(), translate(), pushMatrix() and popMatrix() to help rotating the forms (each robot is a triangle).
So, the steps I followed to rotate the triangles were:
1) translate its center point to the origin (0,0) and the vertices using the same translation;
2) rotate all points, where (x, y) become (y, -x);
3) translate back to correct position (inverse of the step 1 translation).
I set some boundaries if statements to put the triangle back to screen if, after rotation, anything went off screen.
My problem
After turning, the triangle is appearing in strange position, like teleporting.
I added a few lines so we can get each vertex's coordinates, the direction it's going and detect when direction is changed.
Code
There are two files: TestRobots, Robot.
Robot:
import processing.core.PApplet;
public class Robot{
int colour;
String name;
float width;
float height;
float x1;
float y1;
float x2;
float y2;
float x3;
float y3;
int direction;
int speed;
float centralPointX = width/2;
float centralPointY = height/2;
PApplet parent;
public Robot(PApplet parent, String name, int colour, float x1, float y1, float x2, float y2, float x3, float y3, int speed){
this.parent = parent;
this.name = name;
this.colour = colour;
this.x1 = x1;
this.y1 = y1;
this.x2 = x2;
this.y2 = y2;
this.x3 = x3;
this.y3 = y3;
this.speed = speed;
direction=4;
width = x2-x3;
if (width < 0){
width *= -1;
}
if (y2 > y3){
height = y2-y1;
}else{
height = y3-y1;
}
if (height < 0){
height *= -1;
}
if (y1<y2 && y1<y3){
direction=4;
}
}
public void drawRobot(){
parent.fill(colour);
parent.triangle(x1, y1, x2, y2, x3, y3);
parent.ellipseMode(parent.CENTER);
parent.ellipse(x1, y1, 3, 3);
}
public void moveForward(){
if(x1<parent.width || y1 <parent.height || x1 > 0 || y1 > 0){
switch (direction){
case 1:
x1 += speed;
x2 += speed;
x3 += speed;
break;
case 2:
y1 += speed;
y2 += speed;
y3 += speed;
break;
case 3:
x1 -= speed;
x2 -= speed;
x3 -= speed;
break;
case 4:
y1 -= speed;
y2 -= speed;
y3 -= speed;
break;
}
}
}
public void turnLeft(){
//Store original coordinates.
float tempX1 = x1;
float tempY1 = y1;
float tempX2 = x2;
float tempY2 = y2;
float tempX3 = x3;
float tempY3 = y3;
//Calculate translation of the central point of triangle to the origin.
float xTranslation = 0 - centralPointX;
float yTranslation = 0 - centralPointY;
//Translate all points by the translation calculated.
float translatedX1 = tempX1 + xTranslation;
float translatedY1 = tempY1 + yTranslation;
float translatedX2 = tempX2 + xTranslation;
float translatedY2 = tempY2 + yTranslation;
float translatedX3 = tempX3 + xTranslation;
float translatedY3 = tempY3 + yTranslation;
//Rotate all points 90 degrees counterclockwise, (x, y) --> (y, -x).
float rotatedX1 = translatedY1;
float rotatedY1 = -translatedX1;
float rotatedX2 = translatedY2;
float rotatedY2 = -translatedX2;
float rotatedX3 = translatedY3;
float rotatedY3 = -translatedX3;
//Translate all points back.
x1 = rotatedX1 - xTranslation;
y1 = rotatedY1 - yTranslation;
x2 = rotatedX2 - xTranslation;
y2 = rotatedY2 - yTranslation;
x3 = rotatedX3 - xTranslation;
y3 = rotatedY3 - yTranslation;
//Check which y and which x are the smallest, in order to correct any negative numbers.
float minX;
float minY;
if (y1<y2 && y1<y3){
minY = y1;
} else if (y2<y1 && y2<y3){
minY = y2;
} else {
minY = y3;
}
if (x1<x2 && x1<x3){
minX = x1;
} else if (x2<x1 && x2<x3){
minX = x2;
} else {
minX = x3;
}
//Check which y and which x are the biggest, in order to correct any out-of-screen draws.
float maxX;
float maxY;
if (y1>y2 && y1>y3){
maxY = y1;
} else if (y2>y1 && y2>y3){
maxY = y2;
} else {
maxY = y3;
}
if (x1>x2 && x1>x3){
maxX = x1;
} else if (x2>x1 && x2>x3){
maxX = x2;
} else {
maxX = x3;
}
//Correct position if any coordinate is negative.
if((minY-speed)<=minY){
float differenceY = -minY + 10;
y1 += differenceY;
y2 += differenceY;
y3 += differenceY;
}
if(x1<=(x1-speed)){
float differenceX = -minX + 10;
x1 += differenceX;
x2 += differenceX;
x3 += differenceX;
}
//Correct position if any coordinate is bigger than the screen size.
if((parent.height<=(maxY+speed))){
float differenceY = (-maxY+parent.height) + 10;
y1 -= differenceY;
y2 -= differenceY;
y3 -= differenceY;
}
if((x1+speed)>=parent.width){
float differenceX = (-maxX+parent.width) + 10;
x1 -= differenceX;
x2 -= differenceX;
x3 -= differenceX;
}
//Change direction variable and adjust it between 0 and 4.
direction -=1;
if (direction == 0){
direction = 4;
}
}
public void patrol(){
System.out.println("Direction is: "+ direction);
if(((y1-speed)<= 0)||((y1+speed)>= parent.height) || ((x1+speed)>=parent.width)||((x1-speed)<=0)){
turnLeft();
System.out.println("The NEW direction is: "+ direction);
}
moveForward();
}
}
TestRobots:
import processing.core.PApplet;
public class TestRobots extends PApplet{
Robot alice = new Robot(this, "Alice", 255, 257f, 389f, 309f, 450f, 209f, 450f, 3);
public static void main(String[] args){
PApplet.main("TestRobots");
}
public void settings(){
size(1000, 500);
}
public void setup(){
frameRate(30);
}
public void draw(){
background(255);
alice.patrol();
System.out.println("x1 = "+ alice.x1);
System.out.println("y1 = "+ alice.y1);
System.out.println("x2 = "+ alice.x2);
System.out.println("y2 = "+ alice.y2);
System.out.println("x3 = "+ alice.x3);
System.out.println("y3 = "+ alice.y3);
alice.drawRobot();
}
}
Here is a print of the generated output. I snipped the part where it changes direction:
Direction is: 2
x1 = 62.0
y1 = 497.0
x2 = 10.0
y2 = 436.0
x3 = 110.0
y3 = 436.0
The NEW direction is: 1
x1 = 500.0
y1 = 58.0
x2 = 439.0
y2 = 110.0
x3 = 439.0
y3 = 10.0
Same strange behavior here:
Direction is: 4
x1 = 257.0
y1 = 2.0
x2 = 309.0
y2 = 63.0
x3 = 209.0
y3 = 63.0
The NEW direction is: 3
x1 = -1.0
y1 = 62.0
x2 = 60.0
y2 = 10.0
x3 = 60.0
y3 = 110.0
The NEW direction is: 2
x1 = 62.0
y1 = 74.0
x2 = 10.0
y2 = 13.0
x3 = 110.0
y3 = 13.0
Thank you very much for reading until here and sorry in advance if I wasn't clear enough. It's my first question!
Gustavo
I think your problem relates to the variables centralPointX and centralPointY. Look at this code you wrote:
//Calculate translation of the central point of triangle to the origin.
float xTranslation = 0 - centralPointX;
float yTranslation = 0 - centralPointY;
//Translate all points by the translation calculated.
float translatedX1 = tempX1 + xTranslation;
float translatedY1 = tempY1 + yTranslation;
float translatedX2 = tempX2 + xTranslation;
float translatedY2 = tempY2 + yTranslation;
float translatedX3 = tempX3 + xTranslation;
float translatedY3 = tempY3 + yTranslation;
It seems from this that you think centralPointX and centralPointY indicate the center of the triangle... However, look at where they are defined:
float centralPointX = width/2;
float centralPointY = height/2;
So they don't actually represent the center xy co-ordinates. What you need to do is fix this part:
//Calculate translation of the central point of triangle to the origin.
float xTranslation = 0 - centralPointX;
float yTranslation = 0 - centralPointY;
So that it actually does what the comment says it should do, i.e., calculates the x and y co-ordinates of the center of your triangle.
I won't implement this for you, because as you said, it is homework. However, I think this should definitely point you in the right direction. Also, keep up the good work. I wish every first question was as well thought out as this.
I need to cover some polygon with rectangles here's an example :
The black figure in a black square is the polygon that i need to cover with those green rectangles but i need to do it more efficiently that just make a net like i did. Because as you can see there can be place more green rectangles if i moved them.
Rectangles inside are fixed size(just not as big as polygon it self), one for all like in the picture, they can be places vertically and horizontally, i want to fill the polygon as much as it can fit it inside of it, this polygon is just for example, there can be different polygons with holes in them for example that black small square is a hole.
module = rectangle
private void coverWithModules(Graphics g, int[] xpoints, int[] ypoints) {
Polygon module;
int x1, x2, x3, x4, y1, y2, y3, y4;
int moduleRowNumber = 0;
int totalRows = (getMax(ypoints) / moduleHeight);
while (moduleRowNumber < totalRows) {
// first module
x1 = getMin(xpoints);
y1 = getMin(ypoints) + distance * moduleRowNumber + moduleHeight
* moduleRowNumber;
x2 = x1 + moduleWidth;
y2 = y1;
x3 = x1 + moduleWidth;
y3 = y1 + moduleHeight;
x4 = x1;
y4 = y1 + moduleHeight;
int[] x = { x1, x2, x3, x4 };
int[] y = { y1, y2, y3, y4 };
module = new Polygon();
// check if point are inside the polygon
checkModulePlacement(g, x, y, module);
// placing modules in a row
while (x1 < getMax(xpoints)) {
x1 = x2 + distance;
y1 = getMin(ypoints) + distance * moduleRowNumber
+ moduleHeight * moduleRowNumber;
x2 = x1 + moduleWidth;
y2 = y1;
x3 = x1 + moduleWidth;
y3 = y1 + moduleHeight;
x4 = x1;
y4 = y1 + moduleHeight;
int[] xx = { x1, x2, x3, x4 };
int[] yy = { y1, y2, y3, y4 };
module = new Polygon();
checkModulePlacement(g, xx, yy, module);
}
moduleRowNumber++;
}
}
private void checkModulePlacement(Graphics g, int[] x, int[] y, Polygon module) {
boolean pointInside = true;
boolean pointOnObstraction = true;
for (int i = 0; i < x.length; i++) {
if (pointInside) {
pointInside = roof.contains(x[i], y[i]);
}
module.addPoint(x[i], y[i]);
}
pointOnObstraction = checkForObstractions(module);
g.setColor(Color.GREEN);
if (pointInside == true && pointOnObstraction == false ) {
g.drawPolygon(module);
}
}
I was looking for something and i have found Something like this maybe there is more stuff like this ?
I don't know where to search for such info. What should i look up to get what i need ? Maybe there is some kind of library for this kind of things ?