def map_to_polygon(shape,origin,position,rotation,size): geom_obj=Polygon(shape) geom_obj=affinity.translate(geom_obj, -origin[0],-origin[1],0) geom_obj=affinity.scale(geom_obj,size[0],size[1],origin=(0,0)) geom_obj=affinity.rotate(geom_obj,int(rotation*360),origin=(0,0)) geom_obj=affinity.translate(geom_obj, position[0],position[1],0) return geom_obj
def main(infile, outfile, driver): with fio.open(infile) as src: meta = src.meta meta['driver'] = driver with fio.open(infile) as src, fio.open(outfile, 'w', **meta) as dst: with click.progressbar(src) as features: for feat in features: east = deepcopy(feat) west = deepcopy(feat) east_geom = shape(east['geometry']) west_geom = shape(west['geometry']) # if 'Point' not in asShape(feat['geometry']).type: # east_geom = east_geom.simplify(0.0001).buffer(0) # west_geom = west_geom.simplify(0.0001).buffer(0) east_geom = translate(east_geom, xoff=180) west_geom = translate(west_geom, xoff=-180) if not east_geom.is_empty: east['geometry'] = mapping(east_geom) dst.write(east) if not west_geom.is_empty: west['geometry'] = mapping(west_geom) dst.write(west)
def _refine_predug(self, candidate): """ uses the color information directly to specify the predug """ # determine a bounding rectangle region = candidate.bounds size = max(region.width, region.height) region.buffer(0.5 * size) # < increase by 50% in each direction # extract the region from the image slice_x, slice_y = region.slices img = self.image[slice_y, slice_x].astype(np.uint8, copy=True) # build the estimate polygon poly_p = affinity.translate(candidate.polygon, -region.x, -region.y) poly_s = affinity.translate(self.ground.get_sky_polygon(), -region.x, -region.y) def fill_mask(color, margin=0): """ fills the mask with the buffered regions """ for poly in (poly_p, poly_s): pts = np.array(poly.buffer(margin).boundary.coords, np.int32) cv2.fillPoly(mask, [pts], color) # prepare the mask for the grabCut algorithm burrow_width = self.params["burrows/width"] mask = np.full_like(img, cv2.GC_BGD, dtype=np.uint8) # < sure background fill_mask(cv2.GC_PR_BGD, 0.25 * burrow_width) # < possible background fill_mask(cv2.GC_PR_FGD, 0) # < possible foreground fill_mask(cv2.GC_FGD, -0.25 * burrow_width) # < sure foreground # run GrabCut algorithm img = cv2.cvtColor(img, cv2.COLOR_GRAY2RGB) bgdmodel = np.zeros((1, 65), np.float64) fgdmodel = np.zeros((1, 65), np.float64) try: cv2.grabCut(img, mask, (0, 0, 1, 1), bgdmodel, fgdmodel, 2, cv2.GC_INIT_WITH_MASK) except: # any error in the GrabCut algorithm makes the whole function useless logging.warn("GrabCut algorithm failed for predug") return candidate # turn the sky into background pts = np.array(poly_s.boundary.coords, np.int32) cv2.fillPoly(mask, [pts], cv2.GC_BGD) # extract a binary mask determining the predug predug_mask = (mask == cv2.GC_FGD) | (mask == cv2.GC_PR_FGD) predug_mask = predug_mask.astype(np.uint8) # simplify the mask using binary operations w = int(0.5 * burrow_width) kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (w, w)) predug_mask = cv2.morphologyEx(predug_mask, cv2.MORPH_OPEN, kernel) # extract the outline of the predug contour = regions.get_contour_from_largest_region(predug_mask) # translate curves back into global coordinate system contour = curves.translate_points(contour, region.x, region.y) return shapes.Polygon(contour)
def crop_line(line,pts_array): line_start,line_end=list(line.coords) line_start=Point(line_start); line_end=Point(line_end) x=(line_start.x-line_end.x)/line.length y=(line_start.y-line_end.y)/line.length center=line.centroid pts=pts_array-np.array([center.x,center.y]) pts=pts[:,0]*x+pts[:,1]*y return pts2line([translate(center,xoff=(np.min(pts)*x), yoff=np.min(pts)*y),translate(center,xoff=(np.max(pts)*x), yoff=np.max(pts)*y)])
def fit_shape(shape, width, height, padding=0): width -= padding * 2 height -= padding * 2 x1, y1, x2, y2 = shape.bounds w, h = x2 - x1, y2 - y1 s = min(width / w, height / h) shape = translate(shape, -x1, -y1) shape = scale(shape, s, s, origin=(0, 0, 0)) shape = translate(shape, padding, padding) return shape
def findIntersect( ): time, max_area, max_time = 0.0, 0.0, 0.0 while time < 5: time+=.001 temp = asteroid1.asteroid.intersection(asteroid2.asteroid).area if temp > max_area: max_area = temp max_time = time asteroid1.asteroid = translate(asteroid1.asteroid, asteroid1.velocity[0]*.001, asteroid1.velocity[1]*.001) asteroid2.asteroid = translate(asteroid2.asteroid, asteroid2.velocity[0]*.001, asteroid2.velocity[1]*.001) return max_time
def clip_geometry_to_srs_bounds(geometry, pyramid, multipart=False): """ Clip input geometry to SRS bounds of given TilePyramid. If geometry passes the antimeridian, it will be split up in a multipart geometry and shifted to within the SRS boundaries. Note: geometry SRS must be the TilePyramid SRS! - geometry: any shapely geometry - pyramid: a TilePyramid object - multipart: return list of geometries instead of a GeometryCollection """ try: assert geometry.is_valid except AssertionError: raise ValueError("invalid geometry given") try: assert isinstance(pyramid, TilePyramid or MetaTilePyramid) except AssertionError: raise ValueError("not a TilePyramid object") pyramid_bbox = box( pyramid.left, pyramid.bottom, pyramid.right, pyramid.top) # Special case for global tile pyramids if geometry extends over tile # pyramid boundaries (such as the antimeridian). if pyramid.is_global and not geometry.within(pyramid_bbox): inside_geom = geometry.intersection(pyramid_bbox) outside_geom = geometry.difference(pyramid_bbox) # shift outside geometry so it lies within SRS bounds if isinstance(outside_geom, Polygon): outside_geom = [outside_geom] all_geoms = [inside_geom] for geom in outside_geom: geom_left = geom.bounds[0] geom_right = geom.bounds[2] if geom_left < pyramid.left: geom = translate(geom, xoff=2*pyramid.right) elif geom_right > pyramid.right: geom = translate(geom, xoff=-2*pyramid.right) all_geoms.append(geom) if multipart: return all_geoms else: return GeometryCollection(all_geoms) else: if multipart: return [geometry] else: return geometry
def wrap_americas(self, wrapping_point=-50): new_mp = [] try: for i, p in enumerate(self.patch): if min(p.envelope.exterior.xy[0]) < wrapping_point or\ max(p.envelope.exterior.xy[0]) < wrapping_point: new_mp.append(translate(p, xoff=360.)) else: new_mp.append(p) self.patch = MultiPolygon(new_mp) except TypeError: if self.get_maxx() < wrapping_point or\ self.get_minx() < wrapping_point: self.patch = translate(self.patch, xoff=360.)
def load_letters(letters): x = 0.0 s = 1.82748538 p = 0.125 polygons = [] for letter in letters: polygon = load_letter(letter) polygon = scale(polygon, s, s) x1, y1, x2, y2 = polygon.bounds polygon = translate(polygon, -x1, -y1) polygon = translate(polygon, x) x += (x2 - x1) + p polygons.append(polygon) print polygon.bounds return MultiPolygon(polygons)
def move(self, x3_offset, alt_layer=False): """Translate a layer in the vertical (x3) direction.""" # translate the polygon self.polygon = translate(self.polygon, yoff=x3_offset) # translate the corners for i in range(len(self.corners)): new_corner = translate(self.corners[i], yoff=x3_offset) self.corners[i] = new_corner if not alt_layer: # in a regular layer, update the left, right, top, and bottom edges # so they will be translated too self.get_and_save_edges() else: # in an alt layer, translate the edges for edge in self.edges: edge[:,1] += x3_offset
def _load_shapefile(self, shp, index_field, convert_coordinates, remove_offset, simplify): df = shp2df(shp) if index_field is not None: df.index = df[index_field] proj4 = get_proj4(shp) if proj4 != self.proj4: df['geometry'] = projectdf(df, proj4, self.proj4) # convert projected coordinate units and/or get rid z values if the shapefile has them if convert_coordinates != 1 or df.iloc[0]['geometry'].has_z: df['geometry'] = [transform(lambda x, y, z=None: (x * convert_coordinates, y * convert_coordinates), g) for g in df.geometry] # remove model offset from projected coordinates (llcorner = 0,0) if remove_offset: df['geometry'] = [translate(g, -1 * self.extent_proj[0], -1 * self.extent_proj[1]) for g in df.geometry] if simplify > 0: df['geometry'] = [g.simplify(simplify) for g in df.geometry] return df
def tile(self, tile_builder, offset, max_width, max_height, polygon_mask=None): """Extract a tile from the image Parameters ---------- tile_builder: TileBuilder A tile builder for constructing the Tile object offset: (int, int) The (x, y) coordinates of the pixel at the origin point of the tile in the parent image max_width: int The maximum width of the tile max_height: int The maximum height of the tile polygon_mask: Polygon (optional, default: None) The polygon representing the alpha mask to apply to the image window. The polygon must be referenced to the full image top-left pixel. Returns ------- tile: Tile The extracted tile Raises ------ IndexError: if the offset is not inside the image TileExtractionException: if the tile cannot be extracted """ if not self._check_tile_offset(offset): raise IndexError("Offset {} is out of the image.".format(offset)) width = min(max_width, self.width - offset[0]) height = min(max_height, self.height - offset[1]) translated_polygon = translate(polygon_mask, -offset[0], -offset[1]) if polygon_mask is not None else None return tile_builder.build(self, offset, width, height, polygon_mask=translated_polygon)
def module_third(wafer_size, ncells, module_center=Point((0,0)), module_id=0, triggercell_size=1): # Compute the cell grid length for 1/3 of a module grid_size = int(math.sqrt(ncells/3)) # This geometry is of the rotated type # The wafer size below is the vertex to vertex distance # The cell size is the edge to edge distance cell_size = wafer_size/grid_size/2. # Create grid of cells along the usual hexagon axes (60deg rotated axes) grid_generator = GridGenerator('diamond', grid_size) reference_position = translate(module_center, xoff=-cell_size*(grid_size-1), yoff=cell_size*tan30) cell_centers = grid_generator(reference_position, cell_size) # Create cells corresponding to 1/3 of a module hex_generator = HexagonGenerator(cell_size*tan30) cell_transform = CellTransform(cell_size, grid_size) cell_vertices = [cell_transform(i)(hex_generator(point)) for i,point in enumerate(cell_centers)] # Merge cells in trigger cells if requested if triggercell_size>1: cell_vertices = trigger_cells(cell_vertices, size=triggercell_size) cell_centers = [c.centroid for c in cell_vertices] cells = [] for i,(vertices,center) in enumerate(zip(cell_vertices,cell_centers)): cells.append(Cell( id=compute_id(module=module_id, third=0, cell=i), layer=1, zside=1, subdet=3, module=module_id, center=center, vertices=vertices )) return cells
def valid_edge(self, state, primitive, plot = True): bounding_poly = affinity.rotate(primitive.bounding_poly, state[2], origin = (0.0, 0.0), use_radians = True) bounding_poly = affinity.translate(bounding_poly, state[0], state[1]) #Drawing Primitive-TAKE OUT TODO if plot: if bounding_poly.intersects(self.world_polys): color = 'r' else: color = 'b' fig = plt.figure(2) fig.clear() plt.ion() ax = fig.add_subplot(111, aspect = 'equal') for poly in self.world_polys: P = PolygonPatch(poly, fc = 'k', zorder = 2) ax.add_patch(P) P = PolygonPatch(bounding_poly, fc = color, ec = '#999999', alpha = 1, zorder = 1) polyPatch = ax.add_patch(P) ax.set_xlim(0,50) ax.set_ylim(0,50) fig.show() plt.pause(0.1) #pdb.set_trace() if bounding_poly.intersects(self.world_polys): return False return True
def window(self, offset, max_width, max_height, polygon_mask=None): """Build an image object representing a window of the image Parameters ---------- offset: (int, int) The (x, y) coordinates of the pixel at the origin point of the window in the parent image max_width: int The maximum width of the window max_height: int The maximum height of the window polygon_mask: Polygon (optional, default: None) The polygon representing the alpha mask to apply to the image window. The polygon must be referenced to the full image top-left pixel. Returns ------- window: ImageWindow The resulting image window """ # width are bound to the current window size, not the parent one width = min(max_width, self.width - offset[0]) height = min(max_height, self.height - offset[1]) translated_polygon = translate(polygon_mask, -offset[0], -offset[1]) if polygon_mask is not None else None return ImageWindow(self, offset, width, height, polygon_mask=translated_polygon)
def test_translate(self): ls = load_wkt('LINESTRING(240 400 10, 240 300 30, 300 300 20)') # test default offset of 0.0 tls = affinity.translate(ls) self.assertTrue(tls.equals(ls)) # test all offsets tls = affinity.translate(ls, 100, 400, -10) els = load_wkt('LINESTRING(340 800 0, 340 700 20, 400 700 10)') self.assertTrue(tls.equals(els)) # Do explicit 3D check of coordinate values for a, b in zip(tls.coords, els.coords): for ap, bp in zip(a, b): self.assertEqual(ap, bp) # retest with named parameters for the same result tls = affinity.translate(geom=ls, xoff=100, yoff=400, zoff=-10) self.assertTrue(tls.equals(els))
def make(self): # Create new geometry dx = self.destination[0] - self.origin[0] dy = self.destination[1] - self.origin[1] self.geometry = [DrawToolShape(affinity.translate(geom.geo, xoff=dx, yoff=dy)) for geom in self.draw_app.get_selected()] self.complete = True
def gen_feature(feature_name, model_number, image_path, shape, transl, scaling, scn): print("Called gen_feature @ %s" % feature_name) # let's first translate our feature. ip = Polygon(list(shape)) # map(lambda x: (x[0], 4x[1]), shape))) p = translate(ip, xoff=transl[0], yoff=transl[1]) if(feature_name == "Mountain"): center_z = 0 center_pos = p.centroid.coords[0] rd = int((max([dist(x, center_pos) for x in p.exterior.coords]) / 2) ** 0.5) print("Radius = %d" % rd) print("Center = %d, %d" % (center_pos[0], center_pos[1])) return Mountain(rd, center_z, center_pos) elif(feature_name == "MountainImg"): center_z = 0 center_pos = p.bounds[0:2] print("Center = %d, %d" % (center_pos[0], center_pos[1])) return MountainImg(p, center=center_pos) elif(feature_name == "Roads"): pass elif(feature_name == "Image"): f = ImageFeature(image_path) f.shape = p return f elif(feature_name == "Vegetation"): for a in p.exterior.coords: print(a) return Vegetation(p, model=AbstractModel(scn["model_path"], 0.02, (0, 0)), tree_number=model_number) elif(feature_name == "Urban"): pass elif(feature_name == "WaterArea"): pass elif(feature_name == "River"): pass
def pack(items): shifted = [ ] for i, item in enumerate(items): shifted.append( affinity.translate(item, (i%6)*15, (i//6)*15) ) return ops.cascaded_union(shifted)
def main(opts): pattern = loads(open(opts.input, "r").read()) extent = loads(open(opts.extent, "r").read()) if not contains.matches(extent.relate(pattern)): print "ERROR: pattern must be contained within the extent" return c = pattern.centroid (xs, ys) = extent.boundary.xy (minx, maxx, miny, maxy) = (min(xs) - c.x, max(xs) - c.x, min(ys) - c.y, max(ys) - c.y) outputFile = open(opts.output, "w") geoms = [] while len(geoms) < opts.number: dx = random.uniform(minx, maxx) dy = random.uniform(miny, maxy) geom = translate(pattern, xoff=dx, yoff=dy) if contains.matches(extent.relate(geom)): # Check that it is within the extent overlap = False for g in geoms: if intersects.matches(g.relate(geom)): overlap = True if overlap == False: geoms.append(geom) for geom in geoms: outputFile.write(dumps(geom) + "\n") outputFile.close()
def saveR(rectangles, A, cc, n): zona = takeZona(n) polis =[] for r in rectangles: polis.append(r[0]) union = affinity.rotate(cascaded_union(polis), -A, origin=cc) dx = union.centroid.x-cc.x dy = union.centroid.y-cc.y print 'translate : ',dx, dy data2save=() for r in rectangles: rotated=affinity.rotate(r[0], -A, origin=cc) translated = affinity.translate(rotated, -dx, -dy) #verificar si interseca print zona.intersects(translated) if zona.intersects(translated): data = (n, A, r[1], r[2], "SRID=25831;"+str(translated)) data2save += (data,) #print data conn = db.connect(rootData) c = conn.cursor() c.executemany('''insert into elementsdiv ( name, ang, x, y, geometry ) values ( ?, ?, ?,?, GeomFromEWKT( ? ) )''', data2save ) conn.commit() conn.close() return
def move_obs(self, index, displacement): for i in range(0,index): self.obs_config[i][index-1] = translate(self.obs_config[i][index-1], xoff = displacement[0], yoff = displacement[1]) for i in range(index+1, len(self.poly)): self.obs_config[i][index] = translate(self.obs_config[i][index], xoff = displacement[0], yoff = displacement[1]) self.config_poly[index] = translate(self.config_poly[index], xoff = displacement[0], yoff = displacement[1]) self.config_objects = unary_union(self.config_poly) self.poly[index] = translate(self.poly[index], xoff = displacement[0], yoff = displacement[1]) self.objects = unary_union(self.poly)
def get_shapely_object(self): # Start with the "rays" # noinspection PyTypeChecker ray_angles = np.linspace(0, np.pi / 2, 8) + np.pi / 2 outer_ray_positions = (np.array( [np.cos(ray_angles), np.sin(ray_angles)]) * self.height).T + (self.height, 0) inner_ray_positions = (np.array( [np.cos(ray_angles), np.sin(ray_angles)]) * self.height * self.min_radius_fraction).T + (self.height, 0) polygons = list() for outer, inner in zip(outer_ray_positions.reshape(-1, 2, 2), inner_ray_positions.reshape(-1, 2, 2)): polygons.append(Polygon([outer[0], outer[1], inner[1], inner[0]])) pass # Draw the letters d = self.height * 0.077 k_upper_branch = rotate(box(0, -d, sqrt(2) * self.height / 2 + sqrt(2) * d, d), 45, origin=(0, 0)) k_lower_branch = scale(k_upper_branch, yfact=-1., origin=(0, 0)) k_uncut = k_upper_branch.union(k_lower_branch) k_unscaled = k_uncut.intersection( box(0, -self.height / 2., self.height / 2. + sqrt(2) * d, self.height / 2.)) k = scale(k_unscaled, 0.8, origin=(0, 0)) polygons.append(translate(k, self.height * 1.05, self.height / 2.)) i = box(0, 0, 2 * d, self.height) polygons.append(translate(i, self.height * 1.6)) t_overlap = 2 t = box(-d, 0, d, self.height).union( box(-d * (1 + t_overlap), self.height - 2 * d, d * (1 + t_overlap), self.height)) polygons.append(translate(t, self.height * 2.05)) logo = unary_union(polygons) return translate(logo, *self.origin)
def get_kml(self): ''' Render the Site as KML ''' k = kml.KML() ns = '{http://www.opengis.net/kml/2.2}' ls = LineStyle(color="ffffff00", width=0.5) s1 = Style(id="thin_border", styles=[ls]) d = kml.Document(ns, self.site.name, self.site.name, "Site plan for %s" % (self.site.name), styles=[s1]) k.append(d) # nf = kml.Folder(ns, 'B1', 'building 1', 'Building one') # d.append(nf) # render the site reference mark as a KML Placemark p = kml.Placemark(ns, 'ref_mark', self.site.name, 'Reference survey mark') p.geometry = self.site.ref_mark d.append(p) # compute the UTM coords of the Site reference point crs = get_epsg(self.site.ref_mark) site_UTM = get_UTM_from_long_lat(self.site.ref_mark) project_UTM_to_WGS84 = partial(pyproj.transform, pyproj.Proj(init=crs), pyproj.Proj(init='epsg:4326')) folder = kml.Folder(ns, 'Structures', 'Structures', 'Structures on the site') d.append(folder) # render each Structure for s in self.site.structures: name = s.name # work with the outline of the structure outline = s.geometry.buffer(0) # move outline into UTM coordinates for the site outline = translate(outline, xoff=site_UTM.x, yoff=site_UTM.y) # and transform to WGS84 outline = transform(project_UTM_to_WGS84, outline) # place the outline in Structures folder p = kml.Placemark(ns, name, name, s.description, styleUrl="#thin_border") p.geometry = outline folder.append(p) # return the KML return k.to_string(prettyprint=True)
def __init__(self): self.centre = [400, 500] self.centredLineString = LineString([(-playerHalfSize,-playerHalfSize), (-playerHalfSize,playerHalfSize), (playerHalfSize,playerHalfSize), (playerHalfSize,-playerHalfSize)]) self.lineString = translate(self.centredLineString, self.centre[0], self.centre[1]) self.speedY = 0 self.jumping = False
def transform_patch(p, s=2): corrected_patch = scale( translate(p, xoff=-data.shape[1]/2, yoff=-data.shape[0]/2), xfact=0.396, yfact=0.396, origin=(0, 0), ) # display patch at s*Re return scale(corrected_patch, s, s)
def get_geojson(): with open('us_states_simplified_albers.geojson') as us_states_file: geojson = json.loads(us_states_file.read()) for f in geojson['features']: if f['properties']['NAME'] == 'Alaska': geom = affinity.translate(shape(f['geometry']), xoff=1.2e6, yoff=-4.8e6) geom = affinity.scale(geom, .4, .4) geom = affinity.rotate(geom, 30) f['geometry'] = mapping(geom) elif f['properties']['NAME'] == 'Hawaii': geom = affinity.translate(shape(f['geometry']), xoff=4.6e6, yoff=-1.1e6) geom = affinity.rotate(geom, 30) f['geometry'] = mapping(geom) return json.dumps(geojson)
def __call__(self, point, rotation=0): panels = [] for panel in self._panels: p = translate(panel, xoff=point.x, yoff=point.y) if rotation!=0: # Rotate around the origin p = rotate(p, rotation, origin=(0,0)) panels.append(p) return panels
def __init__(self, hexagon_size, module_list=[]): self._vertices = [] for module in module_list: column = module[0] row = module[1] point0 = Point((0,0)) point0 = translate(point0, xoff=-hexagon_size*math.sqrt(3)/2.*column, yoff=hexagon_size/2.*column) self._vertices.append((point0.x, point0.y+hexagon_size*row)) self._vertices.append((self._vertices[0][0]-hexagon_size/10, self._vertices[0][1]))
def rect_polygon(x, y, width, height, angle): """Return a shapely Polygon describing the rectangle with centre at (x, y) and the given width and height, rotated by angle quarter-turns. code from: https://codereview.stackexchange.com/questions/204017/intersection-over-union-for-rotated-rectangles """ w = width / 2 h = height / 2 p = Polygon([(-w, -h), (w, -h), (w, h), (-w, h)]) return translate(rotate(p, angle, use_radians=True), x, y)
def _channel(self): channel_object = self._bezier_guide_channel( 0, self._outer_channel_width, self._inner_channel_width, self._channel_length, self._channel_point_2, self._channel_point_3) x_offset = (self._gate_length + self._gate_choke_length + self._choke_length_2 + self._choke_length_3) y_offset = (1 - self._channel_position) * self._channel_length return translate(rotate(channel_object, -np.pi / 2, (0, 0), True), x_offset, y_offset, 0)
def __rotate_box(box, angle, image_size, rotated_image_size): """ Поворот многоугольника """ rotated_box = [] for i in range(len(box) // 2): pt = Point(box[2 * i], box[2 * i + 1]) pt = affinity.translate(pt, -image_size[0] / 2, -image_size[1] / 2) rotated_pt = affinity.rotate(pt, angle, origin=[0, 0], use_radians=False) rotated_pt = affinity.translate(rotated_pt, rotated_image_size[0] / 2, rotated_image_size[1] / 2) rotated_box.extend([rotated_pt.x, rotated_pt.y]) return rotated_box
def _connect_points(row): pt0 = row['prev_pt'] pt1 = row['geometry'] if type(pt0) != Point: return None if pt0 == pt1: # to avoid intersection issues with zero length lines pt1 = translate(pt1, 0.00000001, 0.00000001) return LineString(list(pt0.coords) + list(pt1.coords))
def add_letter_to_axis(ax, let, x, y, height): """Add 'let' with position x,y and height height to matplotlib axis 'ax'. """ for polygon, color in zip(letters_polygons[let], colors[let]): new_polygon = affinity.scale(polygon, yfact=height, origin=(0, 0, 0)) new_polygon = affinity.translate(new_polygon, xoff=x, yoff=y) patch = PolygonPatch(new_polygon, edgecolor=color, facecolor=color) ax.add_patch(patch) return
def __init__(self, shape, num_particles, map_size): super().__init__(map_size) self.shape = af.translate(shape, -shape.centroid.xy[0].tolist()[0], -shape.centroid.xy[1].tolist()[0]) # shape of object self.particles = [Particle() for i in range(num_particles)] self.reset_particles() self.XY_TRANSITION_SIGMA = 0.1 self.THETA_TRANSITION_SIGMA = np.pi / 24 self.OBS_ACCURACY = 0.99
def to_minimise(optimiser_input): rotated = aff.rotate(ellipse, optimiser_input[2], origin='centroid') translated = aff.translate(rotated, xoff=optimiser_input[0], yoff=optimiser_input[1]) disjoint_area = (translated.difference(cutout).area + cutout.difference(ellipse).area) return disjoint_area
def __init__(self, centreX, centreY): self.centre = [centreX, centreY] self.centredLineString = LineString([(-enemyHalfSize, -enemyHalfSize), (-enemyHalfSize, enemyHalfSize), (enemyHalfSize, enemyHalfSize), (enemyHalfSize, -enemyHalfSize)]) self.lineString = translate(self.centredLineString, self.centre[0], self.centre[1]) self.speedX = enemyLateralSpeed
def __call__(self, point, rotation=0): panels = [] for panel in self._panels: p = translate(panel, xoff=point.x, yoff=point.y) if rotation != 0: # Rotate around the origin p = rotate(p, rotation, origin=(0, 0)) panels.append(p) return panels
def coffin(Rint,wmid,Rmid,lmid,wtop,htop,Rtop): ltot = lmid+Rint L = math.sqrt((ltot-Rmid)*(ltot-Rmid)-Rmid*Rmid) alpha = math.atan(Rmid/L) tri = Polygon([[0,0],[math.cos(alpha)*L, -math.sin(alpha)*L],[math.cos(alpha)*L, math.sin(alpha)*L]]) c = circle(lmid+Rint-Rmid,0,Rmid) union = tri.union(c) trans = 2*Rmid-wmid union2 = translate(union,0,-trans/2) union3 = translate(union, 0,trans/2) inter = union3.intersection(union2) cint = circle(O,Rint) inter = inter.difference(cint) c1 = circle(ltot,0,Rtop) c2 = translate(c1,0,-Rtop+wtop/2) c3 = translate(c1,0,Rtop-wtop/2) eye = c2.intersection(c3) return eye.union(inter)
def minimising_function(optimiser_input): x_shift, y_shift, rotation_angle = optimiser_input rotated = aff.rotate(initial_ellipse, rotation_angle, use_radians=True) translated = aff.translate(rotated, xoff=x_shift, yoff=y_shift) disjoint_area = (translated.difference(insert).area + insert.difference(translated).area) return disjoint_area / 400
def make(self): # Create new geometry dx = self.destination[0] - self.origin[0] dy = self.destination[1] - self.origin[1] self.geometry = [ DrawToolShape(affinity.translate(geom.geo, xoff=dx, yoff=dy)) for geom in self.draw_app.get_selected() ] self.complete = True
def transition_fnc(self, p): """ Makes a new particle, moved by a random amount. """ new_p = Particle() new_p.x = np.random.normal(loc=p.x, scale=self.XY_TRANSITION_SIGMA) new_p.y = np.random.normal(loc=p.y, scale=self.XY_TRANSITION_SIGMA) new_p.theta = np.random.normal(loc=p.theta, scale=self.THETA_TRANSITION_SIGMA) % (2 * np.pi) new_p.shape = af.translate(af.rotate(self.shape, new_p.theta, use_radians=True, origin=(0, 0)), new_p.x, new_p.y) return new_p
def importSVGroute(IDT_group): IDT_group_dir = IDT_group['IDT_group_dir'] Tk().withdraw( ) # we don't want a full GUI, so keep the root window from appearing svg_filename = tkFileDialog.askopenfilename(title='Wafer routing filename', defaultextension='svg', initialdir=IDT_group_dir) all_points = SVGT.read_colored_path_from_svg(svg_filename) route = [[], []] for points in all_points['red']: polygon = shapely_geom.Polygon(points.T) polygon_validity = explain_validity(polygon) if polygon_validity == 'Valid Geometry': route[0].append(polygon) else: tkMessageBox.showwarning('Error in svg import', polygon_validity) for points in all_points['blue']: polygon = shapely_geom.Polygon(points.T) polygon_validity = explain_validity(polygon) if polygon_validity == 'Valid Geometry': route[1].append(polygon) else: tkMessageBox.showwarning('Error in svg import', polygon_validity) route[0] = shapely_geom.MultiPolygon(route[0]) route[1] = shapely_geom.MultiPolygon(route[1]) #outbox = route[0].bounds #dx = outbox[2]-outbox[0] #dy = outbox[3]-outbox[1] #x0 = outbox[0]+dx/2 #y0 = outbox[1]+dy/2 x0 = 4000 y0 = 4000 factor = 1e-5 route[0] = shapely_affinity.translate(route[0], xoff=-x0, yoff=-y0) route[0] = shapely_affinity.scale(route[0], xfact=factor, yfact=factor, origin=(0, 0, 0)) route[1] = shapely_affinity.translate(route[1], xoff=-x0, yoff=-y0) route[1] = shapely_affinity.scale(route[1], xfact=factor, yfact=factor, origin=(0, 0, 0)) IDT_group['route'] = route
def getNFPForHole(self, hole): shape_hash = self.getShapeHash() try: # try to get cached NFP if _debug: print("hole ", hole.wkt, " has cached nfp") return hole.shape_nfps[shape_hash] except KeyError: # it does not exist shapepoints = list(orient(self.shape_rotated).exterior.coords) if self.convex_hull: shapepoints = list(orient(self.shape_rotated.convex_hull).exterior.coords) holepoints = list(orient(hole.simplify(1)).exterior.coords) holepoints = roundCoords(holepoints) trans = [- shapepoints[0][0], - shapepoints[0][1]] holepoints[0] = [holepoints[0][0]+1,holepoints[0][1]+1] #hacky hack holepoints[-1] = holepoints[0] try: nfps = genNFP(holepoints, shapepoints) except RuntimeError as err: self.logger.log("WTF?: " + str(err), self.logger.logLevel.DEBUG, self.log_type) holepoints = roundCoords(holepoints) try: nfps = genNFP(holepoints, shapepoints) except Exception as ee: self.logger.log("WTF!!!" + str(ee), self.logger.logLevel.DEBUG, self.log_type) holepoints = intCoords(holepoints) shapepoints = intCoords(shapepoints) try: nfps = genNFP(holepoints, shapepoints) except Exception as ee: self.logger.log("WTF??????????" + str(ee), self.logger.logLevel.DEBUG, self.log_type) holepoints[0] = [holepoints[0][0]-1,holepoints[0][1]-1] #unhacky unhack holepoints[-1] = holepoints[0] try: nfps = genNFP(holepoints, shapepoints) except Exception as ee: self.logger.log("Falling back to circle" + str(ee), self.logger.logLevel.DEBUG, self.log_type) return None except: print("Fatal error") if _debug: print("storing new NFP for hole ", hole.wkt) try: npolys = Polygon(nfps[0], nfps[1:]) except: # one of NFPS has less than 3 points -> ignote it #FIXME: do not ignore it somehow # hack to create polygons out of 1- and 2-point NFPS by appending # copies of the last point so that there are at least 3 #nfps[1:] = [[*x, *[x[-1]]*(3-len(x))] if len(x) < 3 else x for x in nfps[1:]] npolys = Polygon(nfps[0], [x for x in nfps[1:] if len(x) >= 3]) self.logger.log("OHSHIT!", logger.logLevel.WARNING, self.log_type) npolys = npolys.buffer(self.hole_offset, resolution=2) npolys = affinity.translate(npolys, trans[0], trans[1]) hole.shape_nfps[shape_hash] = npolys # store the NFP in cache return npolys
def __update(self, eps=0.001): if len(list(self.__parcels)) == 0: raise Warning('Empty Block') self.parcels = self.__parcels self.polygon = self.__polygon for trans_type, params in self.__transform_list: if trans_type == 'rotation': theta, origin = params self.parcels = rotate(self.parcels, theta, origin=origin) self.polygon = rotate(self.polygon, theta, origin=origin) elif trans_type == 'translation': x_offset, y_offset = params self.parcels = translate(self.parcels, x_offset, y_offset) self.polygon = translate(self.polygon, x_offset, y_offset) elif trans_type == 'scaling': xfact, yfact, origin = params self.parcels = scale(self.parcels, xfact, yfact, origin=origin) self.polygon = scale(self.polygon, xfact, yfact, origin=origin)
def get_polygons(shape, scale): result = [] parts = list(shape.parts) + [len(shape.points)] for i1, i2 in zip(parts, parts[1:]): points = [mercator(y, x, scale) for x, y in shape.points[i1:i2]] polygon = Polygon(points) bounds = polygon.bounds polygon = translate(polygon, -bounds[0], -bounds[1]) result.append(polygon) return result
def _example(): from gdshelpers.geometry.chip import Cell kit_logo = KITLogo([0, 0], 1) wwu_logo = WWULogo([0, 0], 1, 1) cell = Cell('LOGOS') cell.add_to_layer(1, kit_logo) cell.add_to_layer(1, translate(wwu_logo.get_shapely_object(), 2.5)) cell.show()
def get_polygon(self, idx, FoR='local'): """Get polygon in the appropriate Frame-of-Reference. By default, returns in the local frame to avoid translation. """ if FoR == 'global': return translate(self._polygons[idx], *self.centers[idx]) elif FoR == 'local': return self._polygons[idx] else: raise Exception('invalid frame of reference (FoR)')
def draw_aperture(self, x, y): (name, mods) = self.apertures[self.aperture] if name == 'R': (w,h) = mods p = sa.translate(sg.box(-w / 2, -h / 2, w / 2, h / 2), x, y) self.polys.append(p) elif name == 'C': (r, ) = mods self.polys.append(sg.Point(x, y).buffer(r)) assert 0
def get_base_shape(self): """ Get the base shape of this ship, in board coordinates return: Polygon representing this ship """ bx = self.base_size[0] / 2 by = self.base_size[1] / 2 base_shape = box(-bx, -by, bx, by) base_shape = rotate(base_shape, self.orientation) return translate(base_shape, self.position[0], self.position[1])
def add_paper(self, width, height): """paper width and height are assumed to be in scalar units (inches by default) """ geom = box(minx=0, miny=0, maxx=width, maxy=height) self.paper = translate(geom, xoff=self.paper_origin.x, yoff=self.paper_origin.y) self.paper_center = self.paper.centroid return self.paper
def __init__(self, corners, parcel_borders=[], x=0, y=0, theta=0): self.__polygon = translate(Polygon(corners), x, y) merged = linemerge([self.__polygon.boundary] + [LineString(_) for _ in parcel_borders]) borders = unary_union(merged) self.__parcels = MultiPolygon(list(polygonize(borders))) self.polygon = self.__polygon self.parcels = self.__parcels self.__transform_list = [] self.rotate(theta)
def get_shapely_object(self): shapely_object = geometric_union([ self._gate(), self._choke_channel(), self._choke_left(), self._choke_right(), self._channel() ]) rotated_object = rotate(shapely_object, self._angle, (0, 0), True) return translate(rotated_object, self._origin[0], self._origin[1], 0)
def get_polygon(t): pos = t.position() vert = t.get_shapepoly() heading = t.heading() print('vert {}'.format(vert)) p = Polygon(vert) p = translate(p, xoff=pos[0], yoff=pos[1]) p = rotate(p, 90 + heading) print('polygon {}'.format(p)) return p
def move(self, east_metres=0.0, north_metres=0.0): ''' Move the Structure by the specified distance To move south specify a negative value for north_metres. Same for west ''' self.geometry = translate(self.geometry, xoff=east_metres, yoff=north_metres, zoff=0.0) return self
def _transform(geom): centroid = geom.centroid # Bring back to origin geom = translate(geom, xoff=-centroid.x, yoff=-centroid.y) geom = rotate(geom, -self._bubble_heading, "centroid", use_radians=True) # Now apply new transformation in "vehicle coordinate space" geom = translate( geom, xoff=self._bubble.follow_offset[0], yoff=self._bubble.follow_offset[1], ) geom = rotate(geom, vehicle.heading, (0, 0), use_radians=True) geom = translate(geom, xoff=x, yoff=y) return geom
def handle(self, *args, **options): minx = options['minx'] miny = options['miny'] maxx = options['maxx'] maxy = options['maxy'] if minx >= maxx: raise CommandError(_('minx has to be lower than maxx')) if miny >= maxy: raise CommandError(_('miny has to be lower than maxy')) width = maxx-minx height = maxy-miny model = {'areas': Area, 'obstacles': Obstacle}[options['type']] namespaces = {'svg': 'http://www.w3.org/2000/svg'} svg = ElementTree.fromstring(options['svgfile'].read()) svg_width = float(svg.attrib['width']) svg_height = float(svg.attrib['height']) for element in svg.findall('.//svg:clipPath/..', namespaces): for clippath in element.findall('./svg:clipPath', namespaces): element.remove(clippath) for element in svg.findall('.//svg:symbol/..', namespaces): for clippath in element.findall('./svg:symbol', namespaces): element.remove(clippath) if svg.findall('.//*[@transform]'): raise CommandError(_('svg contains transform attributes. Use inkscape apply transforms.')) if model.objects.filter(space=options['space'], import_tag=options['name']).exists(): raise CommandError(_('objects with this import tag already exist in this space.')) with MapUpdate.lock(): changed_geometries.reset() for path in svg.findall('.//svg:path', namespaces): for polygon in self.parse_svg_data(path.attrib['d']): if len(polygon) < 3: continue polygon = Polygon(polygon) polygon = scale(polygon, xfact=1, yfact=-1, origin=(0, svg_height/2)) polygon = scale(polygon, xfact=width / svg_width, yfact=height / svg_height, origin=(0, 0)) polygon = translate(polygon, xoff=minx, yoff=miny) obj = model(geometry=polygon, space=options['space'], import_tag=options['name']) obj.save() MapUpdate.objects.create(type='importsvg') logger = logging.getLogger('c3nav') logger.info('Imported, map update created.') logger.info('Next step: go into the shell and edit them using ' '%s.objects.filter(space_id=%r, import_tag=%r)' % (model.__name__, options['space'].pk, options['name']))
def splitworlds_shape(shape, seam_longitude): """Returns three MultiPolygons: western old world, eastern old world, and new world.""" # Construct MultiPolygon to perform intersections multi = geoshapes.shape2multi(shape).buffer(0) multi = multi.intersection(geometry.box(multi.bounds[0], -30, multi.bounds[2], 30)) # Drop the drop boxes for region in DROP_REGIONS: multi = multi.difference(region) # Pull out the list, in case it wasn't a list geoms = [poly for poly in geoshapes.polygons(multi)] in_newworlds = [] for geom in geoms: minnew = in_newworld(*geom.bounds[:2]) maxnew = in_newworld(*geom.bounds[2:]) assert minnew == maxnew in_newworlds.append(minnew) newworld = geometry.MultiPolygon([geoms[ii] for ii in range(len(geoms)) if in_newworlds[ii]]) if np.all(in_newworlds): return geometry.MultiPolygon(), geometry.MultiPolygon(), newworld # If some old world, construct unions and re-seam oldworld = [] for ii in range(len(geoms)): if in_newworlds[ii]: continue # Move everything west of new world to the far east if geoms[ii].bounds[0] < -65: oldworld.append(affinity.translate(geoms[ii], 360)) else: oldworld.append(geoms[ii]) oldworld = ops.cascaded_union(geometry.MultiPolygon(oldworld)) rightoldworld = oldworld.intersection(geometry.box(-65, -30, seam_longitude, 30)) leftoldworld = affinity.translate(oldworld.intersection(geometry.box(seam_longitude, -30, oldworld.bounds[2], 30)), -360) return rightoldworld, leftoldworld, newworld
def to_minimise(optimiser_input): rotated = aff.rotate( ellipse, optimiser_input[2], origin='centroid') translated = aff.translate( rotated, xoff=optimiser_input[0], yoff=optimiser_input[1]) disjoint_area = ( translated.difference(cutout).area + cutout.difference(ellipse).area ) return disjoint_area
def affine_trans(self,header): for elmt in header.elements: if elmt.element.is_empty: continue if elmt.active: if self.mirror: elmt.element=affinity.scale(elmt.element, xfact=1, yfact=-1,origin=self.center) if abs(self.rot_ang) > self.tiny_ang: elmt.element=affinity.rotate(elmt.element, self.rot_ang,origin=self.center) if abs(self.xoff) > 0.0 or abs(self.yoff) > 0.0: elmt.element=affinity.translate(elmt.element, xoff=self.xoff, yoff=self.yoff)