def draw(self): background(0, 0, 0) # clear grid lists for i in range(0, self.numrows): for j in range(0, self.numcols): #self.grid[i][j] = list() del self.grid[i][j][:] # register agents in grid for agent in self.agents: row = int(agent.pos.y/self.gridsize) col = int(agent.pos.x/self.gridsize) self.grid[row][col].append(agent) agent_positions = list() for agent in self.agents: agent_positions.append(agent.pos) agent.draw() nearby = list() row = int(agent.pos.y/self.gridsize) col = int(agent.pos.x/self.gridsize) nearby.extend(self.grid[row % self.numrows-1][col % self.numcols-1]) nearby.extend(self.grid[row+1 % self.numrows-1][col+1 % self.numcols-1]) nearby.extend(self.grid[row+1 % self.numrows-1][col % self.numcols-1]) nearby.extend(self.grid[row % self.numrows-1][col+1 % self.numcols-1]) nearby.extend(self.grid[row-1 % self.numrows-1][col-1 % self.numcols-1]) nearby.extend(self.grid[row-1 % self.numrows-1][col % self.numcols-1]) nearby.extend(self.grid[row % self.numrows-1][col-1 % self.numcols-1]) nearby.extend(self.grid[row+1 % self.numrows-1][col-1 % self.numcols-1]) nearby.extend(self.grid[row-1 % self.numrows-1][col+1 % self.numcols-1]) if mousePressed: target = PVector(mouseX, mouseY) agent.seek(target) agent.cognate(nearby) agent.move() agent.reset_acceleration() # whoops v = voronoi.computeVoronoiDiagram(agent_positions) lines = v[1] vertices = v[0] stroke(255, 255, 255) for l in lines: v1index = l[1] v2index = l[2] if v1index != -1 and v2index != -1: p1 = vertices[v1index] p2 = vertices[v2index] line(p1[0], p1[1], p2[0], p2[1])
def plotVoronoi(points): results = voronoi.computeVoronoiDiagram(preparePoints(points)) curves = [] print "number of edges: "+str(len(results[2])) for edge in results[2]: if edge[1] != -1 and edge[2] != -1: startx = decimate(results[0][edge[1]][0]) starty = decimate(results[0][edge[1]][1]) endx = decimate(results[0][edge[2]][0]) endy = decimate(results[0][edge[2]][1]) startpoint = [startx, starty, 0] endpoint = [endx, endy, 0] curves.append(rs.AddLine(startpoint, endpoint)) return curves
def effect(self): #{{{ Check that elements have been selected if len(self.options.ids) == 0: inkex.errormsg(_("Please select objects!")) return #}}} #{{{ Drawing styles linestyle = { 'stroke' : '#000000', 'stroke-width' : str(self.unittouu('1px')), 'fill' : 'none' } facestyle = { 'stroke' : '#ff0000', 'stroke-width' : str(self.unittouu('1px')), 'fill' : 'none' } #}}} #{{{ Handle the transformation of the current group parentGroup = self.getParentNode(self.selected[self.options.ids[0]]) trans = self.getGlobalTransform(parentGroup) invtrans = None if trans: invtrans = simpletransform.invertTransform(trans) #}}} #{{{ Recovery of the selected objects pts = [] nodes = [] seeds = [] for id in self.options.ids: node = self.selected[id] nodes.append(node) bbox = simpletransform.computeBBox([node]) if bbox: cx = 0.5*(bbox[0]+bbox[1]) cy = 0.5*(bbox[2]+bbox[3]) pt = [cx,cy] if trans: simpletransform.applyTransformToPoint(trans,pt) pts.append(Point(pt[0],pt[1])) seeds.append(Point(cx,cy)) #}}} #{{{ Creation of groups to store the result if self.options.diagramType != 'Delaunay': # Voronoi groupVoronoi = inkex.etree.SubElement(parentGroup,inkex.addNS('g','svg')) groupVoronoi.set(inkex.addNS('label', 'inkscape'), 'Voronoi') if invtrans: simpletransform.applyTransformToNode(invtrans,groupVoronoi) if self.options.diagramType != 'Voronoi': # Delaunay groupDelaunay = inkex.etree.SubElement(parentGroup,inkex.addNS('g','svg')) groupDelaunay.set(inkex.addNS('label', 'inkscape'), 'Delaunay') #}}} #{{{ Clipping box handling if self.options.diagramType != 'Delaunay': #Clipping bounding box creation gBbox = simpletransform.computeBBox(nodes) #Clipbox is the box to which the Voronoi diagram is restricted clipBox = () if self.options.clipBox == 'Page': svg = self.document.getroot() w = self.unittouu(svg.get('width')) h = self.unittouu(svg.get('height')) clipBox = (0,w,0,h) else: clipBox = (2*gBbox[0]-gBbox[1], 2*gBbox[1]-gBbox[0], 2*gBbox[2]-gBbox[3], 2*gBbox[3]-gBbox[2]) #Safebox adds points so that no Voronoi edge in clipBox is infinite safeBox = (2*clipBox[0]-clipBox[1], 2*clipBox[1]-clipBox[0], 2*clipBox[2]-clipBox[3], 2*clipBox[3]-clipBox[2]) pts.append(Point(safeBox[0],safeBox[2])) pts.append(Point(safeBox[1],safeBox[2])) pts.append(Point(safeBox[1],safeBox[3])) pts.append(Point(safeBox[0],safeBox[3])) if self.options.showClipBox: #Add the clip box to the drawing rect = inkex.etree.SubElement(groupVoronoi,inkex.addNS('rect','svg')) rect.set('x',str(clipBox[0])) rect.set('y',str(clipBox[2])) rect.set('width',str(clipBox[1]-clipBox[0])) rect.set('height',str(clipBox[3]-clipBox[2])) rect.set('style',simplestyle.formatStyle(linestyle)) #}}} #{{{ Voronoi diagram generation if self.options.diagramType != 'Delaunay': vertices,lines,edges = voronoi.computeVoronoiDiagram(pts) for edge in edges: line = edge[0] vindex1 = edge[1] vindex2 = edge[2] if (vindex1 <0) or (vindex2 <0): continue # infinite lines have no need to be handled in the clipped box else: segment = self.clipEdge(vertices,lines,edge,clipBox) #segment = [vertices[vindex1],vertices[vindex2]] # deactivate clipping if len(segment)>1: v1 = segment[0] v2 = segment[1] cmds = [['M',[v1[0],v1[1]]],['L',[v2[0],v2[1]]]] path = inkex.etree.Element(inkex.addNS('path','svg')) path.set('d',simplepath.formatPath(cmds)) path.set('style',simplestyle.formatStyle(linestyle)) groupVoronoi.append(path) if self.options.diagramType != 'Voronoi': triangles = voronoi.computeDelaunayTriangulation(seeds) for triangle in triangles: p1 = seeds[triangle[0]] p2 = seeds[triangle[1]] p3 = seeds[triangle[2]] cmds = [['M',[p1.x,p1.y]], ['L',[p2.x,p2.y]], ['L',[p3.x,p3.y]], ['Z',[]]] path = inkex.etree.Element(inkex.addNS('path','svg')) path.set('d',simplepath.formatPath(cmds)) path.set('style',simplestyle.formatStyle(facestyle)) groupDelaunay.append(path)
def __init__(self, width, height): self.width = width self.height = height self.size = (width, height) spacing = 50 num_points = ((width * 3 ) * (height * 3) / spacing / spacing) # Randomly choose points corners = [ (0,0), (0, width - 1), (height - 1, width - 1), (height - 1, 0), ] points = set(corners) for _ in range(int(num_points * 5)): new_p = (random.randint(- width, width * 2), random.randint(- width, height * 2)) if all((distance(new_p, p) > spacing for p in points)): points.add(new_p) print num_points - len(points) else: print '*', for corner in corners: points.remove(corner) points = list(points) points.extend(corners) num_points = len(points) # # Spread points out using inverse-square repulsion # multiplier = 1500.0 # steps = int(num_points ** 2) # multiplier_step = 1.0 / steps # for _ in range(steps): # i = random.randint(0, num_points - 1 - len(corners)) # point = points[i] # force = [0, 0] # for j in range(num_points): # if j != i: # other = points[j] # dist = float(distance(point, other)) # other_force = 1.0 / float(dist * dist) # other_force = ( # (point[0] - other[0]) / dist * other_force, # (point[1] - other[1]) / dist * other_force) # force[0] += other_force[0] # force[1] += other_force[1] # points[i] = ( # point[0] + force[0] * multiplier, # point[1] + force[1] * multiplier) # multiplier -= multiplier_step # self.points = points # Generate voronoi diagram for points self.vpoints, self.vlines, self.vedges = voronoi.computeVoronoiDiagram(points) # # Generate Delaunay triangulation. Turns out that this doesn't # # look nearly as nice. # triangles = voronoi.computeDelaunayTriangulation(points) # self.vpoints = points # self.vedges = [] # for a, b, c in triangles: # self.vedges.append((None, a, b)) # self.vedges.append((None, b, c)) # self.vedges.append((None, c, a)) # generate adjacency mapping adjacency_map = {} def addNeighbor(k, v): pk = self.vpoints[k] pv = self.vpoints[v] if inside(pk, vec_mul(-.5, self.size), vec_mul(1.5, self.size)): adjacency_map.setdefault(k, set()).add(v) for l, p1, p2 in self.vedges: addNeighbor(p1, p2) addNeighbor(p2, p1) # straighten edges npoints = self.vpoints[:] straigtenings = [0] * len(npoints) spaz = [0.0] * len(npoints) todo = set(adjacency_map.keys()) spaz = [] for _ in range(len(todo) ** 2): if not todo: break try: i = random.choice(tuple(todo)) todo.remove(i) best = math.pi # Straighten any angle, even those that cut across another # angle. This can sometimes cause "straightening of the cross" neighbors = tuple(adjacency_map[i]) for j in neighbors: for k in neighbors: if j == k: continue # # Straighten angles only between neighbors that are "adjacent" # # when going around the circle. ie: "pie slice" angles. # neighbors = list(adjacency_map[i]) # neighbors.sort(key=lambda x:normangle(theta(npoints[i], npoints[x]))) # neighbors = tuple(neighbors) # for j_idx, j in enumerate(neighbors): # for k_idx in ((j_idx +1) % len(neighbors)), ((j_idx - 1) % len(neighbors)): # k = neighbors[k_idx] th_j = theta(npoints[i], npoints[j]) th_k = theta(npoints[i], npoints[k]) bent = abs(normangle(th_j - th_k) - math.pi) if bent < best: best = bent best_j = j best_k = k # # Straighten random angle # neighbors = tuple(adjacency_map[i]) # best_j, best_k = random.sample(neighbors, 2) new_point = project_on_segment(npoints[i], npoints[best_j], npoints[best_k]) if distance(new_point, npoints[i]) > 0.1: straigtenings[i] += 1 npoints[i] = new_point for neighbor in neighbors: if neighbor in adjacency_map: todo.add(neighbor) print len(todo) except KeyboardInterrupt: break self.npoints = npoints self.straigtenings = straigtenings self.todo = todo
def drawVoronoiDiagram(printToFile, gridSideLength,*highlightedPoints): global points; hPoints = [] if len(highlightedPoints) > 0: assert 0 == len(highlightedPoints) % 2 hPoints.append(Point(highlightedPoints[0],highlightedPoints[1])) hPoints.append(Point(highlightedPoints[2],highlightedPoints[3])) if printToFile: printMethod=goo(printToFile) else: printMethod=foo preamble(printMethod); printMethod('# SCALE %d' % (SCALE,)) printMethod('# GRID_SIDE_LENGTH %d' % (gridSideLength)) radius_x = SCALE/60; radius_y = radius_x; for point in points: if point in hPoints: printMethod('1 3 0 1 0 18 50 -1 20 0.000 1 0.0000 %d %d %d %d %d %d %d %d' % (SCALE*point.x, SCALE*point.y, radius_x, radius_y, SCALE*point.x-radius_x, SCALE*point.y, SCALE*point.x+radius_x, SCALE*point.y)) else: printMethod('1 3 0 1 0 0 50 -1 20 0.000 1 0.0000 %d %d %d %d %d %d %d %d' % (SCALE*point.x, SCALE*point.y, radius_x, radius_y, SCALE*point.x-radius_x, SCALE*point.y, SCALE*point.x+radius_x, SCALE*point.y)) #printMethod('4 0 0 0 0 0 1 0 0 1 1 %d %d 65 66 65 66 \ 0 0 1' % (SCALE*point.x, SCALE*point.y)) pencolorVoronoiEdge = 0 linestyleVoronoiEdge = -1 printMethod('2 1 %s 2 %s 7 50 -1 -1 0.000 0 0 -1 0 0 2' % (linestyleVoronoiEdge,pencolorVoronoiEdge)) printMethod('\t 0 0 0 %d' % (SCALE*gridSideLength,)) printMethod('2 1 %s 2 %s 7 50 -1 -1 0.000 0 0 -1 0 0 2' % (linestyleVoronoiEdge,pencolorVoronoiEdge)) printMethod('\t 0 0 %d 0' % (SCALE*gridSideLength,)) printMethod('2 1 %s 2 %s 7 50 -1 -1 0.000 0 0 -1 0 0 2' % (linestyleVoronoiEdge,pencolorVoronoiEdge)) printMethod('\t %d %d %d 0' % (SCALE*gridSideLength,SCALE*gridSideLength,SCALE*gridSideLength)) printMethod('2 1 %s 2 %s 7 50 -1 -1 0.000 0 0 -1 0 0 2' % (linestyleVoronoiEdge,pencolorVoronoiEdge)) printMethod('\t %d %d 0 %d' % (SCALE*gridSideLength,SCALE*gridSideLength,SCALE*gridSideLength)) vertices,lines,edges = voronoi.computeVoronoiDiagram(points) voronoiEdge = '2 1 %s 2 %s 7 50 -1 -1 0.000 0 0 -1 0 0 2' % (linestyleVoronoiEdge, pencolorVoronoiEdge) for line,v1,v2 in edges: if v1 != -1 and v2 != -1: printMethod(voronoiEdge) printMethod('\t %d %d %d %d' % (SCALE*vertices[v1][0], SCALE*vertices[v1][1], SCALE*vertices[v2][0], SCALE*vertices[v2][1])) points = [] def readTopologyFromFile(inFile): global points inHandle = open(inFile, 'r') for line in inHandle: if line.startswith('1 '): lineSplit = line.split() points.append(Point(float(lineSplit[12])/float(SCALE),float(lineSplit[13])/float(SCALE))) inHandle.close() def createTopology(numPoints,gridDimension): for point in range(numPoints): point = Point(default='yes') point.x = random.random()*gridDimension point.y = random.random()*gridDimension points.append(point) if __name__ == "__main__": """ The format of .fig files is described in http://www.xfig.org/userman/fig-format.html""" createTopology(150,5) drawVoronoiDiagram(None,5)
def computeVoronoiDiagram(): global points; return voronoi.computeVoronoiDiagram(points);
def effect(self): # Check that elements have been selected if not self.svg.selected: inkex.errormsg(_("Please select objects!")) return linestyle = { 'stroke': '#000000', 'stroke-width': str(self.svg.unittouu('1px')), 'fill': 'none', 'stroke-linecap': 'round', 'stroke-linejoin': 'round' } facestyle = { 'stroke': '#000000', 'stroke-width': str(self.svg.unittouu('1px')), 'fill': 'none', 'stroke-linecap': 'round', 'stroke-linejoin': 'round' } parent_group = self.svg.selection.first().getparent() trans = parent_group.composed_transform() invtrans = None if trans: invtrans = -trans # Recovery of the selected objects pts = [] nodes = [] seeds = [] fills = [] for node in self.svg.selected.values(): nodes.append(node) bbox = node.bounding_box() if bbox: center_x, center_y = bbox.center point = [center_x, center_y] if trans: point = trans.apply_to_point(point) pts.append(Point(*point)) if self.options.delaunayFillOptions != "delaunay-no-fill": fills.append(node.style.get('fill', 'none')) seeds.append(Point(center_x, center_y)) # Creation of groups to store the result if self.options.diagramType != 'Delaunay': # Voronoi group_voronoi = parent_group.add(Group()) group_voronoi.set('inkscape:label', 'Voronoi') if invtrans: group_voronoi.transform *= invtrans if self.options.diagramType != 'Voronoi': # Delaunay group_delaunay = parent_group.add(Group()) group_delaunay.set('inkscape:label', 'Delaunay') # Clipping box handling if self.options.diagramType != 'Delaunay': # Clipping bounding box creation group_bbox = sum([node.bounding_box() for node in nodes], None) # Clipbox is the box to which the Voronoi diagram is restricted if self.options.clip_box == 'Page': svg = self.document.getroot() width = self.svg.unittouu(svg.get('width')) height = self.svg.unittouu(svg.get('height')) clip_box = (0, width, 0, height) else: clip_box = (group_bbox.left, group_bbox.right, group_bbox.top, group_bbox.bottom) # Safebox adds points so that no Voronoi edge in clip_box is infinite safe_box = (2 * clip_box[0] - clip_box[1], 2 * clip_box[1] - clip_box[0], 2 * clip_box[2] - clip_box[3], 2 * clip_box[3] - clip_box[2]) pts.append(Point(safe_box[0], safe_box[2])) pts.append(Point(safe_box[1], safe_box[2])) pts.append(Point(safe_box[1], safe_box[3])) pts.append(Point(safe_box[0], safe_box[3])) if self.options.showClipBox: # Add the clip box to the drawing rect = group_voronoi.add(Rectangle()) rect.set('x', str(clip_box[0])) rect.set('y', str(clip_box[2])) rect.set('width', str(clip_box[1] - clip_box[0])) rect.set('height', str(clip_box[3] - clip_box[2])) rect.style = linestyle # Voronoi diagram generation if self.options.diagramType != 'Delaunay': vertices, lines, edges = voronoi.computeVoronoiDiagram(pts) for edge in edges: vindex1, vindex2 = edge[1:] if (vindex1 < 0) or (vindex2 < 0): continue # infinite lines have no need to be handled in the clipped box else: segment = self.clip_edge(vertices, lines, edge, clip_box) # segment = [vertices[vindex1],vertices[vindex2]] # deactivate clipping if len(segment) > 1: x1, y1 = segment[0] x2, y2 = segment[1] cmds = [['M', [x1, y1]], ['L', [x2, y2]]] path = group_voronoi.add(PathElement()) path.set('d', str(inkex.Path(cmds))) path.style = linestyle if self.options.diagramType != 'Voronoi': triangles = voronoi.computeDelaunayTriangulation(seeds) i = 0 if self.options.delaunayFillOptions == "delaunay-fill": random.seed("inkscape") for triangle in triangles: pt1 = seeds[triangle[0]] pt2 = seeds[triangle[1]] pt3 = seeds[triangle[2]] cmds = [['M', [pt1.x, pt1.y]], ['L', [pt2.x, pt2.y]], ['L', [pt3.x, pt3.y]], ['Z', []]] if self.options.delaunayFillOptions == "delaunay-fill" \ or self.options.delaunayFillOptions == "delaunay-fill-random": facestyle = { 'stroke': fills[triangle[random.randrange(0, 2)]], 'stroke-width': str(self.svg.unittouu('0.005px')), 'fill': fills[triangle[random.randrange(0, 2)]], 'stroke-linecap': 'round', 'stroke-linejoin': 'round' } path = group_delaunay.add(PathElement()) path.set('d', str(inkex.Path(cmds))) path.style = facestyle i += 1
def computeVoronoi(self): self.coords, self.equation, self.edges, self.bounds = computeVoronoiDiagram(self.control_points) self.voronoi = computeVoronoiDiagram(self.control_points) self.computePolys()
def update(self): # inputs if 'Edges' in self.outputs and self.outputs['Edges'].links or \ 'Vertices' in self.outputs and self.outputs['Vertices'].links: if 'Vertices' in self.inputs and self.inputs['Vertices'].links: points_in = SvGetSocketAnyType(self,self.inputs['Vertices']) pts_out = [] # polys_out = [] edges_out = [] for obj in points_in: pt_list = [] x_max = obj[0][0] x_min = obj[0][0] y_min = obj[0][1] y_max = obj[0][1] #creates points in format for voronoi library, throwing away z for pt in obj: x,y = pt[0],pt[1] x_max = max(x,x_max) x_min = min(x,x_min) y_max = max(y,y_max) y_min = min(x,x_min) pt_list.append(Site(pt[0],pt[1])) res = computeVoronoiDiagram(pt_list) edges = res[2] delta = self.clip x_max = x_max + delta y_max = y_max + delta x_min = x_min - delta y_min = y_min - delta #clipping box to bounding box. pts_tmp = [] for pt in res[0]: x,y=pt[0],pt[1] if x < x_min: x = x_min if x > x_max: x = x_max if y < y_min: y = y_min if y > y_max: y = y_max pts_tmp.append((x,y,0)) pts_out.append(pts_tmp) edges_out.append([ (edge[1], edge[2]) for edge in edges if -1 not in edge ]) # outputs if 'Vertices' in self.outputs and self.outputs['Vertices'].links: SvSetSocketAnyType(self, 'Vertices', pts_out) if 'Edges' in self.outputs and self.outputs['Edges'].links: SvSetSocketAnyType(self,'Edges',edges_out)
y.append(lat) ctx.init_geoscale(min(x), max(x) - min(x), min(y), max(y) - min(y)) ctx.set_antialias(cairo.ANTIALIAS_SUBPIXEL) ctx.set_line_width(0.3 * c.ctxscale) # see http://lists.cairographics.org/archives/cairo/2009-June/017459.html for drawing points for plz, (long, lat, name) in geoitems: ctx.move_to(*ctx.geoscale(long, lat)) ctx.close_path() ctx.stroke() pts = [] for plz, (long, lat, name) in geoitems: pts.append(voronoi.Site(long, lat)) points, lines, edges = voronoi.computeVoronoiDiagram(pts) pprint(points) pprint(lines) pprint(edges) ctx.set_line_width(0.1 * c.ctxscale) for (l, p1, p2) in edges: x1 = y1 = x2 = y2 = None if p1 > -1: x1, y1 = points[p1] if p2 > -1: x2, y2 = points[p2] if p1 > -1 and p2 > -1: print("(%f, %f) -> (%f, %f)" % (x1, y1, x2, y2))
def voronoi_tesselation(self, writer, provider, points): coords, equation, edges, bounds = voronoi.computeVoronoiDiagram(points) all_attrs = provider.attributeIndexes() provider.select(all_attrs) feat = QgsFeature() count = 0 for index, v1, v2 in edges: a, b, c = equation[index] x_0, y_0 = coords[v1] x_1, y_1 = coords[v2] if (v1 < 0 and x_1 in bounds and y_1 in bounds) or (v2 < 0 and x_0 in bounds and y_0 in bounds): continue if v1 < 0: if a == 1.0: if b < 0: y = bounds[1] else: y = bounds[3] x = c - b * y if x < bounds[0] or x > bounds[2]: if x < bounds[0]: x = bounds[0] elif x > bounds[2]: x = bounds[2] y = (c - a * x) / b else: # b == 1.0 if a > 0: y = bounds[3] else: y = bounds[1] x = (c - b * y) / a if x < bounds[0] or x > bounds[2]: if x < bounds[0]: x = bounds[0] elif x > bounds[2]: x = bounds[2] y = (c - a * x) / b x_0 = x y_0 = y elif v2 < 0: if a == 1.0: if b > 0: y = bounds[1] else: y = bounds[3] x = c - b * y if x < bounds[0] or x > bounds[2]: if x < bounds[0]: x = bounds[0] elif x > bounds[2]: x = bounds[2] y = (c - a * x) / b else: # b == 1.0 if a < 0: x = bounds[0] else: x = bounds[2] y = (c - a * x) / b if y < bounds[1] or y > bounds[3]: if y < bounds[1]: y = bounds[1] elif y > bounds[3]: y = bounds[3] x = (c - y * b) / a x_1 = x y_1 = y line = [QgsPoint(x_0, y_0), QgsPoint(x_1, y_1)] geometry = QgsGeometry().fromPolyline(line) feat.addAttribute(0, QVariant(count)) feat.addAttribute(1, QVariant(a)) feat.addAttribute(2, QVariant(b)) feat.addAttribute(3, QVariant(c)) feat.addAttribute(4, QVariant(v1)) feat.addAttribute(5, QVariant(v2)) feat.setGeometry(geometry) writer.addFeature(feat) count += 1 rect = [ QgsPoint(bounds[0], bounds[1]), QgsPoint(bounds[2], bounds[1]), QgsPoint(bounds[2], bounds[3]), QgsPoint(bounds[0], bounds[3]), QgsPoint(bounds[0], bounds[1]), ] geometry = QgsGeometry().fromPolyline(rect) feat.setGeometry(geometry) writer.addFeature(feat) del writer
def computeVoronoi(self): self.coords, self.equation, self.edges, self.bounds = computeVoronoiDiagram( self.control_points) self.voronoi = computeVoronoiDiagram(self.control_points) self.computePolys()
def update(self): # inputs if 'Edges' in self.outputs and self.outputs['Edges'].links or \ 'Vertices' in self.outputs and self.outputs['Vertices'].links: if 'Vertices' in self.inputs and self.inputs['Vertices'].links: points_in = SvGetSocketAnyType(self, self.inputs['Vertices']) pts_out = [] # polys_out = [] edges_out = [] for obj in points_in: pt_list = [] x_max = obj[0][0] x_min = obj[0][0] y_min = obj[0][1] y_max = obj[0][1] #creates points in format for voronoi library, throwing away z for pt in obj: x, y = pt[0], pt[1] x_max = max(x, x_max) x_min = min(x, x_min) y_max = max(y, y_max) y_min = min(x, x_min) pt_list.append(Site(pt[0], pt[1])) res = computeVoronoiDiagram(pt_list) edges = res[2] delta = self.clip x_max = x_max + delta y_max = y_max + delta x_min = x_min - delta y_min = y_min - delta #clipping box to bounding box. pts_tmp = [] for pt in res[0]: x, y = pt[0], pt[1] if x < x_min: x = x_min if x > x_max: x = x_max if y < y_min: y = y_min if y > y_max: y = y_max pts_tmp.append((x, y, 0)) pts_out.append(pts_tmp) edges_out.append([(edge[1], edge[2]) for edge in edges if -1 not in edge]) # outputs if 'Vertices' in self.outputs and self.outputs['Vertices'].links: SvSetSocketAnyType(self, 'Vertices', pts_out) if 'Edges' in self.outputs and self.outputs['Edges'].links: SvSetSocketAnyType(self, 'Edges', edges_out)
def update(self): # inputs points_in = [] if 'Vertices' in self.inputs and len(self.inputs['Vertices'].links)>0: if not self.inputs['Vertices'].node.socket_value_update: self.inputs['Vertices'].node.update() points_in = eval(self.inputs['Vertices'].links[0].from_socket.VerticesProperty) pts_out = [] # polys_out = [] edges_out = [] for obj in points_in: pt_list = [] x_max = obj[0][0] x_min = obj[0][0] y_min = obj[0][1] y_max = obj[0][1] #creates points in format for voronoi library, throwing away z for pt in obj: x,y = pt[0],pt[1] x_max = max(x,x_max) x_min = min(x,x_min) y_max = max(y,y_max) y_min = min(x,x_min) pt_list.append(Site(pt[0],pt[1])) res = computeVoronoiDiagram(pt_list) edges = res[2] delta = self.clip x_max = x_max + delta y_max = y_max + delta x_min = x_min - delta y_min = y_min - delta #clipping box to bounding box I think. pts_tmp = [] for pt in res[0]: x,y=pt[0],pt[1] if x < x_min: x = x_min if x > x_max: x = x_max if y < y_min: y = y_min if y > y_max: y = y_max pts_tmp.append((x,y,0)) pts_out.append(pts_tmp) edges_out.append([ (edge[1], edge[2]) for edge in edges if -1 not in edge ]) # outputs if 'Vertices' in self.outputs and len(self.outputs['Vertices'].links)>0: if not self.outputs['Vertices'].node.socket_value_update: self.outputs['Vertices'].node.update() self.outputs['Vertices'].VerticesProperty = str(pts_out) if 'Edges' in self.outputs and len(self.outputs['Edges'].links)>0: if not self.outputs['Edges'].node.socket_value_update: self.outputs['Edges'].node.update() self.outputs['Edges'].StringsProperty = str(edges_out)
def calc_voronoi(self,points): v = voronoi.computeVoronoiDiagram(points) for l in v[2]: c = (v[0][l[1]][0], v[0][l[1]][1], v[0][l[2]][0], v[0][l[2]][1]) if c[0] > 0 and c[0] < self.map_width and c[1] > 0 and c[1] < self.map_height and c[2] > 0 and c[2] < self.map_width and c[3] > 0 and c[3] < self.map_height: self.draw_line(c,(0,0,0))