#Problem
Hey I wondered how we can find the intersection between a point with a vector direction, assuming that the point is in the circle.
In Other words, how can I find where the particle will hit the circle circumference when I know the following: Circle position, radius, Particle Position and direction (velocity).
#Implementation
I am currently creating a flight radar, all flights are stored in a Queue and I need to sort the queue based on the time untill the flight leaves the cirlce (Radar Radius)
So I need to return a Point, thus I can just get the distance and calculate the time based on distance and velocity.
At first subtract center cordinates to simplify calculations (now circle center is coordinate origin)
x11 = x1 - x0
y11 = y1 - y0
Point position against time is
x = x11 + vx * t
y = y11 + vy * t
where vx, vy are components of velocity
Point is at circumference when
x^2 + y^2 = R^2
so
(x11 + vx * t)^2 + (y11 + vy * t)^2 = R^2
(vx^2+vy^2)*t^2 + (2*vx*x11+2*vy*y11)*t + (x11^2+y11^2-R^2) = 0
This is quadratic equation for unknown t. Solve it, find roots - none for outside moving, one for single touch case, two roots for regular intersection - larger one is needed time of intersection t_int
Substitute t into point position equations and get coordinates:
x_int = x1 + t_int * vx
y_int = y1 + t_int * vy
I have a circle formed with three given points. How can i know whether another given point is inside the circle formed by previous three points. Is it determinant i need to calculate? Then what are the cases i need to handle?
It seems you want to know an answer without calculation of circle parameters (radius, center). So you can use the equation for the circumcircle of the triangle (formula 2), substitute (x,y) with given point coordinates and calculate determinant (Det) sign.
Important: points x1, x2, x3 should be in counterclockwise order. Otherwise - change the sign
| x^2+y^2 x y 1 |
| x1^2+y1^2 x1 y1 1 | = Det
| x2^2+y2^2 x2 y2 1 |
| x3^2+y3^2 x3 y3 1 |
To take mutual orientation of points into account:
Det = Det * ((x1-x3)*(y2-y3)-(y1-y3)*(x2-x3))
If Det = 0 then all four points are concyclic (given point lies at the circle border)
if Det < 0 then point is inside
otherwise it is outside the circle
But I suspect that this method may require more mathematical operations then calculation of radius and center point and estimating (x-x0)^2+(y-y0)^2 <= R^2
Addition:
It seems that general approach to calculate 4th order determinant is not very effective here: instead use minors of 4th column (Laplace formula here) or one of "alternate forms" from WolphramAlpha output
If the radii of the inner circle is less then the radii of the outer circle, this means the inner circle is inside the outer circle (in case if you need to test if another circle is inside the outer one).
Here is the formula for the circle:
x = (Math.cos(angle * Math.PI / 180) * radius) + this.centerX;
y = (Math.sin(angle * Math.PI / 180) * radius) + this.centerY; // in radians
You can apply this formula to test if a point is inside of a circle.
To test if two circles intersects you have to see if, the distance between their centers is between the sum and the difference of their radii.
I would like to write a function that takes a 3d triangle (as 3 points (vector3ds)) and returns a 2d triangle (as 3 points (vector2ds)):
When given a 3d triangle, it should return the 2 dimensional coordinates of its points as they lie on its plane. (By 'its plane' I mean the plane that all three points lie on).
I can think a long winded way todo this:
rotate the triangle until its normal is equal to +z (0,0,1), then construct a triangle from the (x, y) coords of each point.
I cant help but think there must be an easier way to achieve the same thing.
If posting code examples please try not to use Greek alphabet. Some pseudo code in a C/java style language would be ideal.
From your comments I infer that you can choose the coordinate system of the plane in an arbitrary way, as long as the Euclidean metric of this coordinate system is the same as the metric induced by the Euclidean metric of your three-dimensional coordinate system. (That is, Euclidean distances will stay the same.)
One possible solution:
x0' = 0
y0' = 0
x1' = sqrt((x1 - x0)^2 + (y1 - y0)^2 + (z1 - z0)^2)
y1' = 0
x2' = ((x1 - x0) * (x2 - x0) +
(y1 - y0) * (y2 - y0) +
(z1 - z0) * (z2 - z0)) / x1'
y2' = sqrt((x2 - x0)^2 + (y2 - y0)^2 + (z2 - z0)^2 - x2'^2)
There is no singular answer to this problem.
The plane in which the triangle sits has no defined origin, and no defined orientation.
The best you can do is define one of the vertices as the origin, and one of the edges laying along the X axis:
v1 = (0, 0)
You will need to calculate vectors A (i.e. v2 - v1) and B (i.e. v3 - v1).
Vertex 2 will then be at:
v2 = (|A|, 0)
The position of vertex 3 can be worked out by using the vector cross product rule, e.g.:
A x B = |A| * |B| sin(theta)
So, work out A x B and from that you can work out the sine of the angle theta between A and B:
sin(theta) = | A x B | / (|A| * |B|)
Vertex 3 is then at coordinates:
v3 = |B| (cos(theta), sin(theta))
You can take advantage of cos(theta) = sqrt(1 - sin(theta) ^ 2) to avoid any inverse trig operations.
You should also see that |B| sin(theta) is just | A x B | / | A |
Hey there guys, I'm learning processing.js, and I've come across a mathematical problem, which I can't seem to solve with my limited geometry and trigonometry knowledge or by help of Wikipedia.
I need to draw a rectangle. To draw this rectangle, I need to know the coordinate points of each corner. All I know is x and y for the midpoints of the top and bottom of the box, and the length of all four sides.
There is no guarantee on the orientation of the box.
Any help? This seems like it should be easy, but it is really stumping me.
If this quadrilateral is a rectangle (all four angles are 90 degrees), then it can be solved. (if it could be any quadrilateral, then it is not solvable)
if the points are (x1,y1), and (x2, y2), and if the two points are not perfectly vertical (x1 = x2) or horizontal (y1 = y2), then the slope of one edge of the rectangle is
m1 = (y2-y1) / (x2-x1)
and the slope of the other edge is:
m2 = - 1 / m1
If you know the lengths of the sides, and the midpoints of two opposite sides, then the corrner points are easily determined by adding dx, dy to the midpoints: (if L is length of the sides that the midpoints are on)
dx = Sqrt( L^2 / (1 + m2^2) ) / 2
and
dy = m2 * dx
NOTE: if the points are vertically or horizontally aligned, this technique will not work, although the obvious solution for those degenerative cases is much simpler.
If you know your quadrilateral is a rectangle, then you can use some simple vector maths to find the coordinates of the corners. The knowns are:
(x1,y1) - the coordinate of the midpoint on the top line
(x2,y2) - the coordinate of the midpoint on the bottom line
l1 - the length of the top and bottom lines
l2 - the length of the other two lines
First, we find the vector between the two known points. This vector is parallel to the side lines:
(vx, vy) = (x2 - x1, y2 - y1)
We need to normalize this vector (i.e. make it length 1) so we can use it later as a basis to find our coordinates.
vlen = sqrt(vx*vx + vy*vy)
(v1x, v1y) = (vx / vlen, vy / vlen)
Next, we rotate this vector anticlockwise by 90 degrees. The rotated vector will be parallel to the top and bottom lines. 90 degree rotation turns out to just be swapping the coordinates and negating one of them. You can see this just by trying it out on paper. Or take at look at the equations for 2D rotations and substitute in 90 degrees.
(u1x, u1y) = (-v1y, v1x)
Now we have enough information to find the 'top-left' corner. We simply start at our point (x1, y1) and move back along that side by half the side length:
(p1x, p1y) = (x1 - u1x * l1 / 2, y1 - u1y * l1 / 2)
From here we can find the remaining points just by adding the appropriate multiples of our basis vectors. When implementing this you can obviously speed it up by only calculating each unique multiplication a single time:
(p2x, p2y) = (p1x + u1x * l1, p1y + u1y * l1)
(p3x, p3y) = (p1x + v1x * l2, p1y + v1y * l2)
(p4x, p4y) = (p3x + u1x * l1, p3y + u1y * l1)
function getFirstPoint(x1,y1,x2,y2,l1,l2)
distanceV = {x2 - x1, y2 - y1}
vlen = math.sqrt(distanceV[1]^2 + distanceV[2]^2)
normalized = {distanceV[1] / vlen, distanceV[2] / vlen}
rotated = {-normalized[2], normalized[1]}
p1 = {x1 - rotated[1] * l1 / 2, y1 - rotated[2] * l1 / 2}
p2 = {p1[1] + rotated[1] * l1, p1[2] + rotated[2] * l1}
p3 = {p1[1] + normalized[1] * l2, p1[2] + normalized[2] * l2}
p4 = {p3[1] + rotated[1] * l1, p3[2] + rotated[2] * l1}
points = { p1 , p2 , p3 , p4}
return p1
end
It's definitely a rectangle? Then you know the orientation of the short sides (they're parallel to the line between your points), and hence the orientation of the long sides.
You know the orientation and length of the long sides, and you know their midpoints, so it's straightforward to find the corners from there.
Implementation is left as an exercise to the reader.
This means that there will be two lines parallel to the line between the two points you have. Get the corners by translating the line you have 1/2 the length of the top side in each direction perpendicular to the line you have.
If you know the midpoint for the top, and the length of the top, then you know that the y will stay the same for both top corners, and the x will be the midpoint plus/minus the width of the rectangle. This will also be true for the bottom.
Once you have the four corners, there is no need to worry about the side lengths, as their points are the same as those used for the top and bottom.
midpoint
x,10 10,10 x,10
*--------------------------------------------*
width = 30
mx = midpoint x.
top left corner = (w/2) - mx or 15 - 10
top left corner coords = -5,10
mx = midpoint x.
top right corner = (w/2) + mx or 15 + 10
top left corner coords = 25,10
There's a difference between a "quadrilateral" and a "rectangle".
If you have the midpoint of the top and bottom, and the sides lengths, the rest is simple.
Given:
(x1, y1) -- (top_middle_x, top_middle_y) -- (x2, y1)
(x1, y2) -- (btm_middle_x, btm_middle_y) -- (x2, y2)
and top/bottom length along with right/left length.
x1 = top_middle_x - top/bottom_length / 2;
x2 = x1 + top/bottom_length;
y1 = top_middle_y
y2 = bottom_middle_y
Obviously, that's the simplest case and assuming that the line of (tmx, tmy) (bmx, bmy) is solely along the Y axis.
We'll call that line the "mid line".
The next trick is to take the mid line, and calculate it's rotational offset off the Y axis.
Now, my trig is super rusty.
dx = tmx - bmx, dy = tmy - bmy.
So, the tangent of the angle is dy / dx. The arctangent(dy / dx) is the angle of the line.
From that you can get your orientation.
(mind, there's some games with quadrants, and signs, and stuff to get this right -- but this is the gist of it.)
Once you have the orientation, you can "rotate" the line back to the Y axis. Look up 2D graphics for the math, it's straight forward.
That gets you your normal orientation. Then calculate the rectangles points, in this new normal form, and finally, rotate them back.
Viola. Rectangle.
Other things you can do is "rotate" a line that's half the length of the "top" line to where it's 90 deg of the mid line. So, say you have a mid line that's 45 degrees. You would start this line at tmx, tmy, and rotate this line 135 degrees (90 + 45). That point would be your "top left" corner. Rotate it -45 (45 - 90) to get the "top right" point. Then do something similar with the lower points.
Calculate the angle of the line joining the two midpoints using an arc-tangent function applied to the vector you get between them.
Subtract 90 degrees from that angle to get the direction of the top edge
Starting from the top-center point, move relative (1/2 top width x sin(angle), 1/2 top width x cos(angle)) - that gets the top right corner point.
Continue around the rectangle using the sin and cos of the angles and widths as appropriate
As a test: Check you made it back to the starting point
/* rcx = center x rectangle, rcy = center y rectangle, rw = width rectangle, rh = height rectangle, rr = rotation in radian from the rectangle (around it's center point) */
function toRectObjectFromCenter(rcx, rcy, rw, rh, rr){
var a = {
x: rcx+(Math.sin((rr-degToRad(90))+Math.asin(rh/(Math.sqrt(rh*rh+rw*rw)))) * (Math.sqrt(rh*rh+rw*rw)/2)),
y: rcy-(Math.cos((rr-degToRad(90))+Math.asin(rh/(Math.sqrt(rh*rh+rw*rw)))) * (Math.sqrt(rh*rh+rw*rw)/2))
};
var b = {
x: a.x+Math.cos(rr)*rw,
y: a.y+Math.sin(rr)*rw
};
var c = {
x: b.x+Math.cos(degToRad(radToDeg(rr)+90))*rh,
y: b.y+Math.sin(degToRad(radToDeg(rr)+90))*rh
};
var d = {
x: a.x+Math.cos(degToRad(radToDeg(rr)+90))*rh,
y: a.y+Math.sin(degToRad(radToDeg(rr)+90))*rh
};
return {a:a,b:b,c:c,d:d};
}