We Keep Coding

Several unintended lines when attempting to create voronoi diagram given scatter point locations

I'm trying to create a Voronoi diagram given a set of scatterplot points. However, several "extra unintended lines" appear to get calculated in the process. Some of these "extra" lines appear to be the infinite edges getting incorrectly calculated. But others are appearing randomly in the middle of the plot as well. How can I only create an extra edge when it's needed/required to connect a polygon to the edge of the plot (e.g. plot boundaries)?
My graph outer boundaries are:
boundaries = np.array([[0, -2], [0, 69], [105, 69], [105, -2], [0, -2]])
Here's the section dealing with the voronoi diagram creation:
def voronoi_polygons(voronoi, diameter):
centroid = voronoi.points.mean(axis=0)
ridge_direction = defaultdict(list)
for (p, q), rv in zip(voronoi.ridge_points, voronoi.ridge_vertices):
u, v = sorted(rv)
if u == -1:
t = voronoi.points[q] - voronoi.points[p] # tangent
n = np.array([-t[1], t[0]]) / np.linalg.norm(t) # normal
midpoint = voronoi.points[[p, q]].mean(axis=0)
direction = np.sign(np.dot(midpoint - centroid, n)) * n
ridge_direction[p, v].append(direction)
ridge_direction[q, v].append(direction)
for i, r in enumerate(voronoi.point_region):
region = voronoi.regions[r]
if -1 not in region:
# Finite region.
yield Polygon(voronoi.vertices[region])
continue
# Infinite region.
inf = region.index(-1) # Index of vertex at infinity.
j = region[(inf - 1) % len(region)] # Index of previous vertex.
k = region[(inf + 1) % len(region)] # Index of next vertex.
if j == k:
# Region has one Voronoi vertex with two ridges.
dir_j, dir_k = ridge_direction[i, j]
else:
# Region has two Voronoi vertices, each with one ridge.
dir_j, = ridge_direction[i, j]
dir_k, = ridge_direction[i, k]
# Length of ridges needed for the extra edge to lie at least
# 'diameter' away from all Voronoi vertices.
length = 2 * diameter / np.linalg.norm(dir_j + dir_k)
# Polygon consists of finite part plus an extra edge.
finite_part = voronoi.vertices[region[inf + 1:] + region[:inf]]
extra_edge = [voronoi.vertices[j] + dir_j * length,
voronoi.vertices[k] + dir_k * length]
combined_finite_edge = np.concatenate((finite_part, extra_edge))
poly = Polygon(combined_finite_edge)
yield poly
Here are the points being used:
['52.629' '24.28099822998047']
['68.425' '46.077999114990234']
['60.409' '36.7140007019043']
['72.442' '28.762001037597656']
['52.993' '43.51799964904785']
['59.924' '16.972000122070312']
['61.101' '55.74899959564209']
['68.9' '13.248001098632812']
['61.323' '29.0260009765625']
['45.283' '36.97500038146973']
['52.425' '19.132999420166016']
['37.739' '28.042999267578125']
['48.972' '2.3539962768554688']
['33.865' '30.240001678466797']
['52.34' '64.94799995422363']
['52.394' '45.391000747680664']
['52.458' '34.79800033569336']
['31.353' '43.14500045776367']
['38.194' '39.24399948120117']
['98.745' '32.15999984741211']
['6.197' '32.606998443603516']

Most likely this is due to the errors associated with floating point arithmetic while computing the voronoi traingulation from your data (esp. the second column).
Assuming that, there is no single solution for such kinds of problems. I urge you to go through this page* of the Qhull manual and try iterating through those parameters in qhull_options before generating the voronoi object that you are inputting in the function. An example would be qhull_options='Qbb Qc Qz QJ'.
Other than that I doubt there is anything that could be modified in the function to avoid such a problem.
*This will take some time though. Just be patient.

Figured out what was wrong: after each polygon I needed to add a null x and y value or else it would attempt to 'stitch' one polygon to another, drawing an additional unintended line in order to do so. So the data should really look more like this:
GameTime,Half,ObjectType,JerseyNumber,X,Y,PlayerIDEvent,PlayerIDTracking,MatchIDEvent,Position,teamId,i_order,v_vor_x,v_vor_y
0.0,1,1,22,None,None,578478,794888,2257663,3,35179.0,0,22.79645297,6.20866756
0.0,1,1,22,None,None,578478,794888,2257663,3,35179.0,1,17.63464264,3.41230187
0.0,1,1,22,None,None,578478,794888,2257663,3,35179.0,2,20.27639318,34.29191902
0.0,1,1,22,None,None,578478,794888,2257663,3,35179.0,3,32.15600546,36.60432421
0.0,1,1,22,None,None,578478,794888,2257663,3,35179.0,4,38.34639812,33.62806739
0.0,1,1,22,None,None,578478,794888,2257663,3,35179.0,5,22.79645297,6.20866756
0.0,1,1,22,None,None,578478,794888,2257663,3,35179.0,5,nan,nan
0.0,1,1,22,33.865,30.240001678466797,578478,794888,2257663,3,35179.0,,,
0.0,1,0,92,None,None,369351,561593,2257663,1,32446.0,0,46.91696938,29.44801535
0.0,1,0,92,None,None,369351,561593,2257663,1,32446.0,1,55.37574848,29.5855499
0.0,1,0,92,None,None,369351,561593,2257663,1,32446.0,2,58.85876401,23.20381766
0.0,1,0,92,None,None,369351,561593,2257663,1,32446.0,3,57.17455086,21.5228301
0.0,1,0,92,None,None,369351,561593,2257663,1,32446.0,4,44.14237744,22.03925667
0.0,1,0,92,None,None,369351,561593,2257663,1,32446.0,5,45.85962774,28.83613332
0.0,1,0,92,None,None,369351,561593,2257663,1,32446.0,5,nan,nan
0.0,1,0,92,52.629,24.28099822998047,369351,561593,2257663,1,32446.0,,,
0.0,1,0,27,None,None,704169,704169,2257663,2,32446.0,0,65.56965667,33.4292025
0.0,1,0,27,None,None,704169,704169,2257663,2,32446.0,1,57.23303682,32.43809027
0.0,1,0,27,None,None,704169,704169,2257663,2,32446.0,2,55.65704152,38.97814049
0.0,1,0,27,None,None,704169,704169,2257663,2,32446.0,3,60.75304149,44.53251169
0.0,1,0,27,None,None,704169,704169,2257663,2,32446.0,4,65.14170295,40.77562188
0.0,1,0,27,None,None,704169,704169,2257663,2,32446.0,5,65.56965667,33.4292025
0.0,1,0,27,None,None,704169,704169,2257663,2,32446.0,5,nan,nan

How to create a polygon and check if given lat, lon are inside

I have a set of coordinates and want to create a polygon from it and after that, I'll take input lat & long and check if the given coordinates are inside or outside of the polygon.
I tried to plot polygon using Shapely and somewhat is is correct. My coordinates:
coords = [(48.9276684941938, 9.148899187374205),
(48.927881447105676, 9.148709214807226),
(48.928097614085175, 9.148527808307),
(48.92831656589233, 9.148354454524537),
(48.92853801299333, 9.14818847255271),
(48.92876304120666, 9.148030296534815),
(48.92899058574909, 9.147880813070733),
(48.929220004856425, 9.147737925539758),
(48.92945050690533, 9.147599646704602),
(48.92970963088016, 9.147448804345393),
(48.929969642221785, 9.147302124446165),
(48.930230552830835, 9.147158909183357),
(48.93049212225262, 9.147018600375391),
(48.931016778198384, 9.146744181554437),
(48.93154237676336, 9.146473988125043),
(48.9276684941938, 9.148899187374205),
(48.927881447105676, 9.148709214807226),
(48.928097614085175, 9.148527808307),
(48.92831656589233, 9.148354454524537),
(48.92853801299333, 9.14818847255271),
(48.92876304120666, 9.148030296534815),
(48.92899058574909, 9.147880813070733),
(48.929220004856425, 9.147737925539758),
(48.92945050690533, 9.147599646704602),
(48.92970963088016, 9.147448804345393),
(48.929969642221785, 9.147302124446165),
(48.930230552830835, 9.147158909183357),
(48.93049212225262, 9.147018600375391),
(48.931016778198384, 9.146744181554437),
(48.93154237676336, 9.146473988125043),
(48.9276684941938, 9.148899187374205),
(48.927881447105676, 9.148709214807226),
(48.928097614085175, 9.148527808307),
(48.92831656589233, 9.148354454524537),
(48.92853801299333, 9.14818847255271),
(48.92876304120666, 9.148030296534815),
(48.92899058574909, 9.147880813070733),
(48.929220004856425, 9.147737925539758),
(48.92945050690533, 9.147599646704602),
(48.92970963088016, 9.147448804345393),
(48.929969642221785, 9.147302124446165),
(48.930230552830835, 9.147158909183357),
(48.93049212225262, 9.147018600375391),
(48.931016778198384, 9.146744181554437),
(48.93154237676336, 9.146473988125043),
(48.9276684941938, 9.148899187374205),
(48.927881447105676, 9.148709214807226),
(48.928097614085175, 9.148527808307),
(48.92831656589233, 9.148354454524537),
(48.92853801299333, 9.14818847255271),
(48.92876304120666, 9.148030296534815),
(48.92899058574909, 9.147880813070733),
(48.929220004856425, 9.147737925539758),
(48.92945050690533, 9.147599646704602),
(48.92970963088016, 9.147448804345393),
(48.929969642221785, 9.147302124446165),
(48.930230552830835, 9.147158909183357),
(48.93049212225262, 9.147018600375391),
(48.931016778198384, 9.146744181554437),
(48.93154237676336, 9.146473988125043),
(48.92770214317435, 9.14898338362773),
(48.92791356880573, 9.148794765833149),
(48.92812829266924, 9.148614547378457),
(48.92834590048043, 9.14844222176487),
(48.928566113985696, 9.148277117808037),
(48.92878946335235, 9.148120067839535),
(48.929015676775194, 9.147971398151217),
(48.92924412032041, 9.147829052791057),
(48.92947400781438, 9.147691074306037),
(48.929732441980185, 9.147540555874041),
(48.92999185500086, 9.147394137713535),
(48.93025226040877, 9.147251128456126),
(48.93051341950752, 9.147110975575266),
(48.931037543721, 9.146836738790197),
(48.931563000656055, 9.146566582017199),
(48.92770214317435, 9.14898338362773),
(48.92791356880573, 9.148794765833149),
(48.92812829266924, 9.148614547378457),
(48.92834590048043, 9.14844222176487),
(48.928566113985696, 9.148277117808037),
(48.92878946335235, 9.148120067839535),
(48.929015676775194, 9.147971398151217),
(48.92924412032041, 9.147829052791057),
(48.92947400781438, 9.147691074306037),
(48.929732441980185, 9.147540555874041),
(48.92999185500086, 9.147394137713535),
(48.93025226040877, 9.147251128456126),
(48.93051341950752, 9.147110975575266),
(48.931037543721, 9.146836738790197),
(48.931563000656055, 9.146566582017199),
(48.92770214317435, 9.14898338362773),
(48.92791356880573, 9.148794765833149),
(48.92812829266924, 9.148614547378457),
(48.92834590048043, 9.14844222176487),
(48.928566113985696, 9.148277117808037),
(48.92878946335235, 9.148120067839535),
(48.929015676775194, 9.147971398151217),
(48.92924412032041, 9.147829052791057),
(48.92947400781438, 9.147691074306037),
(48.929732441980185, 9.147540555874041),
(48.92999185500086, 9.147394137713535),
(48.93025226040877, 9.147251128456126),
(48.93051341950752, 9.147110975575266),
(48.931037543721, 9.146836738790197),
(48.931563000656055, 9.146566582017199),
(48.92770214317435, 9.14898338362773),
(48.92791356880573, 9.148794765833149),
(48.92812829266924, 9.148614547378457),
(48.92834590048043, 9.14844222176487),
(48.928566113985696, 9.148277117808037),
(48.92878946335235, 9.148120067839535),
(48.929015676775194, 9.147971398151217),
(48.92924412032041, 9.147829052791057),
(48.92947400781438, 9.147691074306037),
(48.929732441980185, 9.147540555874041),
(48.92999185500086, 9.147394137713535),
(48.93025226040877, 9.147251128456126),
(48.93051341950752, 9.147110975575266),
(48.931037543721, 9.146836738790197),
(48.931563000656055, 9.146566582017199)]
Code:
from shapely.geometry import Point, Polygon
poly = Polygon(coords)
poly
Output:
I want to pass coordinates as input and return if coordinates are inside the given coordinates or not.
Expected ouput:

You didn't specify whether your polygon coordinates are ordered or not. It appears, from your example, that they are not. If not, you might wish to create a polygon using object.convex_hull rather than the polygon constructor:
coords = [
(48.9276684941938, 9.148899187374205),
...
]
poly = MultiPoint(coords).convex_hull
Beyond that, it seems like you're only missing the use of object.intersects() to check if a given point is within* your polygon:
x = 48.929234
y = 9.147870
Point(x, y).intersects(poly)
Returns True
*For the common understanding of "within". In technical terms, "within" would exclude points on the boundary of your polygon, whereas "intersects" includes them. If you don't want points on the boundary (such as the points in your original coords) to return True, substitute object.within() for object.intersects().

Python homogeneous to inhomogeneous plot line

I found an article which is about epipolar geometry.
I calculated the fundamental matrix. Now Iam trying to find the line on which a corresponding point lays as described in the article:
I calculated the line which is in homogeneous coordinates. How could I plot this line into the picture like in the example? I thought about transforming the line from homogeneous to inhomogeneous coordinates. I think this can be achieved by dividing x and y by z
For example, homogeneous:
x=0.0295
y=0.9996
z=-265.1531
to inhomogeneous:
x=0.0295/-265.1531
y=0.9996/-265.1531
so:
x=-0.0001112564778612809
y=0.0037698974667842843
Those numbers seem wrong to me, because theyre so small. Is this the correct approach?
How could I plot my result into an image?

the x, y and z you have are the parameters of the "Epipolar Lines" equation that appear under the "line in the image" formula in the slides, but labelled a, b and c respectively, i.e:
au + bv + c = 0
solutions to this are points on the line. e.g. in Python I'd define a as some points on the picture's x-axis, and solve for b:
import numpy as np
F = np.array([
[-0.00310695, -0.0025646, 2.96584],
[-0.028094, -0.00771621, 56.3813],
[13.1905, -29.2007, -9999.79],
])
p_l = np.array([
[343.53],
[221.70],
[ 1.0],
])
lt = F # p_l
# if you want to normalise
lt /= np.sqrt(sum(lt[:2] ** 2))
# should give your values [0.0295, 0.9996, -265.2]
print(lt)
a, b, c = lt.ravel()
x = np.array([0, 400])
y = -(x*a + c) / b
and then just draw a line between these points

Speed up Python cKDTree

I currently have a function that I created that connects the blue dots with its (at maximum) 3 nearest neighbors within a pixel range of 55. The vertices_xy_list is an extremely large list or points (nested list) of about 5000-10000 pairs.
Example of vertices_xy_list:
[[3673.3333333333335, 2483.3333333333335],
[3718.6666666666665, 2489.0],
[3797.6666666666665, 2463.0],
[3750.3333333333335, 2456.6666666666665],...]
I currently have written this calculate_draw_vertice_lines() function that uses a CKDTree inside of a While loop to find all points within 55 pixels and then connect them each with a green line.
It can be seen that this would become exponentially slower as the list gets longer. Is there any method to speed up this function significantly? Such as vectorizing operations?
def calculate_draw_vertice_lines():
global vertices_xy_list
global cell_wall_lengths
global list_of_lines_references
index = 0
while True:
if (len(vertices_xy_list) == 1):
break
point_tree = spatial.cKDTree(vertices_xy_list)
index_of_closest_points = point_tree.query_ball_point(vertices_xy_list[index], 55)
index_of_closest_points.remove(index)
for stuff in index_of_closest_points:
list_of_lines_references.append(plt.plot([vertices_xy_list[index][0],vertices_xy_list[stuff][0]] , [vertices_xy_list[index][1],vertices_xy_list[stuff][1]], color = 'green'))
wall_length = math.sqrt( (vertices_xy_list[index][0] - vertices_xy_list[stuff][0])**2 + (vertices_xy_list[index][1] - vertices_xy_list[stuff][1])**2 )
cell_wall_lengths.append(wall_length)
del vertices_xy_list[index]
fig.canvas.draw()

If I understand the logic of selecting the green lines correctly, there is no need to create a KDTree at each iteration. For each pair (p1, p2) of blue points, the line should be drawn if and only if the following hold:
p1 is one of 3 closest neighbors of p2.
p2 is one of 3 closest neighbors of p1.
dist(p1, p2) < 55.
You can create the KDTree once and create a list of green lines efficiently. Here is part of the implementation that returns a list of pairs of indices for points between which the green lines need to be drawn. The runtime is about 0.5 seconds on my machine for 10,000 points.
import numpy as np
from scipy import spatial
data = np.random.randint(0, 1000, size=(10_000, 2))
def get_green_lines(data):
tree = spatial.cKDTree(data)
# each key in g points to indices of 3 nearest blue points
g = {i: set(tree.query(data[i,:], 4)[-1][1:]) for i in range(data.shape[0])}
green_lines = list()
for node, candidates in g.items():
for node2 in candidates:
if node2 < node:
# avoid double-counting
continue
if node in g[node2] and spatial.distance.euclidean(data[node,:], data[node2,:]) < 55:
green_lines.append((node, node2))
return green_lines
You can proceed to plot green lines as follows:
green_lines = get_green_lines(data)
fig, ax = plt.subplots()
ax.scatter(data[:, 0], data[:, 1], s=1)
from matplotlib import collections as mc
lines = [[data[i], data[j]] for i, j in green_lines]
line_collection = mc.LineCollection(lines, color='green')
ax.add_collection(line_collection)
Example output:

How to do a second interpolation in python

I did my first interpolation with numpy.polyfit() and numpy.polyval() for 50 longitude values for a full satellite orbit.
Now, I just want to look at a window of 0-4.5 degrees longitude and do a second interpolation so that I have 6,000 points for longitude in the window.
I need to use the equation/curve from the first interpolation to create the second one because there is only one point in the window range. I'm not sure how to do the second interpolation.
Inputs:
lon = [-109.73105744378498, -104.28690174554579, -99.2435132929552, -94.48533149079628, -89.91054414962821, -85.42671400689177, -80.94616150449806, -76.38135021210172, -71.6402674905218, -66.62178379632216, -61.21120467960157, -55.27684029674759, -48.66970878028004, -41.23083703244677, -32.813881865289346, -23.332386757370532, -12.832819226213942, -1.5659455609661785, 10.008077792630402, 21.33116444634303, 31.92601575632583, 41.51883213364072, 50.04498630545507, 57.58103957109249, 64.26993028992476, 70.2708323505337, 75.73441871754586, 80.7944079829813, 85.56734813043659, 90.1558676264546, 94.65309120129724, 99.14730128118617, 103.72658922048785, 108.48349841714494, 113.51966824008079, 118.95024882101737, 124.9072309203375, 131.5395221402974, 139.00523971191907, 147.44847902856114, 156.95146022590976, 167.46163867248032, 178.72228750873975, -169.72898181991064, -158.44642409799974, -147.8993300787564, -138.35373014113995, -129.86955508919888, -122.36868103811106, -115.70852432245486]
myOrbitJ2000Time = [ 20027712., 20027713., 20027714., 20027715., 20027716.,
20027717., 20027718., 20027719., 20027720., 20027721.,
20027722., 20027723., 20027724., 20027725., 20027726.,
20027727., 20027728., 20027729., 20027730., 20027731.,
20027732., 20027733., 20027734., 20027735., 20027736.,
20027737., 20027738., 20027739., 20027740., 20027741.,
20027742., 20027743., 20027744., 20027745., 20027746.,
20027747., 20027748., 20027749., 20027750., 20027751.,
20027752., 20027753., 20027754., 20027755., 20027756.,
20027757., 20027758., 20027759., 20027760., 20027761.]
Code:
deg = 30 #polynomial degree for fit
fittime = myOrbitJ2000Time - myOrbitJ2000Time[0]
'Longitude Interpolation'
fitLon = np.polyfit(fittime, lon, deg) #gets fit coefficients
polyval_lon = np.polyval(fitLon,fittime) #interp.s to get actual values
'Get Longitude values for a window of 0-4.5 deg Longitude'
lonwindow =[]
for i in range(len(polyval_lon)):
if 0 < polyval_lon[i] < 4.5: # get lon vals in window
lonwindow.append(polyval_lon[i]) #append lon vals
lonwindow = np.array(lonwindow)

First, generate the polynomial fit coefficients using the old time (x-axis) values, and interpolated longitude (y-axis) values.
import numpy as np
import matplotlib.pyplot as plt
poly_deg = 3 #degree of the polynomial fit
polynomial_fit_coeff = np.polyfit(original_times, interp_lon, poly_deg)
Next, use np.linspace() to generate arbitrary time values based on the number of desire points in the window.
start = 0
stop = 4
num_points = 6000
arbitrary_time = np.linspace(start, stop, num_points)
Finally, use the fit coefficients and the arbitrary time to get the actual interpolated longitude (y-axis) values and plot.
lon_intrp_2 = np.polyval(polynomial_fit_coeff, arbitrary_time)
plt.plot(arbitrary_time, lon_intrp_2, 'r') #interpolated window as a red curve
plt.plot(myOrbitJ2000Time, lon, '.') #original data plotted as points