calculate turning points / pivot points in trajectory (path) - python
I'm trying to come up with an algorithm that will determine turning points in a trajectory of x/y coordinates. The following figures illustrates what I mean: green indicates the starting point and red the final point of the trajectory (the entire trajectory consists of ~ 1500 points):
In the following figure, I added by hand the possible (global) turning points that an algorithm could return:
Obviously, the true turning point is always debatable and will depend on the angle that one specifies that has to lie between points. Furthermore a turning point can be defined on a global scale (what I tried to do with the black circles), but could also be defined on a high-resolution local scale. I'm interested in the global (overall) direction changes, but I'd love to see a discussion on the different approaches that one would use to tease apart global vs local solutions.
What I've tried so far:
calculate distance between subsequent points
calculate angle between subsequent points
look how distance / angle changes between subsequent points
Unfortunately this doesn't give me any robust results. I probably have too calculate the curvature along multiple points, but that's just an idea.
I'd really appreciate any algorithms / ideas that might help me here. The code can be in any programming language, matlab or python are preferred.
EDIT here's the raw data (in case somebody want's to play with it):
mat file
text file (x coordinate first, y coordinate in second line)
You could use the Ramer-Douglas-Peucker (RDP) algorithm to simplify the path. Then you could compute the change in directions along each segment of the simplified path. The points corresponding to the greatest change in direction could be called the turning points:
A Python implementation of the RDP algorithm can be found on github.
import matplotlib.pyplot as plt
import numpy as np
import os
import rdp
def angle(dir):
"""
Returns the angles between vectors.
Parameters:
dir is a 2D-array of shape (N,M) representing N vectors in M-dimensional space.
The return value is a 1D-array of values of shape (N-1,), with each value
between 0 and pi.
0 implies the vectors point in the same direction
pi/2 implies the vectors are orthogonal
pi implies the vectors point in opposite directions
"""
dir2 = dir[1:]
dir1 = dir[:-1]
return np.arccos((dir1*dir2).sum(axis=1)/(
np.sqrt((dir1**2).sum(axis=1)*(dir2**2).sum(axis=1))))
tolerance = 70
min_angle = np.pi*0.22
filename = os.path.expanduser('~/tmp/bla.data')
points = np.genfromtxt(filename).T
print(len(points))
x, y = points.T
# Use the Ramer-Douglas-Peucker algorithm to simplify the path
# http://en.wikipedia.org/wiki/Ramer-Douglas-Peucker_algorithm
# Python implementation: https://github.com/sebleier/RDP/
simplified = np.array(rdp.rdp(points.tolist(), tolerance))
print(len(simplified))
sx, sy = simplified.T
# compute the direction vectors on the simplified curve
directions = np.diff(simplified, axis=0)
theta = angle(directions)
# Select the index of the points with the greatest theta
# Large theta is associated with greatest change in direction.
idx = np.where(theta>min_angle)[0]+1
fig = plt.figure()
ax =fig.add_subplot(111)
ax.plot(x, y, 'b-', label='original path')
ax.plot(sx, sy, 'g--', label='simplified path')
ax.plot(sx[idx], sy[idx], 'ro', markersize = 10, label='turning points')
ax.invert_yaxis()
plt.legend(loc='best')
plt.show()
Two parameters were used above:
The RDP algorithm takes one parameter, the tolerance, which
represents the maximum distance the simplified path
can stray from the original path. The larger the tolerance, the cruder the simplified path.
The other parameter is the min_angle which defines what is considered a turning point. (I'm taking a turning point to be any point on the original path, whose angle between the entering and exiting vectors on the simplified path is greater than min_angle).
I will be giving numpy/scipy code below, as I have almost no Matlab experience.
If your curve is smooth enough, you could identify your turning points as those of highest curvature. Taking the point index number as the curve parameter, and a central differences scheme, you can compute the curvature with the following code
import numpy as np
import matplotlib.pyplot as plt
import scipy.ndimage
def first_derivative(x) :
return x[2:] - x[0:-2]
def second_derivative(x) :
return x[2:] - 2 * x[1:-1] + x[:-2]
def curvature(x, y) :
x_1 = first_derivative(x)
x_2 = second_derivative(x)
y_1 = first_derivative(y)
y_2 = second_derivative(y)
return np.abs(x_1 * y_2 - y_1 * x_2) / np.sqrt((x_1**2 + y_1**2)**3)
You will probably want to smooth your curve out first, then calculate the curvature, then identify the highest curvature points. The following function does just that:
def plot_turning_points(x, y, turning_points=10, smoothing_radius=3,
cluster_radius=10) :
if smoothing_radius :
weights = np.ones(2 * smoothing_radius + 1)
new_x = scipy.ndimage.convolve1d(x, weights, mode='constant', cval=0.0)
new_x = new_x[smoothing_radius:-smoothing_radius] / np.sum(weights)
new_y = scipy.ndimage.convolve1d(y, weights, mode='constant', cval=0.0)
new_y = new_y[smoothing_radius:-smoothing_radius] / np.sum(weights)
else :
new_x, new_y = x, y
k = curvature(new_x, new_y)
turn_point_idx = np.argsort(k)[::-1]
t_points = []
while len(t_points) < turning_points and len(turn_point_idx) > 0:
t_points += [turn_point_idx[0]]
idx = np.abs(turn_point_idx - turn_point_idx[0]) > cluster_radius
turn_point_idx = turn_point_idx[idx]
t_points = np.array(t_points)
t_points += smoothing_radius + 1
plt.plot(x,y, 'k-')
plt.plot(new_x, new_y, 'r-')
plt.plot(x[t_points], y[t_points], 'o')
plt.show()
Some explaining is in order:
turning_points is the number of points you want to identify
smoothing_radius is the radius of a smoothing convolution to be applied to your data before computing the curvature
cluster_radius is the distance from a point of high curvature selected as a turning point where no other point should be considered as a candidate.
You may have to play around with the parameters a little, but I got something like this:
>>> x, y = np.genfromtxt('bla.data')
>>> plot_turning_points(x, y, turning_points=20, smoothing_radius=15,
... cluster_radius=75)
Probably not good enough for a fully automated detection, but it's pretty close to what you wanted.
A very interesting question. Here is my solution, that allows for variable resolution. Although, fine-tuning it may not be simple, as it's mostly intended to narrow down
Every k points, calculate the convex hull and store it as a set. Go through the at most k points and remove any points that are not in the convex hull, in such a way that the points don't lose their original order.
The purpose here is that the convex hull will act as a filter, removing all of "unimportant points" leaving only the extreme points. Of course, if the k-value is too high, you'll end up with something too close to the actual convex hull, instead of what you actually want.
This should start with a small k, at least 4, then increase it until you get what you seek. You should also probably only include the middle point for every 3 points where the angle is below a certain amount, d. This would ensure that all of the turns are at least d degrees (not implemented in code below). However, this should probably be done incrementally to avoid loss of information, same as increasing the k-value. Another possible improvement would be to actually re-run with points that were removed, and and only remove points that were not in both convex hulls, though this requires a higher minimum k-value of at least 8.
The following code seems to work fairly well, but could still use improvements for efficiency and noise removal. It's also rather inelegant in determining when it should stop, thus the code really only works (as it stands) from around k=4 to k=14.
def convex_filter(points,k):
new_points = []
for pts in (points[i:i + k] for i in xrange(0, len(points), k)):
hull = set(convex_hull(pts))
for point in pts:
if point in hull:
new_points.append(point)
return new_points
# How the points are obtained is a minor point, but they need to be in the right order.
x_coords = [float(x) for x in x.split()]
y_coords = [float(y) for y in y.split()]
points = zip(x_coords,y_coords)
k = 10
prev_length = 0
new_points = points
# Filter using the convex hull until no more points are removed
while len(new_points) != prev_length:
prev_length = len(new_points)
new_points = convex_filter(new_points,k)
Here is a screen shot of the above code with k=14. The 61 red dots are the ones that remain after the filter.
The approach you took sounds promising but your data is heavily oversampled. You could filter the x and y coordinates first, for example with a wide Gaussian and then downsample.
In MATLAB, you could use x = conv(x, normpdf(-10 : 10, 0, 5)) and then x = x(1 : 5 : end). You will have to tweak those numbers depending on the intrinsic persistence of the objects you are tracking and the average distance between points.
Then, you will be able to detect changes in direction very reliably, using the same approach you tried before, based on the scalar product, I imagine.
Another idea is to examine the left and the right surroundings at every point. This may be done by creating a linear regression of N points before and after each point. If the intersecting angle between the points is below some threshold, then you have an corner.
This may be done efficiently by keeping a queue of the points currently in the linear regression and replacing old points with new points, similar to a running average.
You finally have to merge adjacent corners to a single corner. E.g. choosing the point with the strongest corner property.
Related
Find new position for overlapping circles
I am trying to write a code that, for a given list of circles (list1), it is able to find the positions for new circles (list2). list1 and list2 have the same length, because for each circle in list1 there must be a circle from list2. Each pair of circles (let's say circle1 from list1 and circle2 from list2), must be as close together as possible, circles from list2 must not overlap with circles from list1, while circles of the single lists can overlap each other. list1 is fixed, so now I have to find the right position for circles from list2. I wrote this simple function to recognize if 2 circles overlap: def overlap(x1, y1, x2, y2, r1, r2): distSq = (x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2) radSumSq = (r1 + r2) * (r1 + r2) if (distSq >= radSumSq): return False # no overlap else: return True #overlap and this is the list1: with: x=[14.11450195 14.14184093 14.15435028 14.16206741 14.16951752 14.17171097 14.18569565 14.19700241 14.23129082 14.24083233 14.24290752 14.24968338 14.2518959 14.26536751 14.27209759 14.27612877 14.2904377 14.29187012 14.29409599 14.29618549 14.30615044 14.31624985 14.3206892 14.3228569 14.36143875 14.36351967 14.36470699 14.36697292 14.37235737 14.41422081 14.42583466 14.43226814 14.43319225 14.4437027 14.4557848 14.46592999 14.47036076 14.47452068 14.47815609 14.52229309 14.53059006 14.53404236 14.5411644 ] y=[-0.35319126 -0.44222349 -0.44763246 -0.35669261 -0.24366629 -0.3998799 -0.38940558 -0.57744932 -0.45223859 -0.21021004 -0.44250247 -0.45866323 -0.47203487 -0.51684451 -0.44884869 -0.2018993 -0.40296811 -0.23641759 -0.18019417 -0.33391538 -0.53565156 -0.45215255 -0.40939832 -0.26936951 -0.30894437 -0.55504167 -0.47177047 -0.45573688 -0.43100587 -0.5805912 -0.21770373 -0.199422 -0.17372169 -0.38522363 -0.56950212 -0.56947368 -0.48770753 -0.24940367 -0.31492445 -0.54263926 -0.53460872 -0.4053807 -0.43733299] radius = 0.014 Copy and pasteable... x = [14.11450195,14.14184093,14.15435028,14.16206741,14.16951752, 14.17171097,14.18569565,14.19700241,14.23129082,14.24083233, 14.24290752,14.24968338,14.2518959,14.26536751,14.27209759, 14.27612877,14.2904377,14.29187012,14.29409599,14.29618549, 14.30615044,14.31624985,14.3206892,14.3228569,14.36143875, 14.36351967,14.36470699,14.36697292,14.37235737,14.41422081, 14.42583466,14.43226814,14.43319225,14.4437027,14.4557848, 14.46592999,14.47036076,14.47452068,14.47815609,14.52229309, 14.53059006,14.53404236,14.5411644] y = [-0.35319126,-0.44222349,-0.44763246,-0.35669261,-0.24366629, -0.3998799,-0.38940558,-0.57744932,-0.45223859,-0.21021004, -0.44250247,-0.45866323,-0.47203487,-0.51684451,-0.44884869, -0.2018993,-0.40296811,-0.23641759,-0.18019417,-0.33391538, -0.53565156,-0.45215255,-0.40939832,-0.26936951,-0.30894437, -0.55504167,-0.47177047,-0.45573688,-0.43100587,-0.5805912, -0.21770373,-0.199422,-0.17372169,-0.38522363,-0.56950212, -0.56947368,-0.48770753,-0.24940367,-0.31492445,-0.54263926, -0.53460872,-0.4053807,-0.43733299] Now I am not sure about what I have to do, my first idea is to draw circles of list2 taking x and y from list one and do something like x+c and y+c, where c is a fixed value. Then I can call my overlapping function and, if there is overlap I can increase the c value. In this way I have 2 for loops. Now, my questions are: There is a way to avoid for loops? Is there a smart solution to find a neighbor (circle from list2) for each circle from list1 (without overlaps with other circles from list2)?
Using numpy arrays, you can avoid for loops. Setup from your example. import numpy as np #Using your x and y c1 = np.array([x,y]).T # random set of other centers within the same range as c1 c2 = np.random.random((10,2)) np.multiply(c2, c1.max(0)-c1.min(0),out = c2) np.add(c2, c1.min(0), out=c2) radius = 0.014 r = radius min_d = (2*r)*(2*r) plot_circles(c1,c2) # see function at end An array of distances from each center in c1 to each center in c2 def dist(c1,c2): dx = c1[:,0,None] - c2[:,0] dy = c1[:,1,None] - c2[:,1] return dx*dx + dy*dy d = dist(c1,c2) Or you could use scipy.spatial from scipy.spatial import distance d = distance.cdist(c1,c2,'sqeuclidean') Create a 2d Boolean array for circles that intersect. intersect = d <= min_d Find the indices of overlapping circles from the two sets. a,b = np.where(intersect) plot_circles(c1[a],c2[b]) Using intersect or a and b to index c1,c2, and d you should be able to get groups of intersecting circles then figure out how to move the c2 centers - but I'll leave that for another question/answer. If a list2 circle intersects one list1 circle - find the line between the two and move along that line. If a list2 circle intersects more than one list1 circle - find the line between the two closestlist1circles and move thelitst2` circle along a line perpendicular to that. You didn't mention any constraints on moving the circles so maybe random movement then find the intersects again but that might be problematic. In the following image, it may be trivial to figure out how to move most of the red circles but the group circled in blue might require a different strategy. Here are some examples for getting groups: >>> for f,g,h in zip(c1[a],c2[b],d[a,b]): print(f,g,h) >>> c1[intersect.any(1)],c2[intersect.any(0)] >>> for (f,g) in zip(c2,intersect.T): if g.any(): print(f.tolist(),c1[g].tolist()) import matplotlib as mpl from matplotlib import pyplot as plt def plot_circles(c1,c2): bounds = np.array([c1.min(0),c2.min(0),c1.max(0),c2.max(0)]) xmin, ymin = bounds.min(0) xmax, ymax = bounds.max(0) circles1 = [mpl.patches.Circle(xy,radius=r,fill=False,edgecolor='g') for xy in c1] circles2 = [mpl.patches.Circle(xy,radius=r,fill=False,edgecolor='r') for xy in c2] fig = plt.figure() ax = fig.add_subplot(111) for c in circles2: ax.add_artist(c) for c in circles1: ax.add_artist(c) ax.set_xlim(xmin-r,xmax+r) ax.set_ylim(ymin-r,ymax+r) plt.show() plt.close()
This problem can very well be seen as an optimization problem. To be more precise, a nonlinear optimization problem with constraints. Since optimization strategies are not always so easy to understand, I will define the problem as simply as possible and also choose an approach that is as general as possible (but less efficient) and does not involve a lot of mathematics. As a spoiler: We are going to formulate the problem and the minimization process in less than 10 lines of code using the scipy library. However, I will still provide hints on where you can get your hands even dirtier. Formulating the problem As a guide for a formulation of an NLP-class problem (Nonlinear Programming), you can go directly to the two requirements in the original post. Each pair of circles must be as close together as possible -> Hint for a cost-function Circles must not overlap with other (moved) circles -> Hint for a constraint Cost function Let's start with the formulation of the cost function to be minimized. Since the circles should be moved as little as possible (resulting in the closest possible neighborhood), a quadratic penalty term for the distances between the circles of the two lists can be chosen for the cost function: import scipy.spatial.distance as sd def cost_function(new_positions, old_positions): new_positions = np.reshape(new_positions, (-1, 2)) return np.trace(sd.cdist(new_positions, old_positions, metric='sqeuclidean')) Why quadratic? Partly because of differentiability and for stochastic reasons (think of the circles as normally distributed measurement errors -> least squares is then a maximum likelihood estimator). By exploiting the structure of the cost function, the efficiency of the optimization can be increased (elimination of sqrt). By the way, this problem is related to nonlinear regression, where (nonlinear) least squares are also used. Now that we have a cost function at hand, we also have a good way to evaluate our optimization. To be able to compare solutions of different optimization strategies, we simply pass the newly calculated positions to the cost function. Let's give it a try: For example, let us use the calculated positions from the Voronoi approach (by Paul Brodersen). print(cost_function(new_positions, old_positions)) # prints 0.007999244511697411 That's a pretty good value if you ask me. Considering that the cost function spits out zero when there is no displacement at all, this cost is pretty close. We can now try to outperform this value by using classical optimization! Non-linear constraint We know that circles must not overlap with other circles in the new set. If we translate this into a constraint, we find that the lower bound for the distance is 2 times the radius and the upper bound is simply infinity. import scipy.spatial.distance as sd from scipy.optimize import NonlinearConstraint def cons_f(x): x = np.reshape(x, (-1, 2)) return sd.pdist(x) nonlinear_constraint = NonlinearConstraint(cons_f, 2*radius, np.inf, jac='2-point') Here we make life easy by approximating the Jacobi matrix via finite differences (see parameter jac='2-point'). At this point it should be said that we can increase the efficiency here, by formulating the derivatives of the first and second order ourselves instead of using approximations. But this is left to the interested reader. (It is not that hard, because we use quite simple mathematical expressions for distance calculation here.) One additional note: You can also set a boundary constraint for the positions themselves not to exceed a specified region. This can then be used as another parameter. (See scipy.optimize.Bounds) Minimizing the cost function under constraints Now we have both ingredients, the cost function and the constraint, in place. Now let's minimize the whole thing! from scipy.optimize import minimize res = minimize(lambda x: cost_function(x, positions), positions.flatten(), method='SLSQP', jac="2-point", constraints=[nonlinear_constraint]) As you can see, we approximate the first derivatives here as well. You can also go deeper here and set up the derivatives yourself (analytically). Also note that we must always pass the parameters (an nx2 vector specifying the positions of the new layout for n circles) as a flat vector. For this reason, reshaping can be found several times in the code. Evaluation, summary and visualization Let's see how the optimization result performs in our cost function: new_positions = np.reshape(res.x, (-1,2)) print(cost_function(new_positions, old_positions)) # prints 0.0010314079483565686 Starting from the Voronoi approach, we actually reduced the cost by another 87%! Thanks to the power of modern optimization strategies, we can solve a lot of problems in no time. Of course, it would be interesting to see how the shifted circles look now: Circles after Optimization Performance: 77.1 ms ± 1.17 ms The entire code: from scipy.optimize import minimize import scipy.spatial.distance as sd from scipy.optimize import NonlinearConstraint # Given by original post positions = np.array([x, y]).T def cost_function(new_positions, old_positions): new_positions = np.reshape(new_positions, (-1, 2)) return np.trace(sd.cdist(new_positions, old_positions, metric='sqeuclidean')) def cons_f(x): x = np.reshape(x, (-1, 2)) return sd.pdist(x) nonlinear_constraint = NonlinearConstraint(cons_f, 2*radius, np.inf, jac='2-point') res = minimize(lambda x: cost_function(x, positions), positions.flatten(), method='SLSQP', jac="2-point", constraints=[nonlinear_constraint])
One solution could be to follow the gradient of the unwanted spacing between each circle, though maybe there is a better way. This approach has a few parameters to tune and takes some time to run. import matplotlib.pyplot as plt from scipy.optimize import minimize as mini import numpy as np from scipy.optimize import approx_fprime x = np.array([14.11450195,14.14184093,14.15435028,14.16206741,14.16951752, 14.17171097,14.18569565,14.19700241,14.23129082,14.24083233, 14.24290752,14.24968338,14.2518959,14.26536751,14.27209759, 14.27612877,14.2904377,14.29187012,14.29409599,14.29618549, 14.30615044,14.31624985,14.3206892,14.3228569,14.36143875, 14.36351967,14.36470699,14.36697292,14.37235737,14.41422081, 14.42583466,14.43226814,14.43319225,14.4437027,14.4557848, 14.46592999,14.47036076,14.47452068,14.47815609,14.52229309, 14.53059006,14.53404236,14.5411644]) y = np.array([-0.35319126,-0.44222349,-0.44763246,-0.35669261,-0.24366629, -0.3998799,-0.38940558,-0.57744932,-0.45223859,-0.21021004, -0.44250247,-0.45866323,-0.47203487,-0.51684451,-0.44884869, -0.2018993,-0.40296811,-0.23641759,-0.18019417,-0.33391538, -0.53565156,-0.45215255,-0.40939832,-0.26936951,-0.30894437, -0.55504167,-0.47177047,-0.45573688,-0.43100587,-0.5805912, -0.21770373,-0.199422,-0.17372169,-0.38522363,-0.56950212, -0.56947368,-0.48770753,-0.24940367,-0.31492445,-0.54263926, -0.53460872,-0.4053807,-0.43733299]) radius = 0.014 x0, y0 = (x, y) def plot_circles(x, y, name='initial'): fig, ax = plt.subplots() for ii in range(x.size): ax.add_patch(plt.Circle((x[ii], y[ii]), radius, color='b', fill=False)) ax.set_xlim(x.min() - radius, x.max() + radius) ax.set_ylim(y.min() - radius, y.max() + radius) fig.savefig(name) plt.clf() def spacing(s): x, y = np.split(s, 2) dX, dY = [np.subtract(*np.meshgrid(xy, xy, indexing='ij')).T for xy in [x, y]] dXY2 = dX**2 + dY**2 return np.minimum(dXY2[np.triu_indices(x.size, 1)] - (2 * radius) ** 2, 0).sum() plot_circles(x, y) def spacingJ(s): return approx_fprime(s, spacing, 1e-8) s = np.append(x, y) for ii in range(50): j = spacingJ(s) if j.sum() == 0: break s += .01 * j x_new, y_new = np.split(s, 2) plot_circles(x_new, y_new, 'new%i' % ii) plot_circles(x_new, y_new, 'new%i' % ii) https://giphy.com/gifs/x0lWDLZBz5O3gWTbLa
This answer implements a variation of the Lloyds algorithm. The basic idea is to compute the Voronoi diagram for your points / circles. This assigns each point a cell, which is a region that includes the point and which has a center that is maximally far away from all other points.
In the original algorithm, we would move each point towards the center of its Voronoi cell. Over time, this results in an even spread of points, as illustrated here.
In this variant, we only move points that overlap another point.
import numpy as np
import matplotlib.pyplot as plt
from scipy.spatial import Voronoi
from scipy.spatial.distance import cdist
def remove_overlaps(positions, radii, tolerance=1e-6):
"""Use a variation of Lloyds algorithm to move circles apart from each other until none overlap.
Parameters
----------
positions : array
The (x, y) coordinates of the circle origins.
radii : array
The radii for each circle.
tolerance : float
If all circles overlap less than this threshold, the computation stops.
Higher values leads to faster convergence.
Returns
-------
new_positions : array
The (x, y) coordinates of the circle origins.
See also
--------
https://en.wikipedia.org/wiki/Lloyd%27s_algorithm
"""
positions = np.array(positions)
radii = np.array(radii)
minimum_distances = radii[np.newaxis, :] + radii[:, np.newaxis]
minimum_distances[np.diag_indices_from(minimum_distances)] = 0 # ignore distances to self
# Initialize the first loop.
distances = cdist(positions, positions)
displacements = np.max(np.clip(minimum_distances - distances, 0, None), axis=-1)
while np.any(displacements > tolerance):
centroids = _get_voronoi_centroids(positions)
# Compute the direction from each point towards its corresponding Voronoi centroid.
deltas = centroids - positions
magnitudes = np.linalg.norm(deltas, axis=-1)
directions = deltas / magnitudes[:, np.newaxis]
# Mask NaNs that arise if the magnitude is zero, i.e. the point is already center of the Voronoi cell.
directions[np.isnan(directions)] = 0
# Step into the direction of the centroid.
# Clipping prevents overshooting of the centroid when stepping into the direction of the centroid.
# We step by half the displacement as the other overlapping point will be moved in approximately the opposite direction.
positions = positions + np.clip(0.5 * displacements, None, magnitudes)[:, np.newaxis] * directions
# Initialize next loop.
distances = cdist(positions, positions)
displacements = np.max(np.clip(minimum_distances - distances, 0, None), axis=-1)
return positions
def _get_voronoi_centroids(positions):
"""Construct a Voronoi diagram from the given positions and determine the center of each cell."""
voronoi = Voronoi(positions)
centroids = np.zeros_like(positions)
for ii, idx in enumerate(voronoi.point_region):
region = [jj for jj in voronoi.regions[idx] if jj != -1] # i.e. ignore points at infinity; TODO: compute correctly clipped regions
centroids[ii] = np.mean(voronoi.vertices[region], axis=0)
return centroids
if __name__ == '__main__':
x = np.array([14.11450195,14.14184093,14.15435028,14.16206741,14.16951752,
14.17171097,14.18569565,14.19700241,14.23129082,14.24083233,
14.24290752,14.24968338,14.2518959,14.26536751,14.27209759,
14.27612877,14.2904377,14.29187012,14.29409599,14.29618549,
14.30615044,14.31624985,14.3206892,14.3228569,14.36143875,
14.36351967,14.36470699,14.36697292,14.37235737,14.41422081,
14.42583466,14.43226814,14.43319225,14.4437027,14.4557848,
14.46592999,14.47036076,14.47452068,14.47815609,14.52229309,
14.53059006,14.53404236,14.5411644])
y = np.array([-0.35319126,-0.44222349,-0.44763246,-0.35669261,-0.24366629,
-0.3998799,-0.38940558,-0.57744932,-0.45223859,-0.21021004,
-0.44250247,-0.45866323,-0.47203487,-0.51684451,-0.44884869,
-0.2018993,-0.40296811,-0.23641759,-0.18019417,-0.33391538,
-0.53565156,-0.45215255,-0.40939832,-0.26936951,-0.30894437,
-0.55504167,-0.47177047,-0.45573688,-0.43100587,-0.5805912,
-0.21770373,-0.199422,-0.17372169,-0.38522363,-0.56950212,
-0.56947368,-0.48770753,-0.24940367,-0.31492445,-0.54263926,
-0.53460872,-0.4053807,-0.43733299])
radius = 0.014
positions = np.c_[x, y]
radii = np.full(len(positions), radius)
fig, axes = plt.subplots(1, 2, sharex=True, sharey=True, figsize=(14, 7))
for position, radius in zip(positions, radii):
axes[0].add_patch(plt.Circle(position, radius, fill=False))
axes[0].set_xlim(x.min() - radius, x.max() + radius)
axes[0].set_ylim(y.min() - radius, y.max() + radius)
axes[0].set_aspect('equal')
new_positions = remove_overlaps(positions, radii)
for position, radius in zip(new_positions, radii):
axes[1].add_patch(plt.Circle(position, radius, fill=False))
for ax in axes.ravel():
ax.set_aspect('equal')
plt.show()
How to detect parallelograms from the detected edge points in python
I am reading an image and trying to detect parallelogram in the image. I have created an array which contains edge points(local peaks) using Hough Transform (p = xcos(theta) + ysin(theta)). I got around 2300 edge points(X,Y) and I am not sure how to get/extract parallelogram from it. Out of 2300 edge points, some of the edge points are of circular shape, the triangular shape including parallelogram. If I start considering edge-points(X,Y) as it is then it will not work as they are not only vertices of parallelogram and edge points are in big number(2300 points). [EDIT1] I have stored the edge point in test_img and it contains the pixel value. test_img[point.getX(), point.getY()] = 255 test_img.size = 2343 After plotting above test_image "plt.imshow(test_img, cmap="gray")" I am getting image as below Any help would be highly appreciated.
Given that you already have neat edges, you could try to apply linear regression to extract straight line edges: Pick a random point belonging to an edge plus its N neighbors and put it into a list L. Adjust the procedure of finding neighbors to deal with small gaps. Calculate a line that will fit the data in L. Keep track of the line parameters (angle, offset and MSE). Keep adding batches of neighbors and recalculating the linear model until MSE starts to rise. You probably found a line segment! Does it have MSE close to zero, is it long enough? If yes, store the estimated parameters of the line somewhere. Exclude pixels from L from the picture. Go to #1. After you've collected the segments, it should be pretty trivial to find something resembling parallelograms.
You are lucky to get fairly clean and continuous edges. You can segment them in line segments by the Douglas-Peucker procedure with a suitable straightness tolerance. Keep the segments that are long enough*. You can also try to fill the gap bewteen close and well aligned segments, as well as reconstruct the broken corners (*then you filter on length only after reconstruction). If all goes well, you should be able to obtain a description like below, and from this infer the quadrilaterals by analysis of the edge/corner graph. (Mind the parasitic corners at the overlap of the shapes.)
UPDATE: This code was written before OP gave any example. It should work with a point cloud. It cannot find "almost-parallelograms", though. A naive approach would be to calculate (dx, dy) for every pair of points and save them in a dict. The values of the dict is a list of points pairs. If there is more than 1 pair, every combination of pairs will form a parallelogram. It's not efficient (O(n**2)) but still doable with 2300 points. It's also much more efficient than simply testing every 4-tuple of points. Here's a quick and dirty implementation: from random import randint, random from collections import defaultdict import matplotlib.pyplot as plt import matplotlib.patches as patches # N = 2300 # width = 3000 # height = 2000 N = 180 width = 3000 height = 2000 points = [(randint(0, width), randint(0, height)) for _ in range(N)] points = list(set(points)) # unique points n = len(points) plt.scatter(*zip(*points), linewidth=0.001) vectors = defaultdict(list) for i in range(n): x1, y1 = points[i] for j in range(i + 1, n): x2, y2 = points[j] vectors[(x2 - x1, y2 - y1)].append((i, j)) ax = plt.gca() for vector, pairs in vectors.items(): if len(pairs) > 1: # TODO: Consider every combination if len(pairs) > 2 a, b, c, d = points[pairs[0][0]], points[pairs[0][1]], points[pairs[1][1]], points[pairs[1][0]] ax.add_patch(patches.Polygon(xy=[a, b, c, d], fill=False, color=[random(), random(), random()])) plt.show() Here's the output with 180 points in a 3000 * 2000 grid: With 2300 points, you might find a lot of parallelograms.
Finding edge from 2d points Python
I have several 2d sets of scattered data that I would like to find the edges of. Some edges may be open lines, others may be polygons. For example, here is one plot that has an open edge that I would like to be able to keep. I would actually like to create a polygon from the open edges so I can use point_in_poly to check if another point lies inside. The points that would close the polygon are the boundaries of my plot area, btw. Any ideas on where to get started? EDIT: Here is what I have already tried: KernelDensity from sklearn. The edges point density varies significantly enough to not be entirely distinguishable from the bulk of the points. kde = KernelDensity() kde.fit(my_data) dens = np.exp(kde.score_samples(ds)) dmax = dens.max() dens_mask = (0.4 * dmax < dens) & (dens < 0.8 * dmax) ax.scatter(ds[dens_mask, 0], ds[dens_mask, 1], ds[dens_mask, 2], c=dens[dens_mask], depthshade=False, marker='o', edgecolors='none') Incidentally, the 'gap' in the left side of the color plot is the same one that is in the black and white plot above. I also am pretty sure that I could be using KDE better. For example, I would like to get the density for a much smaller volume, more like using radius_neighbors from sklearn's NearestNeighbors() ConvexHull from scipy. I tried removing points from semi-random data (for practice) while still keeping a point of interest (here, 0,0) inside the convex set. This wasn't terribly effective. I had no sophisticated way of exlcuding points from an iteration and only removed the ones that were used in the last convex hull. This code and accompanying image shows the first and last hull made while keeping the point of interest in the set. hull = ConvexHull(pts) contains = True while contains: temp_pts = np.delete(pts, hull.vertices, 0) temp_hull = ConvexHull(temp_pts) tp = path.Path(np.hstack((temp_pts[temp_hull.vertices, 0][np.newaxis].T, temp_pts[temp_hull.vertices, 1][np.newaxis].T))) if not tp.contains_point([0, 0]): contains = False hull = ConvexHull(pts) plt.plot(pts[hull.vertices, 0], pts[hull.vertices, 1]) else: pts = temp_pts plt.plot(pts[hull.vertices, 0], pts[hull.vertices, 1], 'r-') plt.show() Ideally the goal for convex hull would be to maximize the area inside the hull while keeping only the point of interest inside the set but I haven't been able to code this. KMeans() from sklearn.cluster. Using n=3 clusters I tried just run the class with default settings and got three horizontal groups of points. I haven't learned how to train the data to recognize points that form edges. Here is a piece of the model where the data points are coming from. The solid areas contain points while the voids do not. Here, and here are some other questions I have asked that show some more of what I have been looking at.
So I was able to do this in a roundabout way.
I used images of slices of the model in the xy plane generated from SolidWorks to distinguish the areas of interest.
If you see them, there are points in the corners of the picture that I placed in the model for reference at known distances. These points allowed me to determine the number of pixels per millimeter. From there, I mapped the points in my analysis set to pixels and checked the color of the pixel. If the pixel is white it is masked.
def mask_z_level(xi, yi, msk_img, x0=-14.3887, y0=5.564):
im = plt.imread(msk_img)
msk = np.zeros(xi.shape, dtype='bool')
pxmm = np.zeros((3, 2))
p = 0
for row in range(im.shape[0]):
for col in range(im.shape[1]):
if tuple(im[row, col]) == (1., 0., 0.):
pxmm[p] = (row, col)
p += 1
pxx = pxmm[1, 1] / 5.5
pxy = pxmm[2, 0] / 6.5
print(pxx, pxy)
for j in range(xi.shape[1]):
for i in range(xi.shape[0]):
x, y = xi[i, j], yi[i, j]
dx, dy = x - x0, y - y0
dpx = np.round(dx * pxx).astype('int')
dpy = -np.round(dy * pxy).astype('int')
if tuple(im[dpy, dpx]) == (1., 1., 1.):
msk[i, j] = True
return msk
Here is a plot showing the effects of the masking:
I am still fine tuning the borders but I have a very manageable task now that the mask is in largely complete. The reason being is that some mask points are incorrect resulting in banding.
Draw ellipses around points
I'm trying to draw ellipses around points of a group on a graph, with matplotlib. I would like to obtain something like this: A dataset for a group (the red one for example) could look like this: [[-23.88315146 -3.26328266] # first point [-25.94906669 -1.47440904] # second point [-26.52423229 -4.84947907]] # third point I can easily draw the points on a graph, but I encounter problems to draw the ellipses. The ellipses have diameters of 2 * standard deviation, and its center has the coordinates (x_mean, y_mean). The width of one ellipse equals the x standard deviation * 2. Its height equals the y standard deviation * 2. However, I don't know how to calculate the angle of the ellipses (you can see on the picture the ellipses are not perfectly vertical). Do you have an idea about how to do that ? Note: This question is a simplification of LDA problem (Linear Discriminant Analysis). I'm trying to simplify the problem to its most basic expression.
This is a well-studied problem. First take the convex hull of the set of points you wish to enclose. Then perform computations as described in the literature. I provide two sources below. "Smallest Enclosing Ellipses--An Exact and Generic Implementation in C++" (abstract link). Charles F. Van Loan. "Using the Ellipse to Fit and Enclose Data Points." (PDF download).
This has a lot more to do with mathematics than programming ;) Since you already have the dimensions and only want to find the angle, here is what I would do (based on my instinct): Try to find the line that best fits the given set of points (trendline), this is also called Linear Regression. There are several methods to do this but the Least Squares method is a relatively easy one (see below). Once you found the best fitting line, you could use the slope as your angle. Least Squares Linear Regression The least squares linear regression method is used to find the slope of the trendline, exactly what we want. Here is a video explaining how it works Let's assume you have a data set: data = [(x1, y1), (x2, y2), ...] Using the least square method, your slope would be: # I see in your example that you already have x_mean and y_mean # No need to calculate them again, skip the two following lines # and use your values in the rest of the example avg_x = sum(element[0] for element in data)/len(data) avg_y = sum(element[1] for element in data)/len(data) x_diff = [element[0] - avg_x for element in data] y_diff = [element[1] - avg_y for element in data] x_diff_squared = [element**2 for element in x_diff] slope = sum(x * y for x,y in zip(x_diff, y_diff)) / sum(x_diff_squared) Once you have that, you are almost done. The slope is equal to the tangent of the angle slope = tan(angle) Use python's math module angle = math.atan(slope) this will return the angle in radians. If you want it in degrees you have to convert it using math.degrees(angle) Combine this with the dimensions and position you already have and you got yourself an ellipse ;) This is how I would solve this particular problem, but there are probably a thousand different methods that would have worked too and may eventually be better (and more complex) than what I propose.
I wrote a simple function to implement Mathieu David's solution. I'm sure there are many ways to do this, but this worked for my application. def get_ellipse_params(self, points): ''' Calculate the parameters needed to graph an ellipse around a cluster of points in 2D. Calculate the height, width and angle of an ellipse to enclose the points in a cluster. Calculate the width by finding the maximum distance between the x-coordinates of points in the cluster, and the height by finding the maximum distance between the y-coordinates in the cluster. Multiple both by a scale factor to give padding around the points when constructing the ellipse. Calculate the angle by taking the inverse tangent of the gradient of the regression line. Note that tangent solutions repeat every 180 degrees, and so to ensure the correct solution has been found for plotting, add a correction factor of +/- 90 degrees if the magnitude of the angle exceeds 45 degrees. Args: points (ndarray): The points in a cluster to enclose with an ellipse, containing n ndarray elements representing each point, each with d elements representing the coordinates for the point. Returns: width (float): The width of the ellipse. height (float): The height of the ellipse. angle (float): The angle of the ellipse in degrees. ''' if points.ndim == 1: width, height, angle = 0.1, 0.1, 0 return width, height, angle else: SCALE = 2.5 width = np.amax(points[:,0]) - np.amin(points[:,0]) height = np.amax(points[:,1]) - np.amin(points[:,1]) # Calculate angle x_reg, y_reg = [[p[0]] for p in points], [[p[1]] for p in points] grad = LinearRegression().fit(x_reg, y_reg).coef_[0][0] angle = np.degrees(np.arctan(grad)) # Account for multiple solutions of arctan if angle < -45: angle += 90 elif angle > 45: angle -= 90 return width*SCALE, height*SCALE, angle
Generate random points on a surface of the cylinder
I want to generate random points on the surface of cylinder such that distance between the points fall in a range of 230 and 250. I used the following code to generate random points on surface of cylinder: import random,math H=300 R=20 s=random.random() #theta = random.random()*2*math.pi for i in range(0,300): theta = random.random()*2*math.pi z = random.random()*H r=math.sqrt(s)*R x=r*math.cos(theta) y=r*math.sin(theta) z=z print 'C' , x,y,z How can I generate random points such that they fall with in the range(on the surfaceof cylinder)?
This is not a complete solution, but an insight that should help. If you "unroll" the surface of the cylinder into a rectangle of width w=2*pi*r and height h, the task of finding distance between points is simplified. You have not explained how to measure "distance along the surface" between points on the top of the cylinder and the side- this is a slightly tricky bit of geometry. As for computing the distance along the surface when we created an artificial "seam", just use both (x1-x2) and (w -x1+x2) - whichever gives the shorter distance is the one you want. I do think that #VincentNivoliers' suggestion to use Poisson disk sampling is very good, but with the constraints of h=300 and r=20 you will get terrible results no matter what.
The basic way of creating a set of random points with constraints in the positions between them, is to have a function that modulates the probability of points being placed at a certain location. this function starts out being a constant, and whenever a point is placed, forbidden areas surrounding the point are set to zero. That is difficult to do with continuous variables, but reasonably easy if you discretize your problem. The other thing to be careful about is the being on a cylinder part. It may be easier to think of it as random points on a rectangular area that repeats periodically. This can be handled in two different ways: the simplest is to take into consideration not only the rectangular tile where you are placing the points, but also its neighbouring ones. Whenever you place a point in your main tile, you also place one in the neighboring ones and compute their effect on the probability function inside your tile. A more sophisticated approach considers the probability function then convolution of a kernel that encodes forbidden areas, with a sum of delta functions, corresponding to the points already placed. If this is computed using FFTs, the periodicity is anatural by product. The first approach can be coded as follows: from __future__ import division import numpy as np r, h = 20, 300 w = 2*np.pi*r int_w = int(np.rint(w)) mult = 10 pdf = np.ones((h*mult, int_w*mult), np.bool) points = [] min_d, max_d = 230, 250 available_locs = pdf.sum() while available_locs: new_idx = np.random.randint(available_locs) new_idx = np.nonzero(pdf.ravel())[0][new_idx] new_point = np.array(np.unravel_index(new_idx, pdf.shape)) points += [new_point] min_mask = np.ones_like(pdf) if max_d is not None: max_mask = np.zeros_like(pdf) else: max_mask = True for p in [new_point - [0, int_w*mult], new_point +[0, int_w*mult], new_point]: rows = ((np.arange(pdf.shape[0]) - p[0]) / mult)**2 cols = ((np.arange(pdf.shape[1]) - p[1]) * 2*np.pi*r/int_w/mult)**2 dist2 = rows[:, None] + cols[None, :] min_mask &= dist2 > min_d*min_d if max_d is not None: max_mask |= dist2 < max_d*max_d pdf &= min_mask & max_mask available_locs = pdf.sum() points = np.array(points) / [mult, mult*int_w/(2*np.pi*r)] If you run it with your values, the output is usually just one or two points, as the large minimum distance forbids all others. but if you run it with more reasonable values, e.g. min_d, max_d = 50, 200 Here's how the probability function looks after placing each of the first 5 points: Note that the points are returned as pairs of coordinates, the first being the height, the second the distance along the cylinder's circumference.