Detect if two ellipses intersect I have seen a lot of papers on how to find points of intersection between two ellipses for 2D case, but i only need to check if two ellipses are in collision. I don't need to know points of intersection if there are any. Is there simplified algorithm for this. Thanks.
I know center and two radii for every ellipse. Both ellipses can be rotated.
 A: Checking whether two ellipses intersect, or more generally two n-dimenensional ellipsoids, can be done by solving a 1D smooth convex optimization problem. This is very easy and fast to do computationally.
Format the ellipsoids are given in
First, the data format that ellipsoids are given in should be a a vector which defines the center of the ellipse, and a symmetric positive definite matrix which defines the shape of the ellipse. In particular, let $a,b \in \mathbb{R}^n$, let $A,B \in \mathbb{R}^{n \times n}$ be symmetric positive definite matrices, and define the ellipsoids as follows:
\begin{align*}
E_A &= \{x : (x-a)^T A (x-a) \le 1\} \\
E_B &= \{x : (x-b)^T B (x-b) \le 1\}.
\end{align*}
The vector $a$ is the centerpoint of the ellipsoid $E_A$. The eigenvectors of the matrix $A$ are the unit vectors that point in the directions of the primary axes of $E_A$. The inverse square roots of the corresponding eigenvalues ($1/\sqrt{\lambda_i}$) of $A$ are the lengths of the primary axes of $E_A$. This is shown in the image below. The vector $b$ and matrix $B$ characterize $E_B$ in the same manner.

The vectors $a$ and $b$ and matrices $A$ and $B$ uniquely define the ellipsoids $E_A$ and $E_B$, respectively. Also, for every ellipsoid, there is a corresponding vector and matrix (like $a$ and $A$) that can put it in this format. For more on this, you can see the following wikipedia article:
https://en.wikipedia.org/wiki/Ellipsoid
If your ellipses (2D) or ellipsoids (nD) are given in another format, such as axis lengths and angles, the first step is to convert them to this format by computing the vectors $a$ and $b$, and matrices $A$ and $B$.
Fast ellipsoid intersection test
Now define the following convex scalar function $K:(0,1)\rightarrow \mathbb{R}$,
$$K(s) := 1 - (b-a)^T\left(\frac{1}{1-s}A^{-1} + \frac{1}{s}B^{-1}\right)^{-1}(b-a).$$
The following result holds:
$$E_A \cap E_B = \{\} \quad \text{if and only if}\quad K(s)<0 \quad \text{for some}\quad s \in (0,1).$$
This is proven in Proposition 2 of the following paper:

Gilitschenski, Igor, and Uwe D. Hanebeck. "A robust computational test
for overlap of two arbitrary-dimensional ellipsoids in fault-detection
of kalman filters." 2012 15th International Conference on Information
Fusion. IEEE, 2012.

So you can check whether the two ellipsoids intersect by finding the minimum of $K$ on $(0,1)$ using any 1D convex minimization routine, then check if $K(s)$ is greater than 0 at the minima.
I like to use Brent's algorithm to find the minimum, because it is fast and implementations are available in many software libraries such as scipy.
https://en.wikipedia.org/wiki/Brent%27s_method
The minimization algorithm will evaluate $K(s)$ many times for different values of $s$. You can avoid performing matrix inverses/linear solves at each evaluation of $K(s)$ by precomputing the generalized eigenvalue decomposition of $A$ with respect to $B$, then working in the basis of generalized eigenvectors, because both matrices become diagonal in this basis.
http://fourier.eng.hmc.edu/e161/lectures/algebra/node7.html
Code
Here is some python code I wrote to do this. In this code, $\Sigma_A := A^{-1}$, $\Sigma_B := B^{-1}$, $\mu_A = a$, and $\mu_B = b$, and $\tau$ is an optional scalar that makes the ellipses uniformly bigger or smaller.
import numpy as np
from scipy.linalg import eigh
from scipy.optimize import minimize_scalar


def ellipsoid_intersection_test(Sigma_A, Sigma_B, mu_A, mu_B, tau=1.0):
    lambdas, Phi = eigh(Sigma_A, b=Sigma_B)
    v_squared = np.dot(Phi.T, mu_A - mu_B) ** 2
    res = minimize_scalar(K_function,
                          bracket=[0.0, 0.5, 1.0],
                          args=(lambdas, v_squared, tau))
    return (res.fun[0] >= 0)


def K_function(s, lambdas, v_squared, tau):
    return 1.-(1./tau**2)*np.sum(v_squared*((s*(1.-s))/(1.+s*(lambdas-1.))))

Example images of $K(s)$
Here are a sequence of pictures showing how the function $K(s)$ changes as one ellipsoid slides past another:









The complete code I used to generate these pictures is in the following jupyter notebook:
https://github.com/NickAlger/nalger_helper_functions/blob/master/tutorial_notebooks/ellipsoid_intersection_test_tutorial.ipynb
A: By a suitable stretching of the plane in the direction of the axis of one of the ellipses, you can turn this ellipse to a circle, while the other remains an ellipse.
Now checking if the circle and the ellipse have a nonempty intersection is the same as checking if the center of the circle is inside the outward offset curve of the ellipse, at distance $r$.

Unfortunately, such an offset curve is known to have an octic ($8^{th}$) degree implicit equation, which is just horrible. Check "Brief Atlas of Offset Curves", example 4.
This tends to show that there is no easy exact analytical solution. If you can do with an approximate solution, just replace the offset curve by another ellipse of axis $a+r$ and $b+r$.
A: Let we suppose that $E_1$ is an ellipse with equation $f(x,y)=\frac{x^2}{a}+\frac{y^2}{b}-1=0$ and $E_2$ is another ellipse. To check if $E_1$ and $E_2$ intersect, it is sufficient to check if $f(x,y)$ takes only positive values on $\partial E_2$. So we can take a parametrization of $\partial E_2$ and compute the stationary points for the quadratic function $f(x,y)$ on $\partial E_2$. If we values of $f$ in such points are positive, $E_1$ and $E_2$ do not intersect, otherwise they intersect. 
Here I assumed that the ellipses lie on the euclidean plane, but the same argument can be extended also to check if two ellipses in $\mathbb{R}^3$ are "linked" or not.
