def _genBasicMesh(self):
x = numpy.array(numpy.random.uniform(0, 2.0 * ogre.Math.PI, self.numPts))
y = numpy.array(numpy.random.uniform(0, ogre.Math.PI, self.numPts))
cens, edg, tri, neig = triang.delaunay(x, y)
self.x = x
self.y = y
self.tris = tri
def generate(n, k, outfile):
# Delaunay triangulation of random points in R^2
print 'Generating %d-planar graph with %d tokens.' % (n, k)
x, y = numpy.array(numpy.random.standard_normal((2, n)))
c, E, tris, ngbr = tri.delaunay(x, y)
# Choose k unique vertices to have tokens
token_verts = random.sample(range(n), k)
print "Writing to %s" % (outfile)
with open(outfile, "wb") as f:
writer = csv.writer(f, delimiter=' ')
# Write the graph details
writer.writerow([n, len(E), k])
# Write the adjecency list
for edge in E:
writer.writerow(edge)
# Write which vertices are token vertices
for v in token_verts:
writer.writerow([v])
f.close()
def generate(n, k, outfile):
# Delaunay triangulation of random points in R^2
print 'Generating %d-planar graph with %d tokens.' % (n, k)
x,y = numpy.array(numpy.random.standard_normal((2,n)))
c,E,tris,ngbr = tri.delaunay(x,y)
# Choose k unique vertices to have tokens
token_verts = random.sample(range(n), k)
print "Writing to %s" % (outfile)
with open(outfile, "wb") as f:
writer = csv.writer(f, delimiter=' ')
# Write the graph details
writer.writerow([n, len(E), k])
# Write the adjecency list
for edge in E:
writer.writerow(edge)
# Write which vertices are token vertices
for v in token_verts:
writer.writerow([v])
f.close()
def triangleImage(link, nom, s):
a = seuil(imageio.imread(link), s)
a = py.rot90(a, 3)
xBis, yBis = transforme(a.tolist())
xBis, yBis = np.array(xBis), np.array(yBis)
cens, edg, tri, neig = triang.delaunay(xBis, yBis)
taille = len(a.tolist())
l = taille / 15
b = 0
py.figure()
for t in tri:
# t[0], t[1], t[2] are the points indexes of the triangle
d1, d2, d3 = d(xBis[t[0]], yBis[t[0]], xBis[t[1]],
yBis[t[1]]), d(xBis[t[1]], yBis[t[1]], xBis[t[2]],
yBis[t[2]]), d(xBis[t[2]], yBis[t[2]],
xBis[t[0]], yBis[t[0]])
if (d1 < l and d2 < l and d3 < l):
#t_i = [t[0], t[1], t[2], t[0]]
t_i = [t[0], t[1], t[2], t[0]]
if (b):
py.fill(xBis[t_i], yBis[t_i], "black")
b = 0
else:
b = 1
py.savefig(nom)
def interp(self,xt,yt,zorigt):
x=xt[:,zorigt>=0.0]
y=yt[:,zorigt>=0.0]
z=zorigt[:,zorigt>=0.0]
cens,edg,tri,neig = D.delaunay(x,y)
if 0:
#plot triangulation
for t in tri:
# t[0], t[1], t[2] are the points indexes of the triangle
t_i = [t[0], t[1], t[2], t[0]]
pylab.plot(x[t_i],y[t_i])
#pylab.plot(x,y,'o')
#pylab.show()
tri = D.Triangulation(x,y)
interp = tri.nn_interpolator(z)
xi=N.copy(x)
yi=N.copy(y)
xi=N.concatenate((xi,self.line_x))
yi=N.concatenate((yi,self.line_y))
zi = interp(xi,yi)
mylocator=locator(xi,yi)
inds=mylocator.inside(self.line_x,self.line_y)
outxi=xi[inds.astype(int)]
outyi=yi[inds.astype(int)]
outzi=zi[inds.astype(int)]
return outxi,outyi,outzi
def plot_voronoi(self, ax=None, show_latlon=True):
if ax is None:
fig = pl.figure()
ax = fig.add_subplot(111)
# calculate half size position of each edge and
# do delaunay interpolation again. This
# gives then the Voronoi diagram
if not self._interpolated:
self._delaunay_triangulation()
lons = []
lats = []
for e in self.edg:
# half way position
plon = self.lon[e[0]] + 0.5 * (self.lon[e[1]] - self.lon[e[0]])
plat = self.lat[e[0]] + 0.5 * (self.lat[e[1]] - self.lat[e[0]])
lons.append(plon)
lats.append(plat)
lons = np.asarray(lons)
lats = np.asarray(lats)
cens, edg, tris, neig = triang.delaunay(lons, lats)
self._do_delaunay_plot(tris, lons, lats, ax)
ax.plot(lons, lats, marker='x', linestyle='None', color='green')
if show_latlon:
ax.plot(self.lon, self.lat, 'o', color='black')
def triangulate( datadict ):
del datadict['BEAV']
del datadict['SLAP']
del datadict['HOOK']
del datadict['GOOD']
del datadict['BOIS']
del datadict['KENT']
if 'WALT' in datadict.keys():
datadict['WAL2'] = datadict['WALT']
del datadict['WALT']
stnfile = np.load('mesonet.npz')
m = P( stationdict=stnfile, area='OK' ).proj()
gridX = []
gridY = []
stations = []
for stn in datadict.keys():
if np.isnan( datadict[ stn ][ 'UMET' ] ) == True or np.isnan( datadict[ stn ][ 'VMET' ] ) == True:
del datadict[ stn ]
continue
else:
gridX.append( stnfile[ stn ][0] )
gridY.append( stnfile[ stn ][1] )
stations.append( stn )
x,y = m( gridX, gridY )
x = np.array( x )
y = np.array( y )
centers,edges,tri,neighbors = md.delaunay( x, y )
return ( centers, edges, tri, neighbors, stations, x, y )
def get_mst_score(cls, x, y):
''' Use the size of second largest connected component
when building MST for Delaunay triangulation as score
:param x: x-coordinates of all data
:param y: y-coordinates of all data
:return:
'''
# Do Delaunay triangulation, use length of the edges as weight
cens, edg, tri, neig = triang.delaunay(x, y)
edges = {}
for t in tri:
if not (t[0], t[1]) in edges.items():
edges[(t[0], t[1])] = distance(x, y, t[0], t[1])
if not (t[1], t[2]) in edges.items():
edges[(t[1], t[2])] = distance(x, y, t[1], t[2])
if not (t[2], t[0]) in edges.items():
edges[(t[2], t[0])] = distance(x, y, t[2], t[0])
# Use Kruskal to build a minimum spanning tree
ordered_edges = sorted(edges.items(), key=operator.itemgetter(1))
mst_edges = []
lengths = []
i = len(x)
uf = UnionFind()
for ((t1, t2), length) in ordered_edges:
if MinSpanTree.is_connected(mst_edges, t1, t2):
continue
mst_edges.append((t1, t2))
lengths.append(length)
uf.union(t1, t2)
i -= 1
if length > lengths[0] * 4:
break
return uf.second_largest_size()
def calc_triangulation(self): cens,edg,tri,neig = triang.delaunay(self.xList,self.yList) tri = numpy.array([tri]) tri = tri[0] for t in tri: # t[0], t[1], t[2] are the points indexes of the triangle #Now we want to extract a complete triangle from each index t_i = [t[0], t[1], t[2], t[0]] x = [self.xList[i] for i in t_i] y = [self.yList[i] for i in t_i] z = [self.zList[i] for i in t_i] colourhex = [self.colourList[i] for i in t_i] #Retrieve only the first item of the colour value since all the 3 points have same colour colourhex = colourhex[:1] #Convert to string so we can add to a new list and extract later on colourhex = "".join(colourhex) #Convert string values of triangle to int x = [int(i) for i in x] y = [int(i) for i in y] z = [int(i) for i in z] #For performance sake, we reuse the xList, yList, zList and colourList(holding original CSV data) instead of creating and using a new lists self.xList.append(x) self.yList.append(y) self.zList.append(z) self.colourList.append(colourhex) #Update the content of xList,yList,zList and colourList to the new data needed for triangulation self.xList[:self.len_xList] = [] #Remove all X values original appended from the CSV file self.yList[:self.len_yList] = [] #Remove all Y values original appended from the CSV file self.zList[:self.len_zList] = [] #Remove all Z values original appended from the CSV file self.colourList[:self.len_colourList] = [] #Remove all hex values original appended from the CSV
def plot_voronoi(self, ax=None, show_latlon=True):
if ax is None:
fig = pl.figure()
ax = fig.add_subplot(111)
# calculate half size position of each edge and
# do delaunay interpolation again. This
# gives then the Voronoi diagram
if not self._interpolated:
self._delaunay_triangulation()
lons = []
lats = []
for e in self.edg:
# half way position
plon = self.lon[e[0]] + 0.5 * (self.lon[e[1]] - self.lon[e[0]])
plat = self.lat[e[0]] + 0.5 * (self.lat[e[1]] - self.lat[e[0]])
lons.append(plon)
lats.append(plat)
lons = np.asarray(lons)
lats = np.asarray(lats)
cens, edg, tris, neig = triang.delaunay(lons, lats)
self._do_delaunay_plot(tris, lons, lats, ax)
ax.plot(lons, lats, marker='x', linestyle='None', color='green')
if show_latlon:
ax.plot(self.lon, self.lat, 'o', color='black')
def __init__(self, boundary_callable=CircleBoundary(), sample_count=20):
'''
:param boundary_callable: a callable we can sample sample_count times in [0,1)
:param sample_count: how many points to sample from boundary_callable
if boundary function is of that fancy cas package we could sample
weighed by the absolute value of the gradient. otherwise sampling is uniform
'''
super(PrescribedBoundaryGrid, self).__init__()
fac = 1 / sample_count
self._px = np.array(
[boundary_callable(p * fac)[0] for p in range(sample_count)])
self._py = np.array(
[boundary_callable(p * fac)[1] for p in range(sample_count)])
self._vertices = zip(self._px, self._py)
self._centers, _, triangles, self._neighbours_ids = delaunay(
self._px, self._py)
self._edges = []
for ids in triangles:
self._edges.extend([
self.Edge(ids[i[0]], ids[i[1]])
for i in [(0, 1), (1, 2), (2, 0)]
])
self._triangles = [self.Triangle(x, self._edges) for x in triangles]
self._sizes = {
0: len(self._triangles),
1: len(self._edges),
2: len(self._px)
}
self.__subentities = list(xrange(self.dim + 1))
self.__subentities[2] = np.array([c.vertices for c in self._triangles],
dtype='int32')
self.__subentities[1] = np.array([c.edges for c in self._triangles],
dtype='int32')
self.__subentities[0] = np.arange(len(self._triangles),
dtype='int32')[:, np.newaxis]
self.__embed_A = np.empty((self._sizes[0], 2, 2))
self.__embed_B = np.empty((self._sizes[0], 2))
for i, triangle in enumerate(self._triangles):
x = [(self._px[triangle.vertices[j]],
self._py[triangle.vertices[j]]) for j in (0, 1, 2)]
W = np.array([[x[0][0], x[0][1], 0, 0, 1, 0],
[0, 0, x[0][0], x[0][1], 0, 1],
[x[1][0], x[1][1], 0, 0, 1, 0],
[0, 0, x[1][0], x[1][1], 0, 1],
[x[2][0], x[2][1], 0, 0, 1, 0],
[0, 0, x[2][0], x[2][1], 0, 1]])
K = np.array([0, 0, 0, 1, 1, 1])
try:
R = np.linalg.solve(W, K)
except np.linalg.linalg.LinAlgError, e:
import pprint
self.logger.critical(pprint.pformat(K))
self.logger.critical(pprint.pformat(W))
self.logger.error(pprint.pformat(self._vertices))
raise e
self.__embed_A[i] = [[R[0], R[1]], [R[2], R[3]]]
self.__embed_B[i] = [R[4], R[5]]
def find_minimum_weight_matching(self):
""" finds a minimum weight perfect matching"""
print "computing delaunay of odd_deg_nodes"
circumcenters, edges, tri_points, tri_neighbors = triang.delaunay(
self.x[self.odd_deg_nodes], self.y[self.odd_deg_nodes])
o = nx.Graph()
o.dist_func = lambda i, j: -self.euclidean_dist(i, j)
for i, j in edges:
mi = self.odd_deg_nodes[i]
mj = self.odd_deg_nodes[j]
o.add_edge(mi, mj, weight=o.dist_func(mi, mj))
self.o = o
print '#edges:', len(edges), '#nodes:', len(o.nodes()), len(
self.odd_deg_nodes)
print "computing minimum matching"
t1 = time.time()
mates = max_weight_matching(o, maxcardinality=True)
t2 = time.time()
print "took %s" % (t2 - t1)
m = nx.Graph()
for i in mates.keys():
m.add_edge(i, mates[i], weight=self.g.dist_func(i, mates[i]))
print '#edges:', len(m.edges()), '#nodes:', len(m.nodes())
self.plot_edges(m.edges(), 'r-', 2)
self.m = m
def triangulation(cls, x, y):
cens, edg, tri, neig = triang.delaunay(x, y)
for t in tri:
x_line = [x[t[0]], x[t[1]], x[t[2]], x[t[0]]]
y_line = [y[t[0]], y[t[1]], y[t[2]], y[t[0]]]
plt.plot(x_line, y_line)
plt.plot(x, y, '.')
plt.show()
def delaunay_pairs(date, location, perp_max, temp_max, dir):
centers, edges, tri, neighbors = md.delaunay(date, location)
pairs = edges.tolist()
bperp = []
for idx in xrange(len(pairs)):
if pairs[idx][0] > pairs[idx][1]:
index1 = pairs[idx][1]
index2 = pairs[idx][0]
pairs[idx][0] = index1
pairs[idx][1] = index2
pairs_in = sorted(pairs, key=itemgetter(0))
pairs_in2 = []
[pairs_in2.append(i) for i in pairs_in if not i in pairs_in2]
pairs = []
for idx in xrange(len(pairs_in2)):
perp = location[pairs_in2[idx][1]] - location[pairs_in2[idx][0]]
abs_perp = abs(perp)
date_1 = datetime.datetime.strptime(date[pairs_in2[idx][1]], "%y%m%d")
date_2 = datetime.datetime.strptime(date[pairs_in2[idx][0]], "%y%m%d")
temp_base = date_2 - date_1
btemp = abs(temp_base.days)
if abs_perp > perp_max:
pass
elif btemp > temp_max:
pass
else:
bperp.append(perp)
pairs.append(pairs_in2[idx])
fig = plt.figure()
ax = fig.add_subplot(111)
datelist = []
for i in xrange(len(date)):
datelist.append(datetime.datetime.strptime(date[i], '%y%m%d'))
# location_base = array(location) - location[0]
location_base = array(location)
ax.plot([datelist], [location_base], 'ro')
for k, j in pairs:
date_1 = datelist[k]
date_2 = datelist[j]
ax.plot([date_1, date_2], [location_base[k], location_base[j]], 'b')
fig.suptitle('Baselines')
plt.ylabel('Orbital Location')
plt.xlabel('Time (years)')
# plt.xticks(rotation = 45)
plt.xlim([(datelist[0] - (datetime.timedelta(90))),
(datelist[-1] + (datetime.timedelta(90)))])
fig.savefig('Pairs_' + str(dir) + '.png')
print 'PAIRS: ' + str(len(pairs))
return pairs, bperp
def square_mesh(N):
"""Build an uniform triangular mesh on unit square."""
xs,ys = np.meshgrid(np.linspace(0,1,N),np.linspace(0,1,N))
xs = xs.flatten(1)
ys = ys.flatten(1)
_,_,t,_ = triang.delaunay(xs,ys)
p = np.vstack((xs,ys)).T
return Trimesh(p,t)
def plot_delaunay(pts):
x = pts[:, 0]
y = pts[:, 1]
cens, edg, tri, neig = triang.delaunay(x, y)
for t in tri:
t_i = [t[0], t[1], t[2], t[0]]
pylab.plot(x[t_i], y[t_i])
pylab.plot(x, y, 'o')
pylab.show()
def triangulated_surface(x,y,z):
"""
3d surface plot of irregularly space samples. Surface is found by tessulating XY plane.
"""
# Create a triangulation of our region.
_, _, tri_points, _ = delaunay(x, y)
data = np.array([x,y,z]).T
# Construct the triangles for the surface.
verts = np.array([[data[i], data[j], data[k]] for (i,j,k) in tri_points])
# To get a coloured plot, we need to assign a value to each face that
# dictates the colour. In this case we'll just use the average z
# co-ordinate of the three triangle vertices. One of these values is
# required for each face (triangle).
z_color = np.array([(np.sum(v_p[:,2]) / 3.0) for v_p in verts])
# Choiced for colour maps are :
# autumn bone cool copper flag gray hot hsv jet pink prism spring summer
# winter spectral
cm = pl.cm.get_cmap("jet")
# Our triangles are now turned into a collection of polygons using the
# vertex array. We assign the colour map here, which will figure out its
# required ranges all by itself.
triCol = Poly3DCollection(verts, cmap=cm)
triCol.set_edgecolor('k')
triCol.set_linewidth(0.1)
# Set the value array associated with the polygons.
triCol.set_array(z_color)
# Create the plotting figure and the 3D axes.
fig = pl.figure()
ax = Axes3D(fig)
# Add our two collections of 3D polygons directly. The collections have all of
# the point and color information. We don't need the add_collection3d method,
# since that method actually converts 2D polygons to 3D polygons. We already
# have 3D polygons.
ax.add_collection(triCol)
# Add a label, for interest
#ax.text3D(0.0, 0.0, 2.1, "Peak/Trough")
# If we don't bound the axes correctly the display will be off.
ax.set_xlim3d(x.min(), x.max())
ax.set_ylim3d(y.min(), y.max())
ax.set_zlim3d(z.min(), z.max())
# We could also print to a file here.
pl.show()
return ax
def triangulated_surface(x, y, z):
"""
3d surface plot of irregularly space samples. Surface is found by tessulating XY plane.
"""
# Create a triangulation of our region.
_, _, tri_points, _ = delaunay(x, y)
data = np.array([x, y, z]).T
# Construct the triangles for the surface.
verts = np.array([[data[i], data[j], data[k]] for (i, j, k) in tri_points])
# To get a coloured plot, we need to assign a value to each face that
# dictates the colour. In this case we'll just use the average z
# co-ordinate of the three triangle vertices. One of these values is
# required for each face (triangle).
z_color = np.array([(np.sum(v_p[:, 2]) / 3.0) for v_p in verts])
# Choiced for colour maps are :
# autumn bone cool copper flag gray hot hsv jet pink prism spring summer
# winter spectral
cm = pl.cm.get_cmap("jet")
# Our triangles are now turned into a collection of polygons using the
# vertex array. We assign the colour map here, which will figure out its
# required ranges all by itself.
triCol = Poly3DCollection(verts, cmap=cm)
triCol.set_edgecolor('k')
triCol.set_linewidth(0.1)
# Set the value array associated with the polygons.
triCol.set_array(z_color)
# Create the plotting figure and the 3D axes.
fig = pl.figure()
ax = Axes3D(fig)
# Add our two collections of 3D polygons directly. The collections have all of
# the point and color information. We don't need the add_collection3d method,
# since that method actually converts 2D polygons to 3D polygons. We already
# have 3D polygons.
ax.add_collection(triCol)
# Add a label, for interest
#ax.text3D(0.0, 0.0, 2.1, "Peak/Trough")
# If we don't bound the axes correctly the display will be off.
ax.set_xlim3d(x.min(), x.max())
ax.set_ylim3d(y.min(), y.max())
ax.set_zlim3d(z.min(), z.max())
# We could also print to a file here.
pl.show()
return ax
def initPartition(self):
if self.nDim == 1:
self.partitionCenters = []
self.partitionCells = []
for i in range(self.nSamples-1):
self.partitionCenters.append([self.tVec[0][i],self.tVec[0][i+1]])
self.partitionCells.append([i,i+1])
elif self.nDim == 2:
(self.partitionCenters, _, self.partitionCells, _) = delaunay(self.tVec[0],self.tVec[1])
self.nCells = len(self.partitionCells)
def select_pairs_delaunay(tempBaseList,perpBaseList,normalize=1):
## Select Pairs using Delaunay Triangulation based on temporal/perpendicular baselines
##
## Usage:
## tempBaseList : list of temporal baseline
## perpBaseList : list of perpendicular spatial baseline
## normalize : normalize temporal baseline to perpendicular baseline
## 1 - enable normalization, default
## 0 - disable normalization
##
## Key points
## 1. Define a ratio between perpendicular and temporal baseline axis units (Pepe and Lanari, 2006, TGRS).
## 2. Pairs with too large perpendicular / temporal baseline or Doppler centroid difference should be removed
## after this, using a threshold, to avoid strong decorrelations (Zebker and Villasenor, 1992, TGRS).
##
## Reference:
## Pepe, A., and R. Lanari (2006), On the extension of the minimum cost flow algorithm for phase unwrapping
## of multitemporal differential SAR interferograms, IEEE TGRS, 44(9), 2374-2383.
## Zebker, H. A., and J. Villasenor (1992), Decorrelation in interferometric radar echoes, IEEE TGRS, 30(5), 950-959.
##
import matplotlib.delaunay as md
##### Generate Delaunay Triangulation based on temporal and spatial perpendicular baselines
if normalize == 0:
centers,edges,tri,neighbors = md.delaunay(tempBase,perpBase)
else:
##### Ratio between perpendicular and temporal baselines (Pepe and Lanari, 2006, TGRS)
tempBaseFacList = []
temp2perp_scale = (max(perpBaseList)-min(perpBaseList)) / (max(tempBaseList)-min(tempBaseList))
for tempBase in tempBaseList:
#tempBaseFac = (tempBase - min(tempBaseList)) * temp2perp_scale + min(perpBaseList)
tempBaseFac = tempBase * temp2perp_scale # giving same result as the line above
tempBaseFacList.append(tempBaseFac)
centers,edges,tri,neighbors = md.delaunay(tempBaseFacList,perpBaseList)
## The delaunay pairs do not necessarily have the indexes with lowest
## first, so let's arrange and sort the delaunay pairs
delaunayPairs = edges.tolist()
delaunayPairs = pair_sort(delaunayPairs)
return delaunayPairs
def test_data(npoints):
#A simple testing function that generate random triangles
# 10 random points (x,y) in the plane
import numpy
import matplotlib.delaunay as triang
x, y = numpy.array(numpy.random.standard_normal((2, npoints)))
z = numpy.array(numpy.random.standard_normal(npoints))
points = []
for i in range(npoints):
points.append((x[i], y[i], z[i]))
cens, edg, tri, neig = triang.delaunay(x, y)
return points, tri
def test_data(npoints):
#A simple testing function that generate random triangles
# 10 random points (x,y) in the plane
import numpy
import matplotlib.delaunay as triang
x,y = numpy.array(numpy.random.standard_normal((2,npoints)))
z = numpy.array(numpy.random.standard_normal(npoints))
points=[]
for i in range(npoints):
points.append((x[i],y[i],z[i]))
cens,edg,tri,neig = triang.delaunay(x,y)
return points, tri
def __init__(self, boundary_callable=CircleBoundary(), sample_count=20):
'''
:param boundary_callable: a callable we can sample sample_count times in [0,1)
:param sample_count: how many points to sample from boundary_callable
if boundary function is of that fancy cas package we could sample
weighed by the absolute value of the gradient. otherwise sampling is uniform
'''
super(PrescribedBoundaryGrid, self).__init__()
fac = 1 / sample_count
self._px = np.array([boundary_callable(p * fac)[0] for p in range(sample_count)])
self._py = np.array([boundary_callable(p * fac)[1] for p in range(sample_count)])
self._vertices = zip(self._px, self._py)
self._centers, _, triangles, self._neighbours_ids = delaunay(self._px, self._py)
self._edges = []
for ids in triangles:
self._edges.extend([self.Edge(ids[i[0]], ids[i[1]]) for i in [(0, 1), (1, 2), (2, 0)]])
self._triangles = [self.Triangle(x, self._edges) for x in triangles]
self._sizes = {0: len(self._triangles), 1: len(self._edges), 2: len(self._px)}
self.__subentities = list(xrange(self.dim + 1))
self.__subentities[2] = np.array([c.vertices for c in self._triangles], dtype='int32')
self.__subentities[1] = np.array([c.edges for c in self._triangles], dtype='int32')
self.__subentities[0] = np.arange(len(self._triangles), dtype='int32')[:, np.newaxis]
self.__embed_A = np.empty((self._sizes[0], 2, 2))
self.__embed_B = np.empty((self._sizes[0], 2))
for i, triangle in enumerate(self._triangles):
x = [(self._px[triangle.vertices[j]], self._py[triangle.vertices[j]]) for j in (0, 1, 2)]
W = np.array([[x[0][0], x[0][1], 0, 0, 1, 0],
[0, 0, x[0][0], x[0][1], 0, 1],
[x[1][0], x[1][1], 0, 0, 1, 0],
[0, 0, x[1][0], x[1][1], 0, 1],
[x[2][0], x[2][1], 0, 0, 1, 0],
[0, 0, x[2][0], x[2][1], 0, 1]])
K = np.array([0, 0, 0, 1, 1, 1])
try:
R = np.linalg.solve(W, K)
except np.linalg.linalg.LinAlgError, e:
import pprint
self.logger.critical(pprint.pformat(K))
self.logger.critical(pprint.pformat(W))
self.logger.error(pprint.pformat(self._vertices))
raise e
self.__embed_A[i] = [[R[0], R[1]],
[R[2], R[3]]]
self.__embed_B[i] = [R[4], R[5]]
def main(argv=None):
"""."""
global xl, yl, zl, xyl, xa, ya, cens, edgs, tris, neighs, triPts, trWithPoint
# global width, height
if argv is None:
argv = sys.argv
# generate_points()
read_points()
for i in range(len(xl)):
xyl.append([xl[i], yl[i]])
xyzl.append([xl[i], yl[i], zl[i]])
# transform array data to list data (for delaunay())
xa = numpy.array(xl)
ya = numpy.array(yl)
cens, edgs, triPts, neighs = triang.delaunay(xa, ya)
intersections = 0
for i in range(len(triPts)):
triNormal.append(normal(xyzl[triPts[i][0]], xyzl[triPts[i][1]], xyzl[triPts[i][2]]))
find_path()
print("Path length: {}".format(path_length(path_edges)))
print("Line segments: {}".format(path_edges))
glutInit(argv)
glutInitWindowSize(width, height)
glutCreateWindow("Mount Elk")
glClearDepth(1.0)
glEnable(GL_DEPTH_TEST)
glClearColor(1.0, 1.0, 1.0, 0.0)
glShadeModel(GL_FLAT)
glEnable(GL_COLOR_MATERIAL)
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL)
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH)
glEnable(GL_DEPTH_TEST)
glutInitWindowPosition(100, 100)
glLightfv(GL_LIGHT0, GL_POSITION, lightOnePosition)
glLightfv(GL_LIGHT0, GL_DIFFUSE, lightOneColor)
glEnable(GL_LIGHT0)
glEnable(GL_LIGHTING)
glEnable(GL_RESCALE_NORMAL)
glColorMaterial(GL_FRONT_AND_BACK, GL_DIFFUSE)
glEnable(GL_COLOR_MATERIAL)
glutDisplayFunc(display3D)
glutReshapeFunc(reshape3D)
glutKeyboardFunc(keyboard)
generate_dl()
glutMainLoop()
return
def _compute(self, config):
""" Calculate the Delaunay triangulation.
Sets triangles, a set of 3-tuples of particle ids in
config.*images that form the vertices of a Delaunay triangle.
@param self The object pointer
@param config Config object
@retval neighbors Dict with key=vertex,
val=set of particle ids in *coords based on Delaunay triangulation
"""
# use matplotlib's Delaunay triangulation
# https://github.com/matplotlib/matplotlib/blob/master/lib/matplotlib/tri/triangulation.py
# centers is Ntri x 2 float array of circumcenter x,y coords (ie vertices in Voronoi)
# edges is N? x 2 int array of indices defining triangle edges
# triangles is Ntri x 3 int array of triangle vertex indices, ordered counterclockwise
# tri_nhbrs is Ntri x 3 int array of triangle indices that share edges (null = -1)
# tri_nhbrs[i,j] is the triangle that is the neighbor to the edge from
# point index triangles[i,j] to point index triangles[i,(j+1)%3].
centers, edges, triangles_list, tri_nbhrs = delaunay.delaunay(config.ximages,
config.yimages)
# store triangles as set of tuples, only keeping those in or near
triangles_set = set()
for tri in triangles_list:
if config.is_tri_in_image(tri[0], tri[1], tri[2]):
triangles_set.add(tuple(sorted(tri)))
# identify nearest neighbors in triangulation
# nbhrs is a dict with key=vertex, val=set of neighbor particle ids
# all particle indices are in original image
nbhrs = dict(zip(config.indices, [set() for i in config.indices]))
for tri in triangles_set:
inds = [ip % int(config.N) for ip in tri]
for ivert in range(3): # loop through triangle vertices
for offset in [1,2]: # loop through the two neighboring vertices
nbhrs[inds[ivert]].add(inds[(ivert+offset)%3])
# return neighbors and triangles
self._triangles = triangles_set
return nbhrs
def lloyd(xn,yn):
f = open('points.in','w')
f.write("2 rbox %d D2\n" % len(xn))
f.write("%d\n" % len(xn))
for p in range(len(xn)):
f.write("%e " % xn[p])
f.write("%e\n" % yn[p])
f.close()
for count in range(20):
cmd = 'cat points.in | qvoronoi s o QJ'
sub_process = Popen(cmd, shell=True,stdout=PIPE,stderr=PIPE)
output = sub_process.communicate()
lines = [line.split() for line in output[0].split('\n') if line]
setsize = len(lines)
nv = int(lines[1][0])
coord = lines[2:2+nv]
ref = lines[2+nv:]
for P in range(len(xn)):
cx = 0.
cy = 0.
for V in range(int(ref[P][0])):
cx += float(coord[int(ref[P][V+1])][0])
cy += float(coord[int(ref[P][V+1])][1])
n = int(ref[P][0])
xn[P] = xn[P] - (xn[P]-cx/n)/15.
yn[P] = yn[P] - (yn[P]-cy/n)/15.
f = open('points.in','w')
f.write("2 rbox %d D2\n" % len(xn))
f.write("%d\n" % len(xn))
for p in range(len(xn)):
f.write("%e " % xn[p])
f.write("%e\n" % yn[p])
f.close()
return triang.delaunay(xn,yn)
def main(argv=None):
"""."""
global xl, yl, xyl, xa, ya, cens, edgs, triPts, lp
if argv is None:
argv = sys.argv
generate_points()
for i in range(len(xl)):
xyl.append([xl[i], yl[i]])
xa = numpy.array(xl) # transform array data to list data (for delaunay())
ya = numpy.array(yl)
cens, edgs, triPts, neigs = triang.delaunay(xa, ya)
glutInit(argv)
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB)
glutInitWindowSize(width, height)
glutInitWindowPosition(100, 100)
glutCreateWindow("Delaunay triangulation")
glutDisplayFunc(display)
glutReshapeFunc(reshape)
glutKeyboardFunc(keyboard)
glutMainLoop()
return
def delaunay_triangulation(portals):
xx = []
yy = []
ids = []
names = []
for p in portals:
ids.append(p['id'])
names.append(p['name'])
xx.append(p['coords']['gmaps']['lat'])
yy.append(p['coords']['gmaps']['long'])
xx = numpy.array(xx)
yy = numpy.array(yy)
cens,edg,tri,neig = triang.delaunay(xx,yy)
print min(xx), max(xx)
print min(yy), max(yy)
return {'cens': cens, 'edg': edg, 'tri': tri, 'neig': neig, 'xx': xx, 'yy': yy, 'id': ids, 'names': names}
def get_dely(d, nodes):
"""
get the delaunay tesselation
return centers, triangles, neighbors, bars, barmids
"""
x,y = nodes[0].squeeze(), nodes[1].squeeze()
centers, bars, tris, neighs = delaunay.delaunay(*nodes)#x,y)#*nodes)
# remove outside triangles
kin = nonzero( d(*centers.T)<geps)
centers = centers[kin].T
tris = tris[kin]
neighs = neighs[kin]
# remove outside bars
barmids = .5 * (nodes[:,bars[:,0]] + nodes[:,bars[:,1]])
# kin = nonzero(d(*barmids)<geps)
bars = bars[d(*barmids)<geps]
barmids = .5 * (nodes[:,bars[:,0]] + nodes[:,bars[:,1]])
return centers, tris, neighs, bars, barmids
def tessilate(self, X,Y,Z):
x1 = X[0]
y1 = Y[0]
z1 = Z[0]
hasX = self.hasCoordinate(x1,X)
hasY = self.hasCoordinate(y1,Y)
hasZ = self.hasCoordinate(z1,Z)
n = []
if hasX:
n.append(X)
if hasY:
n.append(Y)
if hasZ:
n.append(Z)
if len(n) < 2:
print "something is wrong"
tri = []
return tri
cens,edg,tri,neig = triang.delaunay(n[0], n[1])
return tri
def _calc_triangles(self, ax=None):
if ax is None:
fig = pl.figure()
ax = fig.add_subplot(111)
if self.gridtype != 'regular':
raise ValueError('only supported for regular grids so far!')
if self._lon0.ndim != 2:
raise ValueError('2D grid required!')
ny, nx = self._lon0.shape
lons = []
lats = []
for i in range(1, ny - 1): # todo revise this calculation method!!!
for j in range(1, nx - 1):
# half way to corner neighbors?
# upper left
lons.append(self._lon0[i - 1, j - 1] + 0.5 *
(self._lon0[i, j] - self._lon0[i - 1, j - 1]))
lats.append(self._lat0[i - 1, j - 1] + 0.5 *
(self._lat0[i, j] - self._lat0[i - 1, j - 1]))
# lower right
lons.append(self._lon0[i, j] + 0.5 *
(self._lon0[i + 1, j + 1] - self._lon0[i, j]))
lats.append(self._lat0[i, j] + 0.5 *
(self._lat0[i + 1, j + 1] - self._lat0[i, j]))
# lower left
# lons.append(self._lon0[i-1,j]+0.5
#*(self._lon0[i+1,j+1]-self._lon0[i,j]))
# add also current center coordinate for
# plotting vizualization
lons.append(self._lon0[i, j])
lats.append(self._lat0[i, j])
lons = np.asarray(lons)
lats = np.asarray(lats)
cens, edg, tri, neig = triang.delaunay(lons, lats)
self._do_delaunay_plot(tri, lons, lats, ax)
def _calc_triangles(self, ax=None):
if ax is None:
fig = pl.figure()
ax = fig.add_subplot(111)
if self.gridtype != 'regular':
raise ValueError('only supported for regular grids so far!')
if self._lon0.ndim != 2:
raise ValueError('2D grid required!')
ny, nx = self._lon0.shape
lons = []
lats = []
for i in range(1, ny - 1): # todo revise this calculation method!!!
for j in range(1, nx - 1):
# half way to corner neighbors?
# upper left
lons.append(self._lon0[i - 1, j - 1] + 0.5
* (self._lon0[i, j] - self._lon0[i - 1, j - 1]))
lats.append(self._lat0[i - 1, j - 1] + 0.5
* (self._lat0[i, j] - self._lat0[i - 1, j - 1]))
# lower right
lons.append(self._lon0[i, j] + 0.5
* (self._lon0[i + 1, j + 1] - self._lon0[i, j]))
lats.append(self._lat0[i, j] + 0.5
* (self._lat0[i + 1, j + 1] - self._lat0[i, j]))
# lower left
# lons.append(self._lon0[i-1,j]+0.5
#*(self._lon0[i+1,j+1]-self._lon0[i,j]))
# add also current center coordinate for
# plotting vizualization
lons.append(self._lon0[i, j])
lats.append(self._lat0[i, j])
lons = np.asarray(lons)
lats = np.asarray(lats)
cens, edg, tri, neig = triang.delaunay(lons, lats)
self._do_delaunay_plot(tri, lons, lats, ax)
def main(argv=None):
"""."""
global xl, yl, xyl, xa, ya, cens, edgs, tris, neighs, triPts, trWithPoint
if argv is None:
argv = sys.argv
generate_points()
for i in range(len(xl)):
xyl.append([xl[i], yl[i]])
# transform array data to list data (for delaunay())
xa = numpy.array(xl)
ya = numpy.array(yl)
cens, edgs, triPts, neighs = triang.delaunay(xa, ya)
find_intersected_edges()
# find_edges_on_path()
# print results
print "Intersected edges:"
for edge in intersected_line_segments:
print("({x1}, {y1}) - ({x2}, {y2})".format(x1=xl[edge[0]],
y1=yl[edge[0]],
x2=xl[edge[1]],
y2=yl[edge[1]]))
if (intersection_points):
print "\nIntersection points:"
for intersection in intersection_points:
print("({x}, {y})".format(x=intersection[0], y=intersection[1]))
glutInit(argv)
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB)
glutInitWindowSize(width, height)
glutInitWindowPosition(100, 100)
glutCreateWindow("Delaunay triangulation")
glutDisplayFunc(display)
glutReshapeFunc(reshape)
glutKeyboardFunc(keyboard)
glutMainLoop()
return
def find_minimum_weight_matching(self):
""" finds a minimum weight perfect matching"""
print "computing delaunay of odd_deg_nodes"
circumcenters, edges, tri_points, tri_neighbors = triang.delaunay(self.x[self.odd_deg_nodes], self.y[self.odd_deg_nodes])
o = nx.Graph()
o.dist_func = lambda i,j: -self.euclidean_dist(i,j)
for i, j in edges:
mi = self.odd_deg_nodes[i]
mj = self.odd_deg_nodes[j]
o.add_edge(mi, mj, weight=o.dist_func(mi, mj))
self.o = o
print '#edges:', len(edges), '#nodes:', len(o.nodes()), len(self.odd_deg_nodes)
print "computing minimum matching"
t1 = time.time()
mates = max_weight_matching(o, maxcardinality=True)
t2 = time.time()
print "took %s" % (t2-t1)
m = nx.Graph()
for i in mates.keys():
m.add_edge(i,mates[i], weight=self.g.dist_func(i,mates[i]))
print '#edges:', len(m.edges()), '#nodes:', len(m.nodes())
self.plot_edges(m.edges(),'r-',2)
self.m = m
def main(
displayFunction,
argv=None,
):
"""."""
global xl, yl, xyl, xa, ya, cens, edgs, tris, neighs, triPts, dcel
if argv is None:
argv = sys.argv
generate_points(True)
xa = numpy.array(xl) # transform array data to list data (for delaunay())
ya = numpy.array(yl)
cens, edgs, triPts, neighs = triang.delaunay(xa, ya)
# Generate the DCEL
dcel = DCEL.from_delaunay_triangulation(xl, yl, triPts, cens)
glutInit(argv)
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB)
glutInitWindowSize(width, height)
glutInitWindowPosition(100, 100)
glutCreateWindow("Delaunay triangulation")
glutDisplayFunc(displayFunction)
glutReshapeFunc(reshape)
glutKeyboardFunc(keyboard)
glutMainLoop()
return
def display_tile_stacked(tile):
real_x_pos = []
real_y_pos = []
real_tile = []
point = []
for starfield_position in tile:
real_x_pos.append((starfield_position[6] * 4800) / 10)
real_y_pos.append((starfield_position[7] * 4800) / 10)
point.append(((starfield_position[6] * 4800) / 10, (starfield_position[7] * 4800) / 10))
real_tile_x = starfield_position[2]
real_tile_y = starfield_position[3]
real_tile.append(real_tile_x + 1.5 * real_tile_y + 9.323)
# plt.ylim([-10, 4810])
# plt.xlim([-10, 4810])
# plt.title('Starfield - True Gridded Star Single Subfield')
# plt.scatter(real_x_pos, real_y_pos, c=real_tile, marker='+')
# plt.ion()
# plt.draw()
# plt.show()
real_x_pos = numpy.array(real_x_pos)
real_y_pos = numpy.array(real_y_pos)
cens, edg, tri, neig = triang.delaunay(real_x_pos, real_y_pos)
for t in tri:
t_i = [t[0], t[1], t[2], t[0]]
plt.plot(real_x_pos[t_i], real_y_pos[t_i])
plt.plot(real_x_pos, real_y_pos, 'o')
plt.show()
def triangle(a):
xBis, yBis = transforme(a)
xBis, yBis = np.array(xBis), np.array(yBis)
cens, edg, tri, neig = triang.delaunay(xBis, yBis)
taille = len(a)
l = taille / 6
b = 0
for t in tri:
# t[0], t[1], t[2] are the points indexes of the triangle
d1, d2, d3 = d(xBis[t[0]], yBis[t[0]], xBis[t[1]],
yBis[t[1]]), d(xBis[t[1]], yBis[t[1]], xBis[t[2]],
yBis[t[2]]), d(xBis[t[2]], yBis[t[2]],
xBis[t[0]], yBis[t[0]])
if (d1 < l and d2 < l and d3 < l):
t_i = [t[0], t[1], t[2], t[0]]
if (b):
pylab.fill(xBis[t_i], yBis[t_i], "black")
b = 0
else:
b = 1
#pylab.plot(xBis, yBis, 'o')
pylab.show()
def find_triangulation2d(x, y):
cens, edg, tri, neig = triang.delaunay(x, y)
return tri
[max(m_contour[:, 0]),
max(m_contour[:, 1]), 1],
[max(m_contour[:, 0]),
min(m_contour[:, 1]), 1]]) ##pay attention to the sequence
#data_brect = np.dstack(( data_brect[:,1], data_brect[:,0] ))[0]
#model_brect = np.dstack(( model_brect[:,1], model_brect[:,0] ))[0]
model = np.concatenate((self.model, model_brect[:, 0:2]))
data = np.concatenate((self.data, data_brect[:, 0:2]))
x = data[:, 0]
y = data[:, 1]
tri = align.triangulate_points(x, y)
fp = np.dstack((data[:, 1], data[:, 0], np.ones(data.shape[0])))[0]
tp = np.dstack((model[:, 1], model[:, 0], np.ones(model.shape[0])))[0]
#nphoto = pw_affine(img,img2,fp.T,tp.T,tri)
'''
aft = align.compute_affine(data, model)
shape = img2.shape
nphoto = cv2.warpAffine(img, aft, (shape[1], shape[0]))
cv2.imshow('img', nphoto)
cv2.waitKey(0)
'''
self.sigPiecewiseRequested.emit((fp.T, tp.T, tri))
if __name__ == '__main__':
delaunay()
def delaunay(pts):
_, _, tri, _ = md.delaunay(pts[:, 0], pts[:, 1])
return tri
def delaunay(pts):
_, _, tri, _ = md.delaunay(pts[:,0], pts[:,1])
return tri
osgb_point = Point(new_x, new_y, srid=27700)
wgs84_point = osgb_point.transform(4326, clone=True)
wgs84_postcode_and_points.append(('infinity{0:06d}'.format(i), wgs84_point))
if args.postcode_points:
output_postcode_points_kml(
join(postcodes_output_directory, 'postcode-points.kml'),
wgs84_postcode_and_points,
)
x = np.array(x)
y = np.array(y)
print("Calculating the Delaunay Triangulation...")
ccs, edges, triangles, neighbours = delaunay(x, y)
point_to_triangles = [[] for _ in x]
for i, triangle in enumerate(triangles):
for point_index in triangle:
point_to_triangles[point_index].append(i)
# Now generate the KML output:
print("Now generating KML output")
def output_kml(point_index_and_triangle_indices):
point_index, triangle_indices = point_index_and_triangle_indices
centre_x = x[point_index]
execfile('/Users/wkerzend/Documents/science/thesis/thesis/tex/thesis_plot_defaults.py')
import matplotlib.delaunay as triang
import pylab
import numpy
np.random.seed(250819801106)
# 10 random points (x,y) in the plane
x,y = numpy.array(numpy.random.standard_normal((2,15)))
cens,edg,tri,neig = triang.delaunay(x,y)
clf()
for t in tri:
# t[0], t[1], t[2] are the points indexes of the triangle
t_i = [t[0], t[1], t[2], t[0]]
pylab.plot(x[t_i],y[t_i], color='k')
ax = gca()
ax.xaxis.set_visible(False)
ax.yaxis.set_visible(False)
ax.axes.set_frame_on(False)
savefig('simple_delauney.pdf')
pylab.plot(x,y,'ko')
# -*- coding: utf-8 -*-
"""
Created on Thu Aug 18 16:41:10 2016
@author: user
"""
from PIL import Image
from numpy import *
import matplotlib.delaunay as md
x, y = array(random.standard_normal((2, 100)))
centers, edges, tri, neighbors = md.delaunay(x, y)
figure()
for t in tri:
t_ext = [t[0], t[1], t[2], t[0]] # add first point to end
plot(x[t_ext], y[t_ext], 'r')
plot(x, y, '*')
axis('off')
show()
execfile(
'/Users/wkerzend/Documents/science/thesis/thesis/tex/thesis_plot_defaults.py'
)
import matplotlib.delaunay as triang
import pylab
import numpy
np.random.seed(250819801106)
# 10 random points (x,y) in the plane
x, y = numpy.array(numpy.random.standard_normal((2, 15)))
cens, edg, tri, neig = triang.delaunay(x, y)
clf()
for t in tri:
# t[0], t[1], t[2] are the points indexes of the triangle
t_i = [t[0], t[1], t[2], t[0]]
pylab.plot(x[t_i], y[t_i], color='k')
ax = gca()
ax.xaxis.set_visible(False)
ax.yaxis.set_visible(False)
ax.axes.set_frame_on(False)
savefig('simple_delauney.pdf')
pylab.plot(x, y, 'ko')
def main():
clos = parse()
print(clos)
dat = open(clos.infile, 'r').readlines()
data = []
for d in dat:
data.append(d.split())
dates = []
tbase = []
pbase = []
slcs = []
prms = []
for d in data:
date = datetime.datetime.strptime(d[0], "%Y%m%d")
if date.month >= clos.monthMin and date.month <= clos.monthMax:
pbase.append(float(d[1]))
dates.append(d[0])
slcs.append(d[3])
prms.append(os.path.splitext(d[3])[0] + '.PRM')
print("************************************")
print("Total # of scenes in %s: %d" % (clos.infile, len(data)))
print("Total after filtering by month: %d" % len(dates))
print("************************************")
'''calculate tbase from d1 to dni'''
d1 = datetime.datetime.strptime(dates[0], "%Y%m%d")
for d in dates:
d2 = datetime.datetime.strptime(d, "%Y%m%d")
diff = d2 - d1
tbase.append(diff.days)
'''
This returns a list of all possible pairs of dates. Should eliminate
those pairs with bad bperp and doppler overlap and leave elimination
based on time for later since we can still use them if there is no
other alternative.
'''
indexList = []
for ni in range(len(dates)):
indexList.append(ni)
allPairs = list(itertools.combinations(indexList, 2))
## Lets remove the ones with bad doppler and baselines
print("all possible pairs = " + str(len(allPairs)))
allPairs = remove_bad_pairs(allPairs, pbase, tbase, clos.Bcrit, clos.Tcrit)
print(
"all pairs with baselines less than Bcrit (%d m) and Tcrit (%d days): %d"
% (clos.Bcrit, clos.Tcrit, len(allPairs)))
'''
Do a delaunay triangulation to find the "best" pairs.
The edges will contain index to the pairs we need. We apply a
weighting factor to the time baseline so that the space being
triangulated is symetric (base on Pepe and Lanari (2006))
After the pairs are selected we then eliminate pairs which
are not "good" due to perpendicular baseline and doppler overlap.
We then add in the pairs with short temporal baselines (lengthDayMax).
'''
tbaseFac = []
for idx in range(len(tbase)):
tbaseFac.append(tbase[idx] * (max(pbase) - min(pbase)) / (max(tbase)))
centers, edges, tri, neighbors = md.delaunay(tbaseFac, pbase)
delaunayPairs = edges.tolist()
'''
The delaunay pairs do not necessarily have the indexes with lowest
first, so let's arrange and sort the delaunay pairs
'''
for idx in range(len(delaunayPairs)):
if delaunayPairs[idx][0] > delaunayPairs[idx][1]:
index1 = delaunayPairs[idx][1]
index2 = delaunayPairs[idx][0]
delaunayPairs[idx][0] = index1
delaunayPairs[idx][1] = index2
delaunayPairs = sorted(delaunayPairs, key=itemgetter(0))
## Lets remove the ones with bad doppler and baselines
print("delaunay possible pairs = " + str(len(delaunayPairs)))
delaunayPairs = remove_bad_pairs(delaunayPairs, pbase, tbase, clos.Bcrit,
clos.Tcrit)
print(
"delaunay pairs with baselines less than Bcrit (%d m) and Tcrit (%d days): %d"
% (clos.Bcrit, clos.Tcrit, len(delaunayPairs)))
## Now lets add all additional pairs less than lengthDayMax from allPairs
for idx in range(len(allPairs)):
allPairs[idx] = list(allPairs[idx])
if tbase[allPairs[idx][1]] - tbase[allPairs[idx]
[0]] <= clos.lengthDayMax:
if allPairs[idx] not in delaunayPairs:
delaunayPairs.append(allPairs[idx])
print("delaunay pairs with added pairs less than " +
str(clos.lengthDayMax) + " days = " + str(len(delaunayPairs)))
projectDir = os.getcwd()
projectName = os.path.basename(projectDir)
if clos.selectMethod == 'all':
pairs = allPairs
else:
pairs = delaunayPairs
dates_obj = [datetime.datetime.strptime(d, "%Y%m%d") for d in dates]
if clos.dateSpan:
""" This will filter out the pairs that don't span the date of interest """
date_span = datetime.datetime.strptime(clos.dateSpan, "%Y-%m-%d")
pairs = [
igram for igram in pairs if dates_obj[igram[0]] < date_span
and dates_obj[igram[1]] > date_span
]
print("# of pairs spanning %s: %d" % (clos.dateSpan, len(pairs)))
intf = open('intf.in', 'w')
f = open('run_p2pTOPS', 'w')
for igram in sorted(pairs):
ndx1 = igram[0]
ndx2 = igram[1]
baseline = '%05.0f' % round(pbase[ndx1] - pbase[ndx2])
temporalbaseline = '%04.0f' % round(tbase[ndx2] - tbase[ndx1])
# print(slcs[ndx1].split("_")[0]+":"+slcs[ndx2].split("_")[0])
intf.write(slcs[ndx1].split("_")[0] + ":" + slcs[ndx2].split("_")[0] +
'\n')
f.write(
'p2p_S1A_TOPS.csh %s %s config.tops.txt\n' %
(os.path.splitext(slcs[ndx1])[0], os.path.splitext(slcs[ndx2])[0]))
intf.close()
f.close()
f = open('config.tops.txt', 'w')
f.write('proc_stage = 4\n')
f.write('topo_phase = 1\n')
f.write('topo_shift = 1\n')
f.write('switch_master = 0\n')
f.write('filter_wavelength = 200\n')
f.write('dec_factor = 2\n')
f.write('threshold_snaphu = 0.1\n')
f.write('switch_land = 1\n')
f.write('defomax = 0\n')
f.write('threshold_geocode = .10')
f.close()
plt.figure()
for e in edges:
x = [dates_obj[e[0]], dates_obj[e[1]]]
y = [pbase[e[0]], pbase[e[1]]]
plt.plot(x, y, '--', c='gray')
for igram in sorted(pairs):
ndx1 = igram[0]
ndx2 = igram[1]
x = [dates_obj[ndx1], dates_obj[ndx2]]
y = [pbase[ndx1], pbase[ndx2]]
plt.plot(x, y, 'b')
plt.plot(dates_obj, pbase, 'ro')
if clos.dateSpan:
plt.axvline(datetime.datetime.strptime(clos.dateSpan, '%Y-%m-%d'),
ls='-',
color='g')
plt.annotate('Event',
xy=(datetime.datetime.strptime(clos.dateSpan,
'%Y-%m-%d'), min(pbase)),
xycoords='data',
color='g')
plt.xlabel('Date')
plt.ylabel('Perpendicular Baseline (m)')
projectName = os.path.basename(os.getcwd())
plt.title('SBAS Network - ' + projectName)
plt.savefig(projectName + '_network.png', transparent=True)
if clos.np:
plt.show()
center_x = rect_width / 2
rect_height = (bottom - top)
center_y = rect_height / 2
#compute the amount to offset the points by
offset_from_center_x = width / 2 - (center_x) - left
offset_from_center_y = height / 2 - (center_y) - top
#actually offset the points
points = [(x + offset_from_center_x,
y + offset_from_center_y)
for x, y in points]
#compute the delunay triangulation
cens, edg, tri, neig = triang.delaunay([x for x, y in points],
[y for x, y in points])
if args.color_edges:
#perform edge coloring
edg_colors = edge_color(edg)
#remember the physical colors we've used
physical_colors = defaultdict(generate_hipster_color)
#draw the delunay triangulation lines
for i in range(0, len(edg)):
start, end = edg[i]
x = points[start][0]
y = points[start][1]
x2 = points[end][0]
y2 = points[end][1]
if args.color_edges:
def triangulate_points(x, y):
# Delaunay triangulation of 2D points. """
centers, edges, tri, neighbors = md.delaunay(x, y)
return tri
def triangulate_points(x, y):
""" 二维点的 Delaunay 三角剖分 """
centers, edges, tri, neighbors = md.delaunay(x, y)
return tri
def build_mesh(self):
print 'triangulating ...'
circumcenters, edges, tri_points, tri_neighbors = triang.delaunay(self.x, self.y)
self.tri_points = tri_points
self.edges = edges
is_color = len(fromim.shape) == 3
# create image to warp to (needed if iterate colors)
im_t = zeros(im.shape, 'uint8')
for t in tri:
# compute affine transformation
H = homography.Haffine_from_points(tp[:,t],fp[:,t])
if is_color:
for col in range(fromim.shape[2]):
im_t[:,:,col] = ndimage.affine_transform(fromim[:,:,col],H[:2,:2],(H[0,2],H[1,2]),im.shape[:2])
else:
im_t = ndimage.affine_transform(fromim,H[:2,:2],(H[0,2],H[1,2]),im.shape[:2])
# alpha for triangle
alpha = alpha_for_triangle(tp[:,t],im.shape[0],im.shape[1]) # add triangle to image
im[alpha>0] = im_t[alpha>0]
return im
x,y = array(np.random.standard_normal((2,100)))
centers,edges,tri,neighbors = md.delaunay(x,y)
figure()
gray()
subplot(121)
axis('off')
plot(x,y,'*')
for t in tri:
t_ext = [t[0], t[1], t[2], t[0]] # add first point to end
subplot(122)
plot(x[t_ext],y[t_ext],'r')
plot(x,y,'*')
axis('off')
show()
def surfplot(dbc, agent_name, filter, colormap = 'hot'):
global axes
P_copyFail = []
P_c = []
fitness = []
# We should only include samples from the database using the latest commit of Simulate.py, and using the latest
# commit of the agent script being plotted. First, find the latest entry of this agent script, and note the
# hashes.
sample = dbc.find({'agent_name': filter['agent_name']}, sort = [('timestamp', -1)], limit = 1).next()
filter['agent_hash'] = sample['agent_hash']
filter['simulate_hash'] = sample['simulate_hash']
for sample in dbc.find(filter):
P_copyFail.append(sample['param_P_copyFail'])
P_c.append(sample['param_P_c'])
fitness.append(sample['fitness'])
circumcenters, edges, tri_points, tri_neighbors = dl.delaunay(P_copyFail, P_c)
# Construct the triangles for the surface.
verts = ( [ np.array( [ [ P_copyFail[ t[0] ] , P_c[ t[0] ] , fitness[ t[0] ] ]
, [ P_copyFail[ t[1] ] , P_c[ t[1] ] , fitness[ t[1] ] ]
, [ P_copyFail[ t[2] ] , P_c[ t[2] ] , fitness[ t[2] ] ] ] )
for t in tri_points
]
)
# To get a coloured plot, we need to assign a value to each face that dictates
# the colour. In this case we'll just use the average z co-ordinate of the
# three triangle vertices. One of these values is required for each face
# (triangle).
z_color = np.array( [ ( np.sum( v_p[:,2] ) / 5000.0 ) for v_p in verts ] )
# Choiced for colour maps are :
# autumn bone cool copper flag gray hot hsv jet pink prism spring summer
# winter spectral
cm = plt.cm.get_cmap(colormap)
# Our triangles are now turned into a collection of polygons using the vertex
# array. We assign the colour map here, which will figure out its required
# ranges all by itself.
triCol = art3d.Poly3DCollection( verts, cmap=cm )
triCol.set_edgecolor('k')
triCol.set_linewidth( 1.0 )
# Set the value array associated with the polygons.
triCol.set_array(z_color)
# Add our two collections of 3D polygons directly. The collections have all of
# the point and color information. We don't need the add_collection3d method,
# since that method actually converts 2D polygons to 3D polygons. We already
# have 3D polygons.
axes.add_collection(triCol)
if axes.get_xlabel() == '':
xvals = P_copyFail
yvals = P_c
zvals = fitness
#else:
#xvals = concatenate((axes.get_xlim3d(), P_copyFail))
#yvals = concatenate((axes.get_ylim3d(), P_c))
#zvals = concatenate((axes.get_ylim3d(), fitness))
axes.set_xlim3d(np.min(xvals), np.max(xvals))
axes.set_ylim3d(np.min(yvals), np.max(yvals))
axes.set_zlim3d(0, np.max([np.max(zvals), 1500.0]))
axes.set_xlabel('P_copyFail')
axes.set_ylabel('P_c')
axes.set_zlabel('fitness')
# plota boundingbox
# rect = mpatches.Rectangle((minc, minr), maxc - minc, maxr - minr,
# fill=False, edgecolor='red', linewidth=2)
# ax1.add_patch(rect)
x0 = region['Centroid'][1]
y0 = region['Centroid'][0]
# pontos.append([x0, y0])
pontos.append([minc, minr])
pontos.append([maxc, minr])
pontos.append([minc, maxr])
pontos.append([maxc, maxr])
pontos = np.array(pontos)
# calculamos pontos dos triânbulos através de Delaunay
cens, edg, tri, neig = triang.delaunay(pontos[:,0], pontos[:,1])
patches = []
cores = []
coords_tri = []
for t in tri:
# t[0], t[1], t[2] are the points indexes of the triangle
t_i = [t[0], t[1], t[2], t[0]]
ax2.plot(pontos[:,0][t_i], pontos[:,1][t_i], 'k-', linewidth=.5)
ax4.plot(pontos[:,0][t_i], pontos[:,1][t_i], 'w-', linewidth=.3)
ax4.plot(pontos[:,0][t_i], pontos[:,1][t_i], 'wo', markersize=2)
#print '---'
t_i2 = [t[0], t[1], t[2]]
#print pontos[:,[0,1]][t_i2]
coords_tri.append([list(aa) for aa in list(pontos[:,[0,1]][t_i2])])
x = pontos[:,0][t_i][0]
y = pontos[:,1][t_i][0]
def triangulate_points(x, y):
""" Delaunay triangulation of 2D points. """
centers, edges, tri, neighbors = md.delaunay(x, y)
return tri
def main():
clos = parse()
print(clos)
dat = open(clos.infile,'r').readlines()
data = []
for d in dat:
data.append(d.split())
dates = []
tbase = []
pbase = []
slcs = []
prms = []
for d in data:
date=datetime.datetime.strptime(d[0],"%Y%m%d")
if date.month >= clos.monthMin and date.month <= clos.monthMax:
pbase.append(float(d[1]))
dates.append(d[0])
slcs.append(d[3])
prms.append(os.path.splitext(d[3])[0]+'.PRM')
print("************************************")
print("Total # of scenes in %s: %d" % (clos.infile,len(data)))
print("Total after filtering by month: %d" % len(dates))
print("************************************")
'''calculate tbase from d1 to dni'''
d1 = datetime.datetime.strptime(dates[0],"%Y%m%d")
for d in dates:
d2 = datetime.datetime.strptime(d,"%Y%m%d")
diff = d2-d1
tbase.append(diff.days)
'''
This returns a list of all possible pairs of dates. Should eliminate
those pairs with bad bperp and doppler overlap and leave elimination
based on time for later since we can still use them if there is no
other alternative.
'''
indexList = []
for ni in range(len(dates)):
indexList.append(ni)
allPairs = list(itertools.combinations(indexList, 2))
## Lets remove the ones with bad doppler and baselines
print("all possible pairs = " + str(len(allPairs)))
allPairs = remove_bad_pairs(allPairs,pbase,tbase,clos.Bcrit,clos.Tcrit)
print("all pairs with baselines less than Bcrit (%d m) and Tcrit (%d days): %d" % (clos.Bcrit, clos.Tcrit, len(allPairs)))
'''
Do a delaunay triangulation to find the "best" pairs.
The edges will contain index to the pairs we need. We apply a
weighting factor to the time baseline so that the space being
triangulated is symetric (base on Pepe and Lanari (2006))
After the pairs are selected we then eliminate pairs which
are not "good" due to perpendicular baseline and doppler overlap.
We then add in the pairs with short temporal baselines (lengthDayMax).
'''
tbaseFac = []
for idx in range(len(tbase)): tbaseFac.append(tbase[idx] * (max(pbase) - min(pbase)) / (max(tbase)))
centers, edges, tri, neighbors = md.delaunay(tbaseFac, pbase)
delaunayPairs = edges.tolist()
'''
The delaunay pairs do not necessarily have the indexes with lowest
first, so let's arrange and sort the delaunay pairs
'''
for idx in range(len(delaunayPairs)):
if delaunayPairs[idx][0] > delaunayPairs[idx][1]:
index1 = delaunayPairs[idx][1]
index2 = delaunayPairs[idx][0]
delaunayPairs[idx][0] = index1
delaunayPairs[idx][1] = index2
delaunayPairs = sorted(delaunayPairs, key=itemgetter(0))
## Lets remove the ones with bad doppler and baselines
print("delaunay possible pairs = " + str(len(delaunayPairs)))
delaunayPairs = remove_bad_pairs(delaunayPairs,pbase,tbase,clos.Bcrit,clos.Tcrit)
print("delaunay pairs with baselines less than Bcrit (%d m) and Tcrit (%d days): %d" % (clos.Bcrit,clos.Tcrit,len(delaunayPairs)))
## Now lets add all additional pairs less than lengthDayMax from allPairs
for idx in range(len(allPairs)):
allPairs[idx] = list(allPairs[idx])
if tbase[allPairs[idx][1]] - tbase[allPairs[idx][0]] <= clos.lengthDayMax:
if allPairs[idx] not in delaunayPairs:
delaunayPairs.append(allPairs[idx])
print("delaunay pairs with added pairs less than " + str(clos.lengthDayMax) + " days = " + str(len(delaunayPairs)))
projectDir = os.getcwd()
projectName = os.path.basename(projectDir)
if clos.selectMethod == 'all':
pairs = allPairs
else:
pairs = delaunayPairs
dates_obj = [datetime.datetime.strptime(d,"%Y%m%d") for d in dates]
if clos.dateSpan:
""" This will filter out the pairs that don't span the date of interest """
date_span = datetime.datetime.strptime(clos.dateSpan,"%Y-%m-%d")
pairs = [igram for igram in pairs if dates_obj[igram[0]]<date_span and dates_obj[igram[1]]>date_span ]
print("# of pairs spanning %s: %d" % (clos.dateSpan,len(pairs)))
intf = open('intf.in','w')
f = open('run_p2pTOPS','w')
for igram in sorted(pairs):
ndx1 = igram[0]
ndx2 = igram[1]
baseline = '%05.0f' % round(pbase[ndx1]-pbase[ndx2])
temporalbaseline = '%04.0f' % round(tbase[ndx2]-tbase[ndx1])
# print(slcs[ndx1].split("_")[0]+":"+slcs[ndx2].split("_")[0])
intf.write(slcs[ndx1].split("_")[0]+":"+slcs[ndx2].split("_")[0]+'\n')
f.write('p2p_S1A_TOPS.csh %s %s config.tops.txt\n' % (os.path.splitext(slcs[ndx1])[0],os.path.splitext(slcs[ndx2])[0]))
intf.close()
f.close()
f = open('config.tops.txt','w')
f.write('proc_stage = 4\n')
f.write('topo_phase = 1\n')
f.write('topo_shift = 1\n')
f.write('switch_master = 0\n')
f.write('filter_wavelength = 200\n')
f.write('dec_factor = 2\n')
f.write('threshold_snaphu = 0.1\n')
f.write('switch_land = 1\n')
f.write('defomax = 0\n')
f.write('threshold_geocode = .10')
f.close()
plt.figure()
for e in edges:
x = [dates_obj[e[0]],dates_obj[e[1]]]
y = [pbase[e[0]],pbase[e[1]]]
plt.plot(x,y,'--', c='gray')
for igram in sorted(pairs):
ndx1 = igram[0]
ndx2 = igram[1]
x = [dates_obj[ndx1], dates_obj[ndx2]]
y = [pbase[ndx1], pbase[ndx2]]
plt.plot(x, y, 'b')
plt.plot(dates_obj, pbase, 'ro')
if clos.dateSpan:
plt.axvline(datetime.datetime.strptime(clos.dateSpan,'%Y-%m-%d'),ls='-',color='g')
plt.annotate('Event',xy=(datetime.datetime.strptime(clos.dateSpan,'%Y-%m-%d'),min(pbase)), xycoords='data', color='g' )
plt.xlabel('Date')
plt.ylabel('Perpendicular Baseline (m)')
projectName = os.path.basename(os.getcwd())
plt.title('SBAS Network - ' + projectName)
plt.savefig(projectName+'_network.png',transparent=True)
if clos.np:
plt.show()
def triangulate_points(x,y):
""" 2Dの点のドロネー三角形分割 """
centers,edges,tri,neighbors = md.delaunay(x,y)
return tri
from matplotlib import cm
from matplotlib.ticker import LinearLocator, FixedLocator, FormatStrFormatter
import matplotlib.pyplot as plt
import numpy as np
import scipy as sp
import matplotlib.delaunay as delaunay
import matplotlib.pyplot as pp
np.random.seed(250819801106)
#generate points
npts=10
xpt=(sp.random.random_sample(npts)-0.5)*4
ypt=(sp.random.random_sample(npts)-0.5)*4
#create triangulation
circumcenters,edges,tri_points,tri_neighbors=delaunay.delaunay(xpt, ypt)
#plot using edges
fig = plt.figure(1)
fig.clf()
ax = fig.add_subplot(111, projection='3d')
ax.set_axis_off()
X = np.arange(-2, 2, 0.25)
Y = np.arange(-2, 2, 0.25)
X, Y = np.meshgrid(X, Y)
R = X**2 + Y**2 +1
surf = ax.plot_surface(X, Y, R, rstride=1, cstride=1, cmap=cm.autumn,
linewidth=0, antialiased=False, alpha=0.5)
ax.set_axis_off()
