def fill_by_graph_search(self):
""" Interpolate along edges to fill in NaN values where possible.
Will not extrapolate, though - to update a value it must have valid
neighbors in more than one direction.
"""
accum = self.F.copy()
weights = array( isfinite(accum), float64 )
counts = zeros( len(self.F), int32)
counts[ isfinite(accum) ] = 1000
accum[ isnan(accum) ] = 0.0
for i in nonzero( isfinite(self.F) )[0]:
# Shortest path search starting from i
# print i
visited = {}
heap = priority_queue.priorityDictionary()
heap[i] = 0.0
while len(heap)>0:
j = heap.smallest()
j_dist = heap[j]
del heap[j]
visited[j]=1
#print "Visiting %d - dist is %g"%(j,j_dist)
if j_dist > 0:
# update costs here
accum[j] += self.F[i] / j_dist
weights[j] += 1.0 / j_dist
counts[j] += 1
# Queue neighbors:
for nbr in self.node_neighbors(j):
if (not visited.has_key(nbr)) and isnan(self.F[nbr]):
nbr_dist = j_dist + norm(self.X[nbr]-self.X[j])
if (not heap.has_key(nbr)) or (heap[nbr]>nbr_dist):
heap[nbr] = nbr_dist
missing = isnan(self.F) & (counts>1)
self.F[missing] = accum[missing] / weights[missing]
def fill_by_graph_search(self):
""" Interpolate along edges to fill in NaN values where possible.
Will not extrapolate, though - to update a value it must have valid
neighbors in more than one direction.
"""
accum = self.F.copy()
weights = array(isfinite(accum), float64)
counts = zeros(len(self.F), int32)
counts[isfinite(accum)] = 1000
accum[isnan(accum)] = 0.0
for i in nonzero(isfinite(self.F))[0]:
# Shortest path search starting from i
# print i
visited = {}
heap = priority_queue.priorityDictionary()
heap[i] = 0.0
while len(heap) > 0:
j = heap.smallest()
j_dist = heap[j]
del heap[j]
visited[j] = 1
#print "Visiting %d - dist is %g"%(j,j_dist)
if j_dist > 0:
# update costs here
accum[j] += self.F[i] / j_dist
weights[j] += 1.0 / j_dist
counts[j] += 1
# Queue neighbors:
for nbr in self.node_neighbors(j):
if (not visited.has_key(nbr)) and isnan(self.F[nbr]):
nbr_dist = j_dist + norm(self.X[nbr] - self.X[j])
if (not heap.has_key(nbr)) or (heap[nbr] > nbr_dist):
heap[nbr] = nbr_dist
missing = isnan(self.F) & (counts > 1)
self.F[missing] = accum[missing] / weights[missing]
def Dijkstra(adjacency_list, n1, n2):
is_visited = [False] * N
parents = [-1] * N
# float('inf') - infinite value, initial value of marks
marks = [float('inf')] * N
queue = priorityDictionary()
current = n1
marks[current] = 0
# add start node into the queue
queue[current] = marks[current]
# notes isn't deleted from the queue
# (stupid implementation of the priority queue)
# infinite value means that a node "isn't in the queue"
while(queue[queue.smallest()] != float('inf')):
current = queue.smallest()
current_mark = queue[current]
for adjacent_node in adjacency_list[current]:
node = adjacent_node[0]
edge_weight = adjacent_node[1]
if not is_visited[node]:
new_mark = current_mark + edge_weight
if marks[node] > new_mark:
marks[node] = new_mark
parents[node] = current
queue[node] = new_mark
is_visited[current] = True;
queue[current] = float('inf')
# print optimal path (n1, n2)
print "Path lenght is " + str(marks[n2])
path = []
current = n2
path.append(current)
while (current != n1):
current = parents[current]
path.append(current)
path.reverse()
print path
def shortest_path(self, n1, n2, boundary_only=False):
"""
Dijkstra on the edge graph from node n1 to n2.
copied and modified form Rusty's code.
Keep in mind that the solution can be non-unique
because there are multiple paths that have the same distances.
Parameters
----------
n1: int
node index for one end of the path
n2: int
node_i for the other end
boundary_only: boolean
limit search to edges on the boundary
Returns
-------
numpy.ndarray
shortest node indexes or None if it cannot be found
"""
queue = pq.priorityDictionary()
queue[n1] = 0
done = {}
while True:
# find the queue-member with the lowest cost:
best = queue.smallest()
best_cost = queue[best]
del queue[best]
done[best] = best_cost
if best == n2:
# print "Found the ending point"
break
# figure out its neighbors
all_nodes_i = self.get_neighbor_nodes(best)
for node_i in all_nodes_i:
if node_i in done:
# both for p and for points that we've already done
continue
if boundary_only:
e = self.find_edge((best, node_i))
if self.edges[e, 2] < EdgeType.BOUNDARY:
continue
dist = np.sqrt(
((self._nodes[node_i] - self._nodes[best])**2).sum())
new_cost = best_cost + dist
if node_i not in queue:
queue[node_i] = np.inf
if queue[node_i] > new_cost:
queue[node_i] = new_cost
# reconstruct the path:
path = [n2]
while True:
node_i = path[-1]
if node_i == n1:
break
# figure out its neighbors
all_nodes_i = self.get_neighbor_nodes(node_i)
found_prev = False
for nbr in all_nodes_i:
if nbr == node_i or nbr not in done:
continue
dist = np.sqrt(
((self._nodes[node_i] - self._nodes[nbr])**2).sum())
if done[node_i] == done[nbr] + dist:
path.append(nbr)
found_prev = True
break
if found_prev is False:
return None
return np.array(path[::-1])
def shortest_path(self, n1, n2, boundary_only=False):
""" dijkstra on the edge graph from n1 to n2.
copied and modified form Rusty's code.
n1 = node_i for one end of the path
n2 = node_i for the other end
boundary_only = limit search to edges on the boundary (have
a -1 for element2)
"""
queue = pq.priorityDictionary()
queue[n1] = 0
done = {}
while True:
# find the queue-member with the lowest cost:
best = queue.smallest()
best_cost = queue[best]
del queue[best]
done[best] = best_cost
if best == n2:
# print "Found the ending point"
break
# figure out its neighbors
elems_i = list(self.get_elems_i_from_node(best))
all_nodes_i = np.unique(self._elems[elems_i])
for node_i in all_nodes_i:
if done.has_key(node_i):
# both for p and for points that we've already done
continue
if boundary_only:
e = self._find_edge((best, node_i))
if self._edges[e, 4] != BOUNDARY:
continue
dist = np.sqrt( ((self._nodes[node_i] \
- self._nodes[best])**2).sum() )
new_cost = best_cost + dist
if not queue.has_key(node_i):
queue[node_i] = np.inf
if queue[node_i] > new_cost:
queue[node_i] = new_cost
# reconstruct the path:
path = [n2]
while 1:
node_i = path[-1]
if node_i == n1:
break
# figure out its neighbors
elems = list(self.get_elems_i_from_node(node_i))
all_nodes_i = np.unique(self._elems[elems])
found_prev = 0
for nbr in all_nodes_i:
if nbr == node_i or not done.has_key(nbr):
continue
dist = np.sqrt( ((self._nodes[node_i] \
- self._nodes[nbr])**2).sum() )
if done[node_i] == done[nbr] + dist:
path.append(nbr)
found_prev = 1
break
if not found_prev:
return None
return np.array(path[::-1])
