Calculation of a perspective transformation matrix - math
Given a point in 3D space, how can I calculate a matrix in homogeneous coordinates which will project that point into the plane z == d, where the origin is the centre of projection.
OK, let's try to sort this out, expanding on Emmanuel's answer.
Assuming that your view vector is directly along the Z axis, all dimensions must be scaled by the ratio of the view plane distance d to the original z coordinate. That ratio is trivially d / z, giving:
x' = x * (d / z)
y' = y * (d / z)
z' = z * (d / z) ( = d)
In homogenous coordinates, it's usual to start with P = [x, y, z, w] where w == 1 and the transformation is done thus:
P' = M * P
The result will have w != 1, and to get the real 3D coordinates we normalise the homogenous vector by dividing the whole thing by its w component.
So, all we need is a matrix that given [x, y, z, 1] gives us [x * d, y * d, z * d, z], i.e.
| x' | = | d 0 0 0 | * | x |
| y' | = | 0 d 0 0 | * | y |
| z' | = | 0 0 d 0 | * | z |
| w' | = | 0 0 1 0 | * | 1 |
which once normalised (by dividing by w' == z) gives you:
[ x * d / z, y * d / z, d, 1 ]
per the first set of equations above
I guess the projection you mean, as Beta says, consists in the intersection between:
the line formed by the origin O(0, 0, 0) and the point P(a, b, c) to be transformed
and the plane z=d
If I'm right, then let's have a look at the equation of this line, given by the vectorial product OP ^ OM = 0 (let's remind that the equation of a line between 2 given points A and B is given by AB ^ AM = 0, with M(x, y, z); this is a vectorial product, so all are vectors: 0 represents the null vector, AB is the vector AB, etc):
bz - cy = 0
cx - az = 0
cz - bx = 0
With z = d, we then have only 2 linearily independent equations:
bd = cy
cx = ad
So this projection converts a point P(a, b, c) into a point P'(ad/c, bd/c, d). For homogeneous coordinates that gives:
P'(ad/c, bd/c, d) = P'(ad/c, bd/c, cd/c)
= P'(ad/c: bd/c: cd/c: 1)
= P'(a: b: c: d/c)
EDIT : the matrix I 1st found was:
1, 0, 0, 0
0, 1, 0, 0
A = 0, 0, 1, 0
0, 0, 0, d/c
but it uses c which is the a coordinate of the point P !! This is nonsense, I couldn't find an expression of A that does not use these coordinates. I may not be familiar enough with homogeneous coordinates.
the homogeneous transformation matrix is (Euler roll-pitch-yaw):
|r1 r2 r3 dx|
|r4 r5 r6 dy|
|r7 r8 r9 dz|
|px py pz sf|
r1-9 are the elements of the combined rotation matrix: Rx*Ry*Rz (work it out)
dx dy and dz are displacement vector (d) elements
px py and pz are the perspective vector (p) elements
sf is the scaling factor
from here on, if you use the inverse of this, you get your projection as a perspective in any arbitrary plane by feeding rotations of your target plane, as well as it's position of origin wrt the reference one in (keep perspective vector at 0 0 0 and sf=1 for pure kinematics), you get T->T* = T1. Get T1^-1 (for kinematics, this is simply R' (transposed,), horizontal concatenated by -R'*d, then vertical concatenated simply by 0 0 0 1).
can have multiple planes e.g. a,b,c as a chain, in which case T1 = Ta*Tb*Tc*...
then, v(new) = (T1^-1)*v(old), job done.
Related
Determining if a point lies between two bearings from a central point
I am trying to determine if a point lies between two bearings from a central point. The diagram below attempts to explain things I have a central point labelled A I have two points (labelled B & C) which provide the boundaries of the search area (based on bearing only - there is no distance element required). I'm trying to determine if point D is within the sector formed by A-B and A-C I've calculated the bearings from A to each B & C In my real scenario the angle created between the bearings can be anything from 0 to 360. There are some similar questions & answers however in my case I'm not interested in restricting my search to the radius of a circle. And there seems to be some implementation issues around angle size and the location of the points in terms of clockwise vs counter-clockwise It seems so simple in theory but my maths is clearly not up to scratch :( Any advice or pseudo-code would be greatly appreciated.
Here would be my approach: calculate first bearing angle X calculate second bearing angle Y calculate angle Z towards point D if X < Z < Y, return true; otherwise, return false In your example it looks like you'd calculate Z ~ 90deg and find 45 < 90 < 135 (is your picture wrong? is says 315). You can use something like the "atan2" function in whatever language you're using. This is an extension of the basic arctangent function which takes not just the slope but both the rise and run and instead of returning an angle from only a 180-degree range, it returns the true angle from a 360-degree range. So Z = atan2(Dy, Dx) Should give you the angle (possibly in radians; be careful) that you can compare to your bearings to tell whether you're inside the search. Note that the order of X and Y matter since the order is what defines which of the two sections is in the search area (X to Y gives ~90 deg in your picture, but Y to X gives ~270 deg).
You can calculate and compare the cross products of the vectors (AB X BD), and (AC X CD).
if (AB X BD) > 0, you have a counter clock wise turn
if (AC X CD) < 0, you have a clock wise turn
If both above tests are true, then the point D is in the sector BAC
This allows you to completely avoid using expensive trig functions.
class Point:
"""small class for point arithmetic convenience
"""
def __init__(self, x: float = 0, y: float = 0) -> None:
self.x = x
self.y = y
def __sub__(self, other: 'Point') -> 'Vector':
return Vector(self.x - other.x, self.y - other.y)
class Vector:
"""small class for vector arithmetic convenience
"""
def __init__(self, x: float = 0, y: float = 0) -> None:
self.x = x
self.y = y
def cross(self, other: 'Vector') -> float:
return (self.x * other.y) - (self.y * other.x)
def in_sector(A: Point, B: Point, C: Point, D: Point) -> bool:
# construct vectors:
ab = B - A
bd = D - B
ac = C - A
cd = D - C
print(f'ab x bc = {ab.cross(bd)}, ac x cd = {ac.cross(cd)}')
return ab.cross(bd) > 0 and ac.cross(cd) < 0
if __name__ == '__main__':
A = Point(0, 0)
B = Point(1, 1)
C = Point(-1, 1)
D = Point(0, 1)
print(f'D in sector ABC: {in_sector(A, B, C, D)}', end='\n\n')
print(f'D in sector ACB: {in_sector(A, C, B, D)}') # inverting the sector definition so D is now outside
Output:
ab x bc = 1, ac x cd = -1
D in sector ABC: True
ab x bc = -1, ac x cd = 1
D in sector ACB: False
Quaternion to matrix rotation only one axis
I have a quaternion that contains the rotation of the three axes (x, y, z) at the same time. I want to convert this quaternion to a rotation matrix but only the rotation on the Y axis of the quaternion or of any of the other axes, without all three at the same time.
A possible route: Transform unit vectors X=(1,0,0) and Z=(0,0,1) by the quaternion Call these rotated vectors (x0,x1,x2) and (z0,z1,z2) If the rotation would have been purely around Y, we would have: (x0,x1,x2) = (cos(theta), 0, sin(theta)) (z0,z1,z2) = (-sin(theta), 0, cos(theta)) not used is (y0,y1,y2) = (0, 1, 0) so, calculate c = (x0+z2) / 2 and s = (x2-z0) / 2 then normalize to get c2 + s2 equal to 1 norm = sqrt(c * c + s * s) if norm != 0: c = c / norm s = s / norm (if the norm would be zero, there is not much we can do) the angle would be atan2(c, s) the rotation matrix would be [[c,0,-s],[0,1,0],[s,0,c]]
Finding the coordinates of a point contained by a trapezoid programmatically
If I have a trapezoid defined by four points (x1, y1), (x2, y2), (x3, y3), (x4, y4) (chosen as (255, 0), (255, 235), (200, 35), and (200, 235) for the sake of the example), and I divide it arbitrarily in n by m sections like so (pardon the crude drawing): How could I find the coordinates of (x, y)? I've tried fooling around with the slopes of the lines, but my math skills are too rusty to figure it out. Any ideas?
For the specific case as per your example it's quite straight forward.
First, the x location is easy. Since the verticals will always be parallel to the y axis, x is simply x width divided by the number of sections:
x = x1+((x2-x1)/a*xa)
where:
x = result coordinate
x1,x2 = edges of the trapezoid
a = number of sections
xa = x coordinate in term of sections
note: I chose a to avoid confusion with the symbol for slope: m.
For y it's a bit more complicated. We first need to find the coordinate that sits on the top and bottom lines of the trapezoid. We use the standard line equation for this:
y = mx+c
Finding m is simple. It's just Dy/Dx:
m = (y2-y1)/(x2-x1)
To get c we just substitute x, y and m into the formula:
c = y-mx
Once we get that, substitute the value of x found earlier into the formula to get the y coordinate. Do this twice to get the points on the top and bottom lines:
1 A 2
x------------x--------------x
| | |
| xC |
| | |
x------------x--------------x
3 B 4
All together (pseudocode):
coordinateFromSection (x1 y1 x2 y2 x3 y3 x4 y4 gridX gridY sectionX sectionY) {
xC = x1+((x2-x1)/gridX*sectionX)
// top line:
m = (y2-y1)/(x2-x1)
c = y1-(m*x1)
yA = m*xC + c
// bottom line:
m = (y4-y3)/(x4-x3)
c = y3-(m*x3)
yB = m*xC + c
// Find yC by dividing line AB by gridY
yC = yA+((yB-yA)/gridY*sectionY)
return (xC yC)
}
All the calculations above assume that (0,0) is the top left of the screen.
Determine which side of a line a point lies [duplicate]
I have a set of points. I want to separate them into 2 distinct sets. To do this, I choose two points (a and b) and draw an imaginary line between them. Now I want to have all points that are left from this line in one set and those that are right from this line in the other set. How can I tell for any given point z whether it is in the left or in the right set? I tried to calculate the angle between a-z-b – angles smaller than 180 are on the right hand side, greater than 180 on the left hand side – but because of the definition of ArcCos, the calculated angles are always smaller than 180°. Is there a formula to calculate angles greater than 180° (or any other formula to chose right or left side)?
Try this code which makes use of a cross product:
public bool isLeft(Point a, Point b, Point c){
return ((b.X - a.X)*(c.Y - a.Y) - (b.Y - a.Y)*(c.X - a.X)) > 0;
}
Where a = line point 1; b = line point 2; c = point to check against.
If the formula is equal to 0, the points are colinear.
If the line is horizontal, then this returns true if the point is above the line.
Use the sign of the determinant of vectors (AB,AM), where M(X,Y) is the query point: position = sign((Bx - Ax) * (Y - Ay) - (By - Ay) * (X - Ax)) It is 0 on the line, and +1 on one side, -1 on the other side.
You look at the sign of the determinant of | x2-x1 x3-x1 | | y2-y1 y3-y1 | It will be positive for points on one side, and negative on the other (and zero for points on the line itself).
The vector (y1 - y2, x2 - x1) is perpendicular to the line, and always pointing right (or always pointing left, if you plane orientation is different from mine). You can then compute the dot product of that vector and (x3 - x1, y3 - y1) to determine if the point lies on the same side of the line as the perpendicular vector (dot product > 0) or not.
Using the equation of the line ab, get the x-coordinate on the line at the same y-coordinate as the point to be sorted. If point's x > line's x, the point is to the right of the line. If point's x < line's x, the point is to the left of the line. If point's x == line's x, the point is on the line.
I implemented this in java and ran a unit test (source below). None of the above solutions work. This code passes the unit test. If anyone finds a unit test that does not pass, please let me know.
Code: NOTE: nearlyEqual(double,double) returns true if the two numbers are very close.
/*
* #return integer code for which side of the line ab c is on. 1 means
* left turn, -1 means right turn. Returns
* 0 if all three are on a line
*/
public static int findSide(
double ax, double ay,
double bx, double by,
double cx, double cy) {
if (nearlyEqual(bx-ax,0)) { // vertical line
if (cx < bx) {
return by > ay ? 1 : -1;
}
if (cx > bx) {
return by > ay ? -1 : 1;
}
return 0;
}
if (nearlyEqual(by-ay,0)) { // horizontal line
if (cy < by) {
return bx > ax ? -1 : 1;
}
if (cy > by) {
return bx > ax ? 1 : -1;
}
return 0;
}
double slope = (by - ay) / (bx - ax);
double yIntercept = ay - ax * slope;
double cSolution = (slope*cx) + yIntercept;
if (slope != 0) {
if (cy > cSolution) {
return bx > ax ? 1 : -1;
}
if (cy < cSolution) {
return bx > ax ? -1 : 1;
}
return 0;
}
return 0;
}
Here's the unit test:
#Test public void testFindSide() {
assertTrue("1", 1 == Utility.findSide(1, 0, 0, 0, -1, -1));
assertTrue("1.1", 1 == Utility.findSide(25, 0, 0, 0, -1, -14));
assertTrue("1.2", 1 == Utility.findSide(25, 20, 0, 20, -1, 6));
assertTrue("1.3", 1 == Utility.findSide(24, 20, -1, 20, -2, 6));
assertTrue("-1", -1 == Utility.findSide(1, 0, 0, 0, 1, 1));
assertTrue("-1.1", -1 == Utility.findSide(12, 0, 0, 0, 2, 1));
assertTrue("-1.2", -1 == Utility.findSide(-25, 0, 0, 0, -1, -14));
assertTrue("-1.3", -1 == Utility.findSide(1, 0.5, 0, 0, 1, 1));
assertTrue("2.1", -1 == Utility.findSide(0,5, 1,10, 10,20));
assertTrue("2.2", 1 == Utility.findSide(0,9.1, 1,10, 10,20));
assertTrue("2.3", -1 == Utility.findSide(0,5, 1,10, 20,10));
assertTrue("2.4", -1 == Utility.findSide(0,9.1, 1,10, 20,10));
assertTrue("vertical 1", 1 == Utility.findSide(1,1, 1,10, 0,0));
assertTrue("vertical 2", -1 == Utility.findSide(1,10, 1,1, 0,0));
assertTrue("vertical 3", -1 == Utility.findSide(1,1, 1,10, 5,0));
assertTrue("vertical 3", 1 == Utility.findSide(1,10, 1,1, 5,0));
assertTrue("horizontal 1", 1 == Utility.findSide(1,-1, 10,-1, 0,0));
assertTrue("horizontal 2", -1 == Utility.findSide(10,-1, 1,-1, 0,0));
assertTrue("horizontal 3", -1 == Utility.findSide(1,-1, 10,-1, 0,-9));
assertTrue("horizontal 4", 1 == Utility.findSide(10,-1, 1,-1, 0,-9));
assertTrue("positive slope 1", 1 == Utility.findSide(0,0, 10,10, 1,2));
assertTrue("positive slope 2", -1 == Utility.findSide(10,10, 0,0, 1,2));
assertTrue("positive slope 3", -1 == Utility.findSide(0,0, 10,10, 1,0));
assertTrue("positive slope 4", 1 == Utility.findSide(10,10, 0,0, 1,0));
assertTrue("negative slope 1", -1 == Utility.findSide(0,0, -10,10, 1,2));
assertTrue("negative slope 2", -1 == Utility.findSide(0,0, -10,10, 1,2));
assertTrue("negative slope 3", 1 == Utility.findSide(0,0, -10,10, -1,-2));
assertTrue("negative slope 4", -1 == Utility.findSide(-10,10, 0,0, -1,-2));
assertTrue("0", 0 == Utility.findSide(1, 0, 0, 0, -1, 0));
assertTrue("1", 0 == Utility.findSide(0,0, 0, 0, 0, 0));
assertTrue("2", 0 == Utility.findSide(0,0, 0,1, 0,2));
assertTrue("3", 0 == Utility.findSide(0,0, 2,0, 1,0));
assertTrue("4", 0 == Utility.findSide(1, -2, 0, 0, -1, 2));
}
First check if you have a vertical line: if (x2-x1) == 0 if x3 < x2 it's on the left if x3 > x2 it's on the right else it's on the line Then, calculate the slope: m = (y2-y1)/(x2-x1) Then, create an equation of the line using point slope form: y - y1 = m*(x-x1) + y1. For the sake of my explanation, simplify it to slope-intercept form (not necessary in your algorithm): y = mx+b. Now plug in (x3, y3) for x and y. Here is some pseudocode detailing what should happen: if m > 0 if y3 > m*x3 + b it's on the left else if y3 < m*x3 + b it's on the right else it's on the line else if m < 0 if y3 < m*x3 + b it's on the left if y3 > m*x3+b it's on the right else it's on the line else horizontal line; up to you what you do
I wanted to provide with a solution inspired by physics. Imagine a force applied along the line and you are measuring the torque of the force about the point. If the torque is positive (counterclockwise) then the point is to the "left" of the line, but if the torque is negative the point is the "right" of the line. So if the force vector equals the span of the two points defining the line fx = x_2 - x_1 fy = y_2 - y_1 you test for the side of a point (px,py) based on the sign of the following test var torque = fx*(py-y_1)-fy*(px-x_1) if torque>0 then "point on left side" else if torque <0 then "point on right side" else "point on line" end if
Assuming the points are (Ax,Ay) (Bx,By) and (Cx,Cy), you need to compute: (Bx - Ax) * (Cy - Ay) - (By - Ay) * (Cx - Ax) This will equal zero if the point C is on the line formed by points A and B, and will have a different sign depending on the side. Which side this is depends on the orientation of your (x,y) coordinates, but you can plug test values for A,B and C into this formula to determine whether negative values are to the left or to the right.
basically, I think that there is a solution which is much easier and straight forward, for any given polygon, lets say consist of four vertices(p1,p2,p3,p4), find the two extreme opposite vertices in the polygon, in another words, find the for example the most top left vertex (lets say p1) and the opposite vertex which is located at most bottom right (lets say ). Hence, given your testing point C(x,y), now you have to make double check between C and p1 and C and p4: if cx > p1x AND cy > p1y ==> means that C is lower and to right of p1 next if cx < p2x AND cy < p2y ==> means that C is upper and to left of p4 conclusion, C is inside the rectangle. Thanks :)
#AVB's answer in ruby det = Matrix[ [(x2 - x1), (x3 - x1)], [(y2 - y1), (y3 - y1)] ].determinant If det is positive its above, if negative its below. If 0, its on the line.
Here's a version, again using the cross product logic, written in Clojure. (defn is-left? [line point] (let [[[x1 y1] [x2 y2]] (sort line) [x-pt y-pt] point] (> (* (- x2 x1) (- y-pt y1)) (* (- y2 y1) (- x-pt x1))))) Example usage: (is-left? [[-3 -1] [3 1]] [0 10]) true Which is to say that the point (0, 10) is to the left of the line determined by (-3, -1) and (3, 1). NOTE: This implementation solves a problem that none of the others (so far) does! Order matters when giving the points that determine the line. I.e., it's a "directed line", in a certain sense. So with the above code, this invocation also produces the result of true: (is-left? [[3 1] [-3 -1]] [0 10]) true That's because of this snippet of code: (sort line) Finally, as with the other cross product based solutions, this solution returns a boolean, and does not give a third result for collinearity. But it will give a result that makes sense, e.g.: (is-left? [[1 1] [3 1]] [10 1]) false
Issues with the existing solution: While I found Eric Bainville's answer to be correct, I found it entirely inadequate to comprehend: How can two vectors have a determinant? I thought that applied to matrices? What is sign? How do I convert two vectors into a matrix? position = sign((Bx - Ax) * (Y - Ay) - (By - Ay) * (X - Ax)) What is Bx? What is Y? Isn't Y meant to be a Vector, rather than a scalar? Why is the solution correct - what is the reasoning behind it? Moreover, my use case involved complex curves rather than a simple line, hence it requires a little re-jigging: Reconstituted Answer Point a = new Point3d(ax, ay, az); // point on line Point b = new Point3d(bx, by, bz); // point on line If you want to see whether your points are above/below a curve, then you would need to get the first derivative of the particular curve you are interested in - also known as the tangent to the point on the curve. If you can do so, then you can highlight your points of interest. Of course, if your curve is a line, then you just need the point of interest without the tangent. The tangent IS the line. Vector3d lineVector = curve.GetFirstDerivative(a); // where "a" is a point on the curve. You may derive point b with a simple displacement calculation: Point3d b = new Point3d(a.X, a.Y, a.Z).TransformBy( Matrix3d.Displacement(curve.GetFirstDerivative(a)) ); Point m = new Point3d(mx, my, mz) // the point you are interested in. The Solution: return (b.X - a.X) * (m.Y - a.Y) - (b.Y - a.Y) * (m.X - a.X) < 0; // the answer Works for me! See the proof in the photo above. Green bricks satisfy the condition, but the bricks outside were filtered out! In my use case - I only want the bricks that are touching the circle. Theory behind the answer I will return to explain this. Someday. Somehow...
An alternative way of getting a feel of solutions provided by netters is to understand a little geometry implications. Let pqr=[P,Q,R] are points that forms a plane that is divided into 2 sides by line [P,R]. We are to find out if two points on pqr plane, A,B, are on the same side. Any point T on pqr plane can be represented with 2 vectors: v = P-Q and u = R-Q, as: T' = T-Q = i * v + j * u Now the geometry implications: i+j =1: T on pr line i+j <1: T on Sq i+j >1: T on Snq i+j =0: T = Q i+j <0: T on Sq and beyond Q. i+j: <0 0 <1 =1 >1 ---------Q------[PR]--------- <== this is PQR plane ^ pr line In general, i+j is a measure of how far T is away from Q or line [P,R], and the sign of i+j-1 implicates T's sideness. The other geometry significances of i and j (not related to this solution) are: i,j are the scalars for T in a new coordinate system where v,u are the new axes and Q is the new origin; i, j can be seen as pulling force for P,R, respectively. The larger i, the farther T is away from R (larger pull from P). The value of i,j can be obtained by solving the equations: i*vx + j*ux = T'x i*vy + j*uy = T'y i*vz + j*uz = T'z So we are given 2 points, A,B on the plane: A = a1 * v + a2 * u B = b1 * v + b2 * u If A,B are on the same side, this will be true: sign(a1+a2-1) = sign(b1+b2-1) Note that this applies also to the question: Are A,B in the same side of plane [P,Q,R], in which: T = i * P + j * Q + k * R and i+j+k=1 implies that T is on the plane [P,Q,R] and the sign of i+j+k-1 implies its sideness. From this we have: A = a1 * P + a2 * Q + a3 * R B = b1 * P + b2 * Q + b3 * R and A,B are on the same side of plane [P,Q,R] if sign(a1+a2+a3-1) = sign(b1+b2+b3-1)
equation of line is y-y1 = m(x-x1) here m is y2-y1 / x2-x1 now put m in equation and put condition on y < m(x-x1) + y1 then it is left side point eg. for i in rows: for j in cols: if j>m(i-a)+b: image[i][j]=0
A(x1,y1) B(x2,y2) a line segment with length L=sqrt( (y2-y1)^2 + (x2-x1)^2 ) and a point M(x,y) making a transformation of coordinates in order to be the point A the new start and B a point of the new X axis we have the new coordinates of the point M which are newX = ((x-x1)(x2-x1)+(y-y1)(y2-y1)) / L from (x-x1)*cos(t)+(y-y1)*sin(t) where cos(t)=(x2-x1)/L, sin(t)=(y2-y1)/L newY = ((y-y1)(x2-x1)-(x-x1)(y2-y1)) / L from (y-y1)*cos(t)-(x-x1)*sin(t) because "left" is the side of axis X where the Y is positive, if the newY (which is the distance of M from AB) is positive, then it is on the left side of AB (the new X axis) You may omit the division by L (allways positive), if you only want the sign
Code or formula for intersection of two parabolas in any rotation
I am working on a geometry problem that requires finding the intersection of two parabolic arcs in any rotation. I was able to intesect a line and a parabolic arc by rotating the plane to align the arc with an axis, but two parabolas cannot both align with an axis. I am working on deriving the formulas, but I would like to know if there is a resource already available for this.
I'd first define the equation for the parabolic arc in 2D without rotations: x(t) = ax² + bx + c y(t) = t; You can now apply the rotation by building a rotation matrix: s = sin(angle) c = cos(angle) matrix = | c -s | | s c | Apply that matrix and you'll get the rotated parametric equation: x' (t) = x(t) * c - s*t; y' (t) = x(t) * s + c*t; This will give you two equations (for x and y) of your parabolic arcs. Do that for both of your rotated arcs and subtract them. This gives you an equation like this: xa'(t) = rotated equation of arc1 in x ya'(t) = rotated equation of arc1 in y. xb'(t) = rotated equation of arc2 in x yb'(t) = rotated equation of arc2 in y. t1 = parametric value of arc1 t2 = parametric value of arc2 0 = xa'(t1) - xb'(t2) 0 = ya'(t1) - yb'(t2) Each of these equation is just a order 2 polynomial. These are easy to solve. To find the intersection points you solve the above equation (e.g. find the roots). You'll get up to two roots for each axis. Any root that is equal on x and y is an intersection point between the curves. Getting the position is easy now: Just plug the root into your parametric equation and you can directly get x and y.
Unfortunately, the general answer requires solution of a fourth-order polynomial. If we transform coordinates so one of the two parabolas is in the standard form y=x^2, then the second parabola satisfies (ax+by)^2+cx+dy+e==0. To find the intersection, solve both simultaneously. Substituting in y=x^2 we see that the result is a fourth-order polynomial: (ax+bx^2)^2+cx+dx^2+e==0. Nils solution therefore won't work (his mistake: each one is a 2nd order polynomial in each variable separately, but together they're not).
It's easy if you have a CAS at hand.
See the solution in Mathematica.
Choose one parabola and change coordinates so its equation becomes y(x)=a x^2 (Normal form).
The other parabola will have the general form:
A x^2 + B x y + CC y^2 + DD x + EE y + F == 0
where B^2-4 A C ==0 (so it's a parabola)
Let's solve a numeric case:
p = {a -> 1, A -> 1, B -> 2, CC -> 1, DD -> 1, EE -> -1, F -> 1};
p1 = {ToRules#N#Reduce[
(A x^2 + B x y + CC y^2 + DD x + EE y +F /. {y -> a x^2 } /. p) == 0, x]}
{{x -> -2.11769}, {x -> -0.641445},
{x -> 0.379567- 0.76948 I},
{x -> 0.379567+ 0.76948 I}}
Let's plot it:
Show[{
Plot[a x^2 /. p, {x, -10, 10}, PlotRange -> {{-10, 10}, {-5, 5}}],
ContourPlot[(A x^2 + B x y + CC y^2 + DD x + EE y + F /. p) ==
0, {x, -10, 10}, {y, -10, 10}],
Graphics[{
PointSize[Large], Pink, Point[{x, x^2} /. p /. p1[[1]]],
PointSize[Large], Pink, Point[{x, x^2} /. p /. p1[[2]]]
}]}]
The general solution involves calculating the roots of:
4 A F + 4 A DD x + (4 A^2 + 4 a A EE) x^2 + 4 a A B x^3 + a^2 B^2 x^4 == 0
Which is done easily in any CAS.