def find_all_intersection(street_list):
intersection_list = []
tmp_street_list = street_list.copy()
for key_main, value_main in street_list.iteritems():
index_main = 0
tmp_street_list.pop(key_main)
for ponits_main in value_main:
if index_main <= (len(value_main)-2):
src = intersect.Point(value_main[index_main][0], value_main[index_main][1])
dst = intersect.Point(value_main[index_main+1][0], value_main[index_main+1][1])
index_main = index_main+1
l1 = intersect.Line(src, dst)
for key_sub, value_sub in tmp_street_list.iteritems():
index_sub = 0
for points_sub in value_sub:
if index_sub <= (len(value_sub) - 2):
src = intersect.Point(value_sub[index_sub][0], value_sub[index_sub][1])
dst = intersect.Point(value_sub[index_sub + 1][0], value_sub[index_sub + 1][1])
l2 = intersect.Line(src, dst)
intersect_point = intersect.intersect(l1,l2)
index_sub = index_sub + 1
if intersect_point != None and type(intersect_point) != list and (not check_exist_point(intersection_list,intersect_point)):
intersection_list.append((intersect_point.x,intersect_point.y))
elif intersect_point != None and type(intersect_point) == list:
for i in range(0, len(intersect_point)):
tmp_point = intersect.Point(intersect_point[i][0],intersect_point[i][1])
if not check_exist_point(intersection_list,tmp_point):
intersection_list.append((tmp_point.x,tmp_point.y))
return intersection_list
def add(self, f2):
f = []
for block1 in self.blocks[1]:
for block2 in f2:
a = intersect(block1[0], block2[0])
for s in a:
f.append((s, block1[1] + block2[1]))
return f
def __test_intersect(self, i, j):
if i in self.sentinels or j in self.sentinels:
return
pair = (i, j) if i < j else (j, i) # i, j may tip over on processing.
if self.reported[pair]:
return
x, y = intersect(self.segs[i], self.segs[j])
if x:
insort(self.events, ((x, y), (i, j), None)) # swap-event
self.reported[pair] = True
return (x, y)
def setpot(pot, evvariables, evidstates):
#FIXME: data format needed to be unified
vars = pot.variables
#vars = np.array(pot.variables) # convert to ndarray format
#evariables = np.array(evvariables)
# convert to ndarray format
#evidstates = np.array(evidstates) # convert to ndarray format
#print "variables:", vars
table = pot.table
nstates = pot.card
#print "number of states:", nstates
#print "vars:", vars
#print "evvariables:", evvariables
intersection, iv, iev = intersect(vars, evvariables)
#iv = np.array(iv)
#iev = np.array(iev)
#print "intersection:", intersection
#print "iv:", iv
#print "iev:", iev
#print "iv type:", type(iv)
#print "number of intersection:", intersection.size
if intersection.size == 0:
newpot = copy.copy(pot)
else:
newvar = setminus(vars, intersection)
dummy, idx = ismember(newvar, vars)
newns = nstates[idx]
newpot = potential()
newpot.variables = newvar
newpot.card = newns
newpot.table = np.zeros(newns)
#print "idx:", idx
#print "iv:", iv
for i in range(np.prod(newns)):
newassign = IndexToAssignment(i, newns)
oldassign = np.zeros(nstates.size, 'int8')
oldassign[idx] = newassign
oldassign[iv] = evidstates
#print "newpot.table.shape:", newpot.table.shape
#print "newassign:", newassign
#print "newassign type:", type(newassign)
newpot.table[tuple(newassign)] = pot.table[tuple(oldassign)]
return newpot
def setpot(pot, evvariables, evidstates):
#FIXME: data format needed to be unified
vars = pot.variables
#vars = np.array(pot.variables) # convert to ndarray format
#evariables = np.array(evvariables)
# convert to ndarray format
#evidstates = np.array(evidstates) # convert to ndarray format
#print "variables:", vars
table = pot.table
nstates = pot.card
#print "number of states:", nstates
#print "vars:", vars
#print "evvariables:", evvariables
intersection, iv, iev = intersect(vars, evvariables)
#iv = np.array(iv)
#iev = np.array(iev)
#print "intersection:", intersection
#print "iv:", iv
#print "iev:", iev
#print "iv type:", type(iv)
#print "number of intersection:", intersection.size
if intersection.size == 0:
newpot = copy.copy(pot)
else:
newvar = setminus(vars, intersection)
dummy, idx = ismember(newvar, vars)
newns = nstates[idx]
newpot = potential()
newpot.variables = newvar
newpot.card = newns
newpot.table = np.zeros(newns)
#print "idx:", idx
#print "iv:", iv
for i in range(np.prod(newns)):
newassign = IndexToAssignment(i, newns)
oldassign = np.zeros(nstates.size, 'int8')
oldassign[idx] = newassign
oldassign[iv] = evidstates
#print "newpot.table.shape:", newpot.table.shape
#print "newassign:", newassign
#print "newassign type:", type(newassign)
newpot.table[tuple(newassign)] = pot.table[tuple(oldassign)]
return newpot
def condpot(pot, varargin):
#FIXME: only 1 varargin supported , use *arg in further development
newpot = potential()
y = []
x = varargin
#print "pot.variables:", pot.variables
#print "pot.table: \n", pot.table
#print "x:", x
#print "pot.variables:", pot.variables
# convert variable to idx (not consistent in Python other than MATLAB)
intersection, ix, ipot = intersect(x, pot.variables)
#print "intersection=", intersection
newpot.variables = intersection
#print "pot.variables:", pot.variables
FULL_axis = np.arange(pot.variables.size)
#print pot.variables
#print intersection
axis_intersection = ipot
#.index(intersection)
other_axis = setminus(FULL_axis, axis_intersection)
#print "axis_intersection=", axis_intersection
#print "other_axis=", other_axis
#print "Full_axis:", FULL_axis
#print "other_axis:", other_axis
newpot.table = np.apply_over_axes(np.sum, pot.table, other_axis)
#print "newpot.variables:", newpot.variables
#print "newpot.table: \n", newpot.table
SUM = potential()
SUM.variables = np.array([])
SUM.table = np.sum(newpot.table)
#print "newpot.table:", newpot.table
#print "SUM.table:", SUM.table
newpot = newpot / SUM
return newpot
def condpot(pot,varargin):
#FIXME: only 1 varargin supported , use *arg in further development
newpot = potential()
y = []
x = varargin
#print "pot.variables:", pot.variables
#print "pot.table: \n", pot.table
#print "x:", x
#print "pot.variables:", pot.variables
# convert variable to idx (not consistent in Python other than MATLAB)
intersection, ix, ipot = intersect(x, pot.variables)
#print "intersection=", intersection
newpot.variables = intersection
#print "pot.variables:", pot.variables
FULL_axis = np.arange(pot.variables.size)
#print pot.variables
#print intersection
axis_intersection = ipot
#.index(intersection)
other_axis = setminus(FULL_axis,axis_intersection)
#print "axis_intersection=", axis_intersection
#print "other_axis=", other_axis
#print "Full_axis:", FULL_axis
#print "other_axis:", other_axis
newpot.table = np.apply_over_axes(np.sum, pot.table, other_axis)
#print "newpot.variables:", newpot.variables
#print "newpot.table: \n", newpot.table
SUM = potential()
SUM.variables = np.array([])
SUM.table = np.sum(newpot.table)
#print "newpot.table:", newpot.table
#print "SUM.table:", SUM.table
newpot = newpot/SUM
return newpot
while not close:
for event in pygame.event.get():
if event.type == pygame.QUIT:
close = True
disp.fill(black)
pygame.display.update()
# Mouse locations
(loc_x, loc_y) = pygame.mouse.get_pos()
x1 = 100
y1 = 300
x2 = loc_x
y2 = loc_y
draw_cirle(x1, y1)
draw_walls(walls_x1, walls_y1, walls_x2, walls_y2)
if intersect(x1, y1, x2, y2, walls_x1, walls_y1, walls_x2, walls_y2):
draw_rays(x1, y1, x2, y2)
px, py = intersect(x1, y1, x2, y2, walls_x1, walls_y1, walls_x2,
walls_y2)
pygame.draw.circle(disp, white, (px, py), 5)
pygame.display.update()
import os
import DXFtoPostgis
from connectionData import *
import db
import intersect, Output
tablesKm = db.ImportShpToPostgres(DB, pathKm, field, field1, field2) #import kat. map; dostanem zoznam importovanych Km >> bude len jedna
print tablesKm
files = ([name for name in os.listdir(pathCad)]) # prejde vsetky subory v zadanom adresary
count = 0
cadTables = []
for file in files:
if file.endswith('.dxf'):
count = count + 1
fileName = file # nazov dxf suboru
name = fileName.split(".")[0]
cadTables.append(name)
importDxfToPostgres = DXFtoPostgis.dxfToPostgis(name, fileName)
print cadTables
for tab in tablesKm:
for tab2 in cadTables:
intersect = intersect.intersect(tab, tab2)
rows = intersect[0]
nam = intersect[1]
output = Output.Output(rows, nam)
def predict(self, traces):
print("Taces", traces)
# Create tracegroups
print("Creating tracegroups")
overlap_pairs = set()
for i, trace in enumerate(traces[:-1]):
for j, trace2 in enumerate(traces[i + 1:]):
for coord1 in trace:
for coord2 in trace2:
if math.hypot(coord2[0] - coord1[0],
coord2[1] - coord1[1]) < 10:
overlap_pairs.add((i, i + j + 1))
# Check lines between endpoints
overlap = intersect.intersect(trace[0], trace[-1], trace2[0],
trace2[-1])
print("End to end overlap", overlap)
if (overlap):
overlap_pairs.add((i, i + j + 1))
print("overlap_pairs", overlap_pairs)
if len(overlap_pairs) > 0:
tracegroups = self.create_tracegroups(overlap_pairs)
else:
tracegroups = []
# Add single traces to a tracegroup
for i, trace in enumerate(traces):
found = False
for group in tracegroups:
if i in group:
found = True
if not found:
tracegroups.append(set([i]))
sorted_tracegroups = sorted(tracegroups, key=lambda m: next(iter(m)))
print(sorted_tracegroups)
'''
line1_cycle = cycle(trace)
next(line1_cycle)
line2_cycle = cycle(trace2)
next(line2_cycle)
for k, coords in enumerate(trace[:-1]):
coord_A = coords
coord_B = next(line1_cycle)
coord_C = trace2[k]
coord_D = next(line2_cycle)
#print(coord_A, coord_B, coord_C, coord_D)
if intersect.intersect(coord_A, coord_B, coord_C, coord_D):
#print("i", i)
print("Intersect", coord_A, coord_B, coord_C, coord_D)
'''
predictions = []
for group in sorted_tracegroups:
# lots of copying, TODO optimalize
res = [traces[i] for i in list(group)]
res_processed = self.pre_process(res)
prediction = self.model.predict(res_processed,
steps=1,
batch_size=None,
verbose=1)
best_pred = (0, 0)
for i, p in enumerate(prediction[0]):
print("Predicted: ", classes[i], "as", p)
if p > best_pred[1]:
best_pred = (i, p)
predictions.append(best_pred)
''' res = self.pre_process(traces)
prediction = self.model.predict_classes(res, batch_size=1, verbose=1)
print("Prediction", prediction)
for i, p in enumerate(prediction[0]):
print("Predicted: ", classes[i], "as", p)
if p > best_pred[1]:
best_pred = (i, p)
'''
to_return = []
for p in predictions:
to_return.append((classes[p[0]], p[1]))
return to_return
def generateGraph(self):
points_dict = {}
#print 'street dict ---------------------',self.street_dict
for key in self.street_dict:
i = 0
point_list = []
while i < len(self.street_dict[key]):
point = intersect.Point(self.street_dict[key][i][0],
self.street_dict[key][i][1])
i += 1
point_list.append(point)
points_dict[key] = point_list
lines_dict = {}
complete_lines = []
for key in points_dict:
i = 0
line_list = []
while i < len(points_dict[key]) - 1:
#print points_dict[key][i]
#print points_dict[key][i+1]
line = intersect.Line(points_dict[key][i],
points_dict[key][i + 1])
#print line
#line = intersect.Line(self.street_dict[key][0],self.street_dict[key][1])
i += 1
line_list.append(line)
lines_dict[key] = line_list
complete_lines.append(line_list)
#find intersect
final_intersects = []
final_edges = []
intersection_points = []
#print "length :"+str(len(complete_lines))
for i in range(0, len(complete_lines)):
for k in range(i + 1, len(complete_lines)):
for j in range(0, len(complete_lines[i])):
for m in range(0, len(complete_lines[k])):
#print "before function call"
point = intersect.intersect(complete_lines[i][j],
complete_lines[k][m])
if (point != -1):
final_intersects = final_intersects + point[0]
final_edges = final_edges + point[1]
if len(point) == 3:
intersection_points.append(point[2])
#print final_intersects
intersections = []
for i in intersection_points:
intersections.append(i[0])
#print final_edges
#print "intersections ::",intersections
new_edges = []
for edge in final_edges:
for vertex in intersections:
isBetween = self.isVertexInBetween(edge[0], edge[1], vertex)
if isBetween and edge[0] != vertex and edge[1] != vertex:
new_edge1 = [edge[0], vertex]
new_edge2 = [edge[1], vertex]
new_edges.append(new_edge1)
new_edges.append(new_edge2)
#print "new edges ",new_edges
final_edges = final_edges + new_edges
edges_remove_dup = []
#edges_remove_dup.extend(final_edges)
#print "edges_remove_dup before-------->",edges_remove_dup
for a in final_edges:
l = [a[1], a[0]]
if a not in edges_remove_dup and l not in edges_remove_dup and l != a:
edges_remove_dup.append(a)
#print "edges_remove_dup after-------->",edges_remove_dup
b_set = set(
(map(tuple, edges_remove_dup))
) #need to convert the inner lists to tuples so they are hashable
b = map(list, b_set)
#print "intersection points :::::",intersection_points
#final_intersects = [(0.0,0.0)]
self.getVerticesOutput(final_intersects)
self.getEdgesOutput(b, intersection_points,
list(set(final_intersects)))
