Пример #1
0
def getFacets(p1,p2, curve):
    
    if p2.x == p1.x:
        leveling_angle = math.radians(90)
    else:
        leveling_angle = -math.atan((p2.y-p1.y)/(p2.x-p1.x))
    p1p = p1#rotate(p1, leveling_angle, origin=p1, use_radians=True)
    p2p = affinity.rotate(p2, leveling_angle, origin=p1, use_radians=True) # rotate p2 around p1, so they lie on a horizontal line.  Finding the center is easier this way.
    
    l = (p2p.x-p1p.x)/2  # half the distance between the points.
    h = l/math.tan(-curve/2) # compute the distance to the center of the circle
                             # from the line connecting the two points.
    
    cp = shapes.Point(p1p.x + l, p1p.y-h) # the center of the (rotated) circle.
    c = affinity.rotate(cp, -leveling_angle, origin=p1, use_radians=True)  # unrotate the circle to get the center of the original circle.

    # how man line segments to use to approximate the curve.  Bound the angle between consecutive segments to 5 degrees. ALways have at least 10 segments.
    facets = max(10, int(math.ceil(abs(curve)/5)))
    
    points = []
    t = p1
    for i in range(1,facets + 2):  # Generate the segments by rotating p1
                                   # around the center a little bit at a time.
        points.append(t)
        t = affinity.rotate(t, curve/facets, origin=c, use_radians=True)

    return points
Пример #2
0
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
Пример #3
0
def min_bounding_box(p):
    ''' return the minimum-area bounding box (any orientation) of a convex polygon p.'''
    
    def rotate_points(pts, theta):
        R = np.array([[np.cos(theta), -np.sin(theta)],
                      [np.sin(theta),  np.cos(theta)]])
        return np.dot(R, pts.T).T
        
    def bbox_area(pts):
        min_pts = pts.min(axis=0)
        max_pts = pts.max(axis=0)
        return np.product(max_pts - min_pts)
    
    edges = np.diff(np.array(p.boundary), axis=0)
    angles = np.arctan2(edges[:,1], edges[:,0]) # polar angles of each edge in p

    zero_pt = (0,0)
    pts = np.array(p.boundary)
    
    '''Minimum-area bounding box of cvx poly must be aligned with an edge.
    So rotate polygon by negative polar angle, fit axis-aligned bbox, repeat and 
    choose box with minimum area'''
    min_area = np.inf
    for angle in angles: 
        pts_rot = rotate_points(pts, -angle)
        area = bbox_area(pts_rot)
        if area < min_area:
            min_area = bbox_area(pts_rot)
            min_angle = angle
            
    p_rot = affinity.rotate(p, -min_angle, origin=zero_pt, use_radians=True)
    return affinity.rotate(p_rot.envelope, min_angle, origin=zero_pt, use_radians=True), min_angle
Пример #4
0
def perpendicular_at(line, point, length):
    """
    line: a linestring
    point: a point within the line at which to search for a perpendicular line
    length: length of the line
    """
    point = asPoint(point)
    E = 1e-8
    if line.intersects(point):
        refpoint = point
    else:
        r = 16
        while True:
            refpoint = point.buffer(line.distance(point)+E, resolution=r).exterior.intersection(line)
            if not refpoint.is_empty:
                break
            else:
                r = r * 2
        assert not refpoint.is_empty
    a = line_angle_at(line, refpoint)
    a2 = a + pi/2
    p2 = Point(point.x, point.y + length*0.5)
    p3 = rotate(p2, -math.degrees(a2), origin=point)
    p4 = rotate(p2, (180 - math.degrees(a2)), origin=point)
    l = linestr(p3, p4)
    return l
def generate_patterns(depths):
    cuts_n = list(generate_cuts(depths))
    cuts_e = [rotate(x, 90) for x in cuts_n]
    cuts_s = [rotate(x, 180) for x in cuts_n]
    cuts_w = [rotate(x, 270) for x in cuts_n]
    for cut_n, cut_e, cut_s, cut_w in product(cuts_n, cuts_e, cuts_s, cuts_w):
        poly = cut_n.union(cut_e).union(cut_s).union(cut_w)
        yield poly
Пример #6
0
def plot_arrow(color, center_line, dist, normalized=False):
    ARROW_LENGTH = 3.0
    origin_p = center_line.interpolate(dist, normalized=normalized)
    normal_line = get_normal_to_line(center_line, dist, normalized=normalized)
    half_arrow = extend_line(normal_line, ARROW_LENGTH - normal_line.length, direction="forward")
    half_arrow = affinity.rotate(half_arrow, -55.0, origin=origin_p)
    plot_line(color, half_arrow)
    half_arrow = affinity.rotate(half_arrow, -70.0, origin=origin_p)
    plot_line(color, half_arrow)
Пример #7
0
def generate_panels(wafer_size):
    panels0 = SectorGenerator(wafer_size*sqrt3o2)(Point(0,wafer_size*sqrt3o2*2))
    panels = []
    panels.append(panels0)
    panels.append([rotate(panel, 60, origin=(0,0)) for panel in panels0])
    panels.append([rotate(panel, 120, origin=(0,0)) for panel in panels0])
    panels.append([rotate(panel, 180, origin=(0,0)) for panel in panels0])
    panels.append([rotate(panel, 240, origin=(0,0)) for panel in panels0])
    panels.append([rotate(panel, 300, origin=(0,0)) for panel in panels0])
    return panels
Пример #8
0
def generate_panels_test(wafer_size, panel_list):
    panels0 = SectorGeneratorTest(wafer_size*sqrt3o2, panel_list)(Point(0,0))
    panels = []
    panels.append(panels0)
    panels.append([rotate(panel, 60, origin=(0,0)) for panel in panels0])
    panels.append([rotate(panel, 120, origin=(0,0)) for panel in panels0])
    panels.append([rotate(panel, 180, origin=(0,0)) for panel in panels0])
    panels.append([rotate(panel, 240, origin=(0,0)) for panel in panels0])
    panels.append([rotate(panel, 300, origin=(0,0)) for panel in panels0])
    return panels
Пример #9
0
def _crop_after_rotation(im, angle, xres, yres, surroundings):
    """Crop image to the bounding box of bite's surroundings.

    Arguments:

    im: PIL.Image, rotated map part
    angle: by which the map has been rotated, in degrees (counterclockwise)
    xres: width of one tile in pixels
    yres: height of one tile in pixels
    surroundings: shapely.geometry.polygon.Polygon
    """

    #before rotation
    x1, y1, x2, y2 = surroundings.bounds
    old_bb_upper_left = Point(x1, y1)
    old_bb_upper_right = Point(x2, y1)
    old_bb_bottom_left = Point(x1, y2)
    old_bb_center = ((x1+x2)/2, (y1+y2)/2)

    #shapely y-axis goes upwards
    shapely_angle = -angle

    #after rotation
    x1, y1, x2, y2 = affinity.rotate(surroundings, shapely_angle, origin=old_bb_center).bounds
    crop_upper_left = Point(x1, y1)
    crop_width = x2 - x1
    crop_height = y2 - y1

    #points where old bounding box of surroundings (i.e. the old image) touches
    #its bounding box after rotation
    tl = None #touch at the left side of the new bounding box
    tt = None #touch at the top side of the new bounding box
    if angle > 0:
        tl = affinity.rotate(old_bb_upper_left, shapely_angle, origin=old_bb_center)
        tt = affinity.rotate(old_bb_upper_right, shapely_angle, origin=old_bb_center)
    else:
        tl = affinity.rotate(old_bb_bottom_left, shapely_angle, origin=old_bb_center)
        tt = affinity.rotate(old_bb_upper_left, shapely_angle, origin=old_bb_center)

    #upper left corner of ther new bounding box
    new_bb_upper_left = Point(tl.x, tt.y)

    #from these we get b: upper left corner of the crop area relative to new_bb_upper_left
    b = (crop_upper_left.x - new_bb_upper_left.x, crop_upper_left.y - new_bb_upper_left.y)

    #crop rectangle in pixels relative to new_bb_upper_left
    crop_box = [int(x) for x in [
        b[0] * xres,
        b[1] * yres,
        (b[0] + crop_width) * xres,
        (b[1] + crop_height) * yres
    ]]
    cropped = im.crop(box=crop_box)
    cropped.load()
    return cropped
Пример #10
0
def generate_sectors(full_layer, wafer_size):
    sector = Polygon([(0,0)]+list(full_layer.exterior.coords)[:2])
    sector = shift_point(sector, 0, (0,wafer_size*sqrt3o2))
    sector = shift_point(sector, 1, (0,wafer_size*sqrt3o2))
    sectors = [sector]
    sectors.append(rotate(sector, 60, origin=(0,0)))
    sectors.append(rotate(sector, 120, origin=(0,0)))
    sectors.append(rotate(sector, 180, origin=(0,0)))
    sectors.append(rotate(sector, 240, origin=(0,0)))
    sectors.append(rotate(sector, 300, origin=(0,0)))
    return sectors
Пример #11
0
 def __init__(self, hexagon_size, length=3, width=2):
     v0 = Point((0,0))
     v1 = Point((0,hexagon_size*(length-1)))
     v2 = Point((0,hexagon_size*(length+width-2)))
     v2 = rotate(v2, 120, origin=v1)
     v3 = Point((0,hexagon_size*(width-1)))
     v3 = rotate(v3, 120, origin=v0)
     self._vertices = [(v0.x,v0.y),(v1.x,v1.y),(v2.x,v2.y),(v3.x,v3.y)]
     # create mirrored panel
     v2_mirror = rotate(v2, -240, origin=v1)
     v3_mirror = rotate(v3, -240, origin=v0)
     self._vertices_mirror = [(v2_mirror.x,v2_mirror.y),(v3_mirror.x,v3_mirror.y),(v0.x,v0.y),(v1.x,v1.y)]
Пример #12
0
def findMinCv(name, polygon):
    bb = polygon.bounds
    ang = 0
    refarea = Bounds(polygon).area
    cc=polygon.centroid
    for p in range(len(polygon.exterior.coords[:])-1):
        angle = getAngle(polygon.exterior.coords[p], polygon.exterior.coords[p+1])
        rPolygon= affinity.rotate(polygon, angle, origin=cc)
        if Bounds(rPolygon).area < refarea:
            ang = angle
            bbx = affinity.rotate(Bounds(rPolygon), (360-angle), origin = cc)
            #bbx = affinity.rotate(Bounds(rPolygon), (angle), origin = cc)
    return (bbx, ang)
Пример #13
0
def cov_trans_and_rotate(p, obst_cov):
    ''' do cov transform as above, fit minimum bounding box, then rotate so bbox is
    axis-aligned '''
    p_w, W = cov_transform(p, obst_cov)
    bbox, bbox_angle = min_bounding_box(p_w)
       
    p_rw = affinity.rotate(p_w, -bbox_angle, origin=(0,0), use_radians=True)
    bbox_r = affinity.rotate(bbox, -bbox_angle, origin=(0,0), use_radians=True)
    
    theta = -bbox_angle
    R = np.array([[np.cos(theta), -np.sin(theta)],
                  [np.sin(theta),  np.cos(theta)]]) 
    return p_rw, bbox_r, np.dot(R,W)
Пример #14
0
    def rotate(self, polygon, angle, refpoint=Point()):
        """
        rotate polygon around ref point

        :param polygon:
        :param angle: in degree
        :param point:
        :return:
        """

        if refpoint.is_empty:
            refpoint = polygon.centroid
            return affinity.rotate(polygon, angle, refpoint)
        else:
            return affinity.rotate(polygon, angle, refpoint)
Пример #15
0
    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
Пример #16
0
def line_extrapolate_point(l, p, length):
    """
    Return a Point p2 which would extend the line `l` so that it
    would have a length of `length`

    l: a line
    p: a point within that line
    length: the length that a line from p to p2 would have

    """
    p = Point(*_normalize_point(p))
    a = line_angle_at(l, p)
    if a > pi:
        a = a % pi
    p2 = Point(p.x, p.y + length)
    c = l.centroid
    if p.x < c.x:
        if p.y < c.y:
            angle = pi-a
        else:
            angle = a
    elif p.x > c.x:
        if p.y < c.y:
            angle = -a
        else:
            angle = -a
    else:
        if p.y < c.y:
            angle = a + pi
        elif p.y > c.y:
            angle = a % pi
        else:
            angle = 100
    p3 = rotate(p2, math.degrees(angle), origin=p)
    return p3
Пример #17
0
def _best_angle(surroundings, maxwidth, maxheight):
    """Find the angle by which surroundings should be rotated.
    
    Try to minimalize surroundings' height while keeping its width
    under maxwidth. Also prefer smaller rotations over bigger ones.

    Arguments:

    surroundings: shapely.geometry.polygon.Polygon
    maxwidth: maximum allowed width of the surroundings bounding box
    maxheight: maximum allowed height of the surroundings bounding box

    Returns:
    
    angle in degrees (counterclockwise)
    """
    
    minheight = maxheight
    best = 0
    lowest_penalty = 1000
    for angle in range(-90, 90, 5):
        x1, y1, x2, y2 = affinity.rotate(surroundings, angle).bounds
        height = y2 - y1
        width = x2 - x1
        if width < maxwidth:
            penalty = height + abs(angle) / 100
            if penalty < lowest_penalty:
                lowest_penalty = penalty
                minheight = height
                best = angle

    #maps and shapely differ in the directions of their y-axes
    return -best
Пример #18
0
 def _do_inverse_transform(shape, rotation, mirrored, rotation_origin=(0,0), scale_origin=(0,0)):
     if shape is None or shape.is_empty:
         return shape
     r = shape
     r = affinity.scale(r, xfact=(-1 if mirrored else 1), origin=scale_origin)
     r = affinity.rotate(r, -rotation, origin=rotation_origin)
     return r;
Пример #19
0
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
Пример #20
0
    def to_shapely(self):
        """Create a shapely half circle rotated by the fan's angle.

        Notes
        =====
        `Motivated by: <https://stackoverflow.com/a/30762727/680232>`_
        """
        # Define the arc (presumably ezdxf uses a similar convention)
        centerx, centery = self.semi_circle_center

        # make a semi-circle first that points to the x-axis, rotate later.
        start_angle = 270  # In degrees

        # number of elements for the semi-circle
        numsegments = 100

        # The coordinates of the arc
        theta = np.radians(np.linspace(start_angle, start_angle+180, numsegments))
        x = centerx + self.radius * np.cos(theta)
        y = centery + self.radius * np.sin(theta)

        arc = geom.LineString(np.column_stack([x, y]))

        rotated = affinity.rotate(arc, self.data.angle,
                                  origin=tuple(self.semi_circle_center))

        df = pd.DataFrame(np.vstack([self.coords[::-1][:2], np.array(rotated)]))
        return geom.Polygon(df.round(2).drop_duplicates().values)
Пример #21
0
 def __init__(self, x=0, y=0, z=0, 
              N_slits=10, width=.0005, 
              spacing=.002, length=.025, 
              angle=0, angle_units='degrees',
              **kwargs):
     
     positions = spacing * np.array(range(N_slits))
     positions = positions - np.mean(positions)
     
     geometry = MultiPolygon(
                [Polygon([(-length/2.0 + y, -width/2.0 + i + z),
                          (-length/2.0 + y, +width/2.0 + i + z),
                          (+length/2.0 + y, +width/2.0 + i + z),
                          (+length/2.0 + y, -width/2.0 + i + z)]) 
                                                         for i in positions]
     )
     
     if angle_units=='degrees':
         angle = angle
     elif angle_units=='radians':
         angle = angle * 180/np.pi
     else:
         raise IOError('unrecognized angle units')
         
     if angle != 0:
         geometry = rotate(geometry, angle, origin=Point((y, z)))
     
     super(PolygonGratingCollimator, self).__init__(x, geometry, **kwargs)
Пример #22
0
def obstacle_bound(shape, orientations):
    ''' return the convex hull of a shape rotated about (0,0) by the angles in the
     orientations sequence. '''
    with nostdout():
        shapes = []
        for angle in orientations:
            shapes.append(affinity.rotate(shape, angle, origin=(0,0), use_radians=True))
    
        union = ops.cascaded_union(shapes)
        bound = union.convex_hull.convex_hull # apparently sometimes one convex_hull isn't enough
        # TODO: check for convexity before retrying convex hull operation
        # sometimes convex-hull returns valid non-convex polygons well f**k
        if not bound.is_valid: # in case it randomly shits out
            # For debug:        
            
    
            # clean shape
            bound = bound.buffer(0.0).convex_hull.convex_hull
            
            if not bound.is_valid:
                raise Exception('why doesnt this work')
            
        obstacle_bounds.append(bound)
        obstacle_orientations.append(orientations)        
            
        return bound
Пример #23
0
def ellipse(width, length):
    """Create ellipse when given width and length.
    """
    circle = geo.Point(0, 0).buffer(1)
    stretched = aff.scale(circle, xfact=width/2, yfact=length/2)
    rotated = aff.rotate(stretched, -45)

    return rotated
Пример #24
0
    def rotate_polygon(self, rotation_pos):
        if rotation_pos not in Hexagon.ROTATE_ANGLES.keys():
            print "Invalid rotation angle", rotation_pos
            return

        self.rotation_pos = rotation_pos
        self.polygon = affinity.rotate(self.original_polygon, Hexagon.ROTATE_ANGLES[rotation_pos])
        pass
Пример #25
0
    def to_minimise(optimiser_input):
        rotated = aff.rotate(to_be_aligned, optimiser_input[0])

        disjoint_area = (
            rotated.difference(alighn_to_this).area +
            alighn_to_this.difference(rotated).area
        )
        return disjoint_area
Пример #26
0
    def render_pad(self, layer_query, drill, **options):

        DRU = self.get_DRU()
        if self._layer_matches(layer_query, "Holes"):
            hole = shapes.Point(self.get_x(), self.get_y()).buffer(drill/2)
            return hole;

        radius = (drill/2);
        radius = radius + scaleAndBound(radius, DRU.rvPadTop, DRU.rlMinPadTop, DRU.rlMaxPadTop)
        
        if layer_query is not None and self.get_file().get_layer(layer_query).get_number() > 16 and not self._layer_matches(layer_query, "tStop") and  not self._layer_matches(layer_query,"bStop"):
            return shapes.LineString()

        if self.get_shape() == "square":
            shape = shapes.box(self.get_x() - radius ,
                               self.get_y() - radius,
                               self.get_x() + radius,
                               self.get_y() + radius)
        elif self.get_shape() == "round" or self.get_shape() is None:
            shape = shapes.point.Point(self.get_x(), self.get_y()).buffer(radius)
        elif self.get_shape() == "octagon":
            shape = shapes.box(self.get_x() - radius,
                               self.get_y() - radius,
                               self.get_x() + radius,
                               self.get_y() + radius)
            shape = shape.intersection(affinity.rotate(shape, 45))
        elif self.get_shape() == "long":
            shape = shapely.ops.unary_union([shapes.point.Point(self.get_x() + DRU.psElongationLong/100.0 * radius,
                                                                self.get_y()).buffer(radius),
                                             shapes.point.Point(self.get_x() - DRU.psElongationLong/100.0 * radius,
                                                                self.get_y()).buffer(radius),
                                             shapes.box(self.get_x() - DRU.psElongationLong/100.0 * radius,
                                                        self.get_y() - radius,
                                                        self.get_x() + DRU.psElongationLong/100.0 * radius,
                                                        self.get_y() + radius)])
        elif self.get_shape() == "offset":
            shape = shapely.ops.unary_union([shapes.point.Point(self.get_x() + DRU.psElongationOffset/100.0 * radius * 2,
                                                                self.get_y()).buffer(radius),
                                             shapes.point.Point(self.get_x(),
                                                                self.get_y()).buffer(radius),
                                             shapes.box(self.get_x(),
                                                        self.get_y() - radius,
                                                        self.get_x() + DRU.psElongationLong/100.0 * radius * 2,
                                                        self.get_y() + radius)
                                         ])
        else:
            raise Swoop.SwoopError("Unknown pad shape: '{}'".format(self.get_shape()))

        if shape is not None:
            if self._layer_matches(layer_query,"tStop") or self._layer_matches(layer_query, "bStop"):
                shape = shape.buffer(computeStopMaskExtra(radius, DRU))

        if options and "fail_on_missing" in options and options["fail_on_missing"] and shape is None:
            raise NotImplemented("Geometry for pad shape '{}' is not implemented yet.".format(self.get_shape()))
        elif shape is None:
            shape = shapes.LineString()

        return shape
Пример #27
0
def rotate_coords(coords, rot, origin):
    """
    Rotates a set of coordinates (wrapper for shapely)
    coords: sequence point tuples (x, y)
    """
    ur = LineString(unrotated)
    r = affinity.rotate(ur, rot, origin=ur[0])

    return list(zip(r.coords.xy[0], r.coords.xy[1]))
Пример #28
0
 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
Пример #29
0
 def __call__(self, point, mirror=False, rotation=0):
     panel = Polygon([(point.x+vx, point.y+vy) for vx,vy in self._vertices])
     if mirror:
         panel = Polygon([(point.x+vx, point.y+vy) for vx,vy in self._vertices_mirror])
     if rotation!=0:
         # FIXME: better to  rotate around vertex 0 than the center
         # of the polygon
         panel = rotate(panel, rotation)
     return panel
Пример #30
0
    def to_shapely(self):
        """Convert a markings.Blotch to shapely Ellipse.

        Code from https://gis.stackexchange.com/questions/243459/drawing-ellipse-with-shapely/243462
        """
        circ = geom.Point(self.center).buffer(1)
        ell = affinity.scale(circ, self.data.radius_1, self.data.radius_2)
        ellr = affinity.rotate(ell, self.data.angle)
        return ellr
Пример #31
0
    def testComputeAvgDir(self):
        crds = [[0, 0], [1, 0], [1, 2], [0, 2], [0, 0]]
        cell0 = g.Polygon(crds)

        cell = cell0
        avgDir = _computeAvgDir(cell)
        self.assertAlmostEqual(0, avgDir)

        cell = a.rotate(cell0, np.pi / 6, use_radians=True)
        avgDir = _computeAvgDir(cell)
        self.assertAlmostEqual(np.pi / 6, avgDir)

        cell = a.rotate(cell0, np.pi / 3, use_radians=True)
        avgDir = _computeAvgDir(cell)
        self.assertAlmostEqual(np.pi / 3, avgDir)

        cell = a.rotate(cell0, np.pi / 2, use_radians=True)
        avgDir = _computeAvgDir(cell)
        self.assertAlmostEqual(0, avgDir)
Пример #32
0
 def get_shapely_object(self):
     object = geometric_union([
         self._gate(),
         self._choke_channel(),
         self._choke_left(),
         self._choke_right(),
         self._channel()
     ])
     rotated_object = rotate(object, self._angle, (0, 0), True)
     return translate(rotated_object, self._origin[0], self._origin[1], 0)
Пример #33
0
def create_shapely_ellipse(center, lengths, angle=0):
    """
    create a shapely ellipse. adapted from
    https://gis.stackexchange.com/a/243462
    """
    angle = math.degrees(angle)
    circ = Point(center).buffer(1)
    ell = affinity.scale(circ, int(lengths[0]), int(lengths[1]))
    ellr = affinity.rotate(ell, angle)
    return ellr
Пример #34
0
	def predict_agents(self,agents,time_increment):
		# Loop over agents
		for agent in agents:
			# Predict Position
			agent.pos_pred  =  agent.pos_pred + agent.vel_vec*time_increment

			# Update prediction polygon 
			agent.pol_pred = agent.pol_origin
			agent.pol_pred = affinity.translate(agent.pol_pred,agent.pos_pred[0],agent.pos_pred[1])
			agent.pol_pred = affinity.rotate(agent.pol_pred,np.rad2deg(-agent.yaw), 'center')
Пример #35
0
 def special(self):
     p = self.generating_region
     xmin, ymin, xmax, ymax = p.bounds
     mx = scale(p, xfact=-1, origin=(xmax, ymin))
     my = scale(p, yfact=-1, origin=(xmax, ymin))
     mxy = scale(p, xfact=-1, yfact=-1, origin=(xmax, ymin))
     s1 = unary_union([p, mx, my, mxy])
     s1r2 = rotate(s1, angle=240, origin=(xmax, ymax))
     pr = rotate(p, angle=180, origin=(xmax / 2, 3**0.5 / 2 * xmax))
     cell_quart = unary_union([p, pr, s1r2])
     cell_quart_1 = scale(cell_quart, xfact=-1, origin=(xmax, ymin))
     cell_quart_2 = scale(cell_quart, yfact=-1, origin=(xmax, ymin))
     cell_quart_3 = scale(cell_quart,
                          xfact=-1,
                          yfact=-1,
                          origin=(xmax, ymin))
     cell = unary_union(
         [cell_quart, cell_quart_1, cell_quart_2, cell_quart_3])
     self.unit = cell
Пример #36
0
        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
Пример #37
0
 def rotate(self, angle, r_c, start_h, start_w):
     poly=self.polygons[0].numpy().reshape(-1,2)
     poly[:, 0]+=start_w
     poly[:, 1]+=start_h
     polys=Polygon(poly)
     r_polys=list(affinity.rotate(polys,angle,r_c).boundary.coords[:-1])
     p=[]
     for r in r_polys:
         p+=list(r)
     return Polygons([p], size=self.size, mode=self.mode)
Пример #38
0
    def __init__(self, center, width, height, theta):

        left = center[0] - width / 2
        right = center[0] + width / 2
        bottom = center[1] - height / 2
        top = center[1] + height / 2

        p = box(left, bottom, right, top)
        p = affinity.rotate(p, theta, origin='center', use_radians=True)
        super(RectangleCollider, self).__init__(p)
Пример #39
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])
Пример #40
0
 def minimum_oriented_boundingbox(self):
     p = self.enveloppe_convexe()
     m_bb = self.bounding_box().area
     k = 0
     for i in range(360):
         rotated_b = affinity.rotate(p, i, origin='centroid')
         a = rotated_b.bounds
         p1 = (a[0], a[1])
         p2 = (a[0], a[3])
         p3 = (a[2], a[3])
         p4 = (a[2], a[1])
         m_cc = Polygon([p1, p2, p3, p4]).area
         pp = Polygon([p1, p2, p3, p4])
         if m_cc < m_bb:
             m_bb = m_cc
             polygon_retenu = pp
             k = i
     vrai_poly = affinity.rotate(polygon_retenu, -k, origin='centroid')
     return Polygon(vrai_poly)
Пример #41
0
    def _prepare(self):
        offset_x, offset_y = self.offset_um

        self.border = affinity.rotate(self.border,
                                      self.angle_deg,
                                      origin=(0, 0),
                                      use_radians=False)
        self.border = affinity.translate(self.border, offset_x, offset_y, 0)
        for i in range(0, self.N):
            self.polys[i] = affinity.rotate(self.polys[i],
                                            self.angle_deg,
                                            origin=(0, 0),
                                            use_radians=False)
            self.polys[i] = affinity.translate(self.polys[i], offset_x,
                                               offset_y, 0)

            t = mpl.transforms.Affine2D().rotate_deg_around(0, 0, self.angle_deg)\
                                         .translate(offset_x, offset_y) + global_geom_ax.transData
            self.pieces[i].rect.set_transform(t)
Пример #42
0
    def build_shapely_geometry(self) -> BaseGeometry:
        """
        Builds the internal shapely representation of the geometry.  This is used by other base class methods
        to build the other output types.

        :return: A shapely geometry specific to the derived type.
        :rtype: :py:class:`BaseGeometry`
        """
        # Get the UTMSRID so we can transform the center point to a coordinate system where distance is
        # measured in meters.
        utmsrid: int = getutmsrid(self.longitude, self.latitude, self.sr_id)
        # Create the OGR Point
        center: ogr.Geometry = ogr.Geometry(ogr.wkbPoint)
        center.AssignSpatialReference(Geodetic2D.get_ogr_sr(self.sr_id))
        center.AddPoint(self.longitude, self.latitude)
        # Project the point from its native projection to the UTM system.
        center = reproject_geom(center, self.sr_id, utmsrid)
        # Buffer the point with the radius to get a polygon of the circle.
        circle: ogr.Geometry = center.Buffer(1)

        # Create the shapely object so we can do the ellipse magic.
        proto_ellipse: BaseGeometry = loads(circle.ExportToWkt())
        # stretch the ellipse along the major and minor axes
        scaled_ellipse: BaseGeometry = affinity.scale(proto_ellipse, self.majorAxis, self.minorAxis)

        rotate_angle = calculate_orientation(self.orientation)

        rotated_ellipse: BaseGeometry = None
        if rotate_angle >= 0:
            # Let rotate the ellipse (clockwise, x axis pointing right):
            rotated_ellipse = affinity.rotate(scaled_ellipse, rotate_angle, use_radians=True)
        else:
            # If one need to rotate it clockwise along an upward pointing x axis:
            rotated_ellipse = affinity.rotate(scaled_ellipse, 90 - rotate_angle, use_radians=True)
            # According to the man, a positive value means a anti-clockwise angle,
            # and a negative one a clockwise angle.

        # Now build an OGR geometry so we can reproject.
        ogr_ellipse: ogr.Geometry = ogr.CreateGeometryFromWkt(rotated_ellipse.wkt)
        ogr_ellipse.AssignSpatialReference(Geodetic2D.get_ogr_sr(utmsrid))
        ogr_ellipse = reproject_geom(ogr_ellipse, utmsrid, self.sr_id)

        return loads(ogr_ellipse.ExportToWkt())
Пример #43
0
def create_ellipse(x,y,a,b,theta,scale):
    """
    create a shapely ellipse. adapted from
    https://gis.stackexchange.com/a/243462
    """
    x,y,a,b = x*scale,y*scale,a*scale,b*scale
    circ = Point((int(x),int(y))).buffer(1)
    ell =  affinity.scale(circ, int(a), int(b))
    ellr = affinity.rotate(ell, theta)
    return ellr
 def rotate(self, angle, r_c, start_h, start_w):
     r_polys = []
     for poly in self.char_boxes:
         poly = poly.numpy()
         poly[0::2] += start_w
         poly[1::2] += start_h
         poly= Polygon(np.array(poly).reshape(4,2))
         r_poly = np.array(list(affinity.rotate(poly, angle, r_c).boundary.coords[:-1])).reshape(-1, 8)
         r_polys.append(r_poly[0])
     return CharPolygons(r_polys, word=self.word, use_char_ann=self.use_char_ann,char_classes=self.char_classes,size=(r_c[0]*2,r_c[1]*2), mode=self.mode)
Пример #45
0
    def test_Tessellation(self):
        tes = mm.Tessellation(self.df_buildings, "uID", self.limit, segment=2)
        tessellation = tes.tessellation
        assert len(tessellation) == len(self.df_tessellation)
        bands = mm.Tessellation(self.df_streets,
                                "nID",
                                mm.buffered_limit(self.df_streets, 50),
                                segment=5).tessellation
        assert len(bands) == len(self.df_streets)

        #  test_enclosed_tessellation
        enc1 = mm.Tessellation(self.df_buildings,
                               "uID",
                               enclosures=self.enclosures).tessellation
        assert len(enc1) == 155
        assert isinstance(enc1, gpd.GeoDataFrame)

        enc1_loop = mm.Tessellation(self.df_buildings,
                                    "uID",
                                    enclosures=self.enclosures,
                                    use_dask=False).tessellation
        assert len(enc1) == 155
        assert isinstance(enc1, gpd.GeoDataFrame)

        assert len(enc1_loop) == 155
        assert isinstance(enc1_loop, gpd.GeoDataFrame)

        assert_geodataframe_equal(enc1, enc1_loop)

        with pytest.raises(ValueError):
            mm.Tessellation(self.df_buildings,
                            "uID",
                            limit=self.limit,
                            enclosures=self.enclosures)

        enc1_loop = mm.Tessellation(self.df_buildings,
                                    "uID",
                                    enclosures=self.enclosures,
                                    use_dask=False).tessellation
        assert len(enc1) == 155
        assert isinstance(enc1, gpd.GeoDataFrame)

        # erroneous geometry
        df = self.df_buildings
        b = df.total_bounds
        x = np.mean([b[0], b[2]])
        y = np.mean([b[1], b[3]])

        df.loc[144] = [145, Polygon([(x, y), (x, y + 1), (x + 1, y)])]
        df.loc[145] = [146, MultiPoint([(x, y), (x + 1, y)]).buffer(0.55)]
        df.loc[146] = [147, affinity.rotate(df.geometry.iloc[0], 12)]

        tess = mm.Tessellation(df, "uID", self.limit)
        assert tess.collapsed == {145}
        assert len(tess.multipolygons) == 3
Пример #46
0
def generate_signals(polygon,
                     angles_deg,
                     samples=1024,
                     cpm_points=None,
                     vertical_error=None,
                     horizontal_error=None,
                     angles_deg_errors=None):

    if not vertical_error:
        vertical_error = 0
    if not horizontal_error:
        horizontal_error = 0

    if angles_deg_errors:
        for index, angle in enumerate(angles_deg):
            angles_deg[index] += angles_deg_errors[index]

    angles = [((i / 360) * 2 * np.pi) for i in angles_deg]

    # TODO: replace 100 with max distance
    probe_distance = 1000
    probe_pos = [
        Point(probe_distance * np.cos(angle), probe_distance * np.sin(angle))
        for angle in angles
    ]
    probe_lines = [
        geometry.LineString([Point(0, 0), pos]) for pos in probe_pos
    ]

    thetas = np.linspace(0, np.pi * 2, samples)
    # initialize list of signals
    signals = [[] for _ in range(len(angles))]

    # print("starting signals")

    for theta_index, theta in enumerate(thetas):

        # CPM movement
        translated = affinity.translate(polygon, cpm_points[theta_index][0],
                                        cpm_points[theta_index][1])

        # error position of the frame
        translated = affinity.translate(translated, horizontal_error,
                                        vertical_error)

        rotated = affinity.rotate(translated, theta, use_radians=True)
        for index, angle in enumerate(angles):
            line = probe_lines[index]

            # intersection = line.intersection(rotated)
            intersection = line.intersection(rotated.boundary)
            dist = intersection.distance(probe_pos[index])
            signals[index].append(dist)

    return signals
Пример #47
0
    def get_forward_wall_camera_direction(self, point):
        wall = self.point2wall[(point.x, point.y)]
        vector0 = scale_line_length(LineString([(point.x, point.y), wall[0]]), ALLOWED_DISTANCE_ERROR)
        vector1 = scale_line_length(LineString([(point.x, point.y), wall[1]]), ALLOWED_DISTANCE_ERROR)
        for v in (vector0, vector1):
            u = rotate(v, 90, origin=point, use_radians=False)
            if not self.polygon.contains(Point(u.coords[1])):
                p1, p2 = u.coords
                return Point(p2[0] - p1[0], p2[1] - p1[1])

        raise NotImplementedError
Пример #48
0
 def create_ellipse(self, ratio):
     """
     create a shapely ellipse. adapted from
     https://gis.stackexchange.com/a/243462
         https://gis.stackexchange.com/questions/243459/drawing-ellipse-with-shapely/243462#243462
     """
     circ = Point(self.center).buffer(1.0)
     ell = affinity.scale(circ, float(self.lengths[0] * ratio),
                          float(self.lengths[1] * ratio))
     ellr = affinity.rotate(ell, self.angle)
     return ellr
Пример #49
0
        def translate_and_rotate(geometry, offset, angle, columns, rows,
                                 spacing):
            if not geometry:
                return geometry

            if not spacing:
                return translate(
                    rotate(geometry,
                           angle if angle else 0,
                           use_radians=True,
                           origin=(0, 0)), *offset)

            return translate(
                geometric_union(
                    translate(
                        rotate(geometry,
                               angle if angle else 0,
                               use_radians=True,
                               origin=(0, 0)), spacing[0] * c, spacing[1] * r)
                    for c in range(columns) for r in range(rows)), *offset)
Пример #50
0
 def getOverlapArea(self, shape=None, offset=None, angle=None):
     if not shape: shape = self.shape_buffer
     if not offset: offset = self.offset
     if not angle: angle = self.angle
     area = 0
     shape = affinity.translate(affinity.rotate(shape, angle, origin=(0,0)), *offset)
     overlaps = [h for h in self.tree.query(shape)]
     for h in overlaps:
         area += shape.intersection(h).area
     area += shape.difference(self.board).area
     return area
Пример #51
0
 def __init__(self, cx, cy, width, length, rotation=0.):
     self.center = [cx,cy]
     self.width = width
     self.length = length
     self.rotation = rotation
     x = numpy.array([-width/2, width/2])+cx
     y = numpy.array([-length/2, length/2])+cy
     square = asPolygon(numpy.append(numpy.roll(numpy.repeat(x,2),-1),
                                     numpy.repeat(y,2)).reshape(2,4).T)
     # rotate() function is provided by shapely.affinity package
     super(SlitAperture, self).__init__(rotate(square, rotation))
Пример #52
0
 def update_abs(self, turtle):
     x = turtle.pos[0]
     y = turtle.pos[1]
     angle = turtle.angle
     pivot = (0, 0)
     point = Point(self.x_off, self.y_off)
     point = affinity.rotate(point, angle, origin=pivot)
     point = affinity.translate(point, xoff=x, yoff=y)
     self.abs_x_off = point.x
     self.abs_y_off = point.y
     self.abs_angle = angle + self.angle % 360
Пример #53
0
 def fresnel(self, clearance=False):
     f1 = math.sqrt(self.l * self.distance / 4)
     radius = f1
     if clearance:
         radius *= 0.6
     S = Point(self.A.x + self.distance / 2, self.A.y)
     alpha = math.atan2(self.B.y - self.A.y, self.B.x - self.A.x)
     C = S.buffer(self.distance / 2)
     C = scale(C, 1, radius / (self.distance / 2))
     C = rotate(C, alpha, origin=self.A, use_radians=True)
     return C
Пример #54
0
    def setup_method(self):

        t1 = Polygon([(0, 0, 0), (1, 0, 0), (1, 1, 1)])
        t2 = Polygon([(1, 0, 0), (2, 0, 0), (2, 1, 1)])
        self.polys = GeoSeries([t1, t2], index=list('AB'))
        self.df = GeoDataFrame({'geometry': self.polys, 'values': [0, 1]})

        multipoly1 = MultiPolygon([t1, t2])
        multipoly2 = rotate(multipoly1, 180)
        self.df2 = GeoDataFrame({'geometry': [multipoly1, multipoly2],
                                 'values': [0, 1]})
Пример #55
0
    def createPolygon(self, item):
        # x,y,h,w,theta
        # x,y - center coordinates
        #h,w -  its size
        # theta - orientations

        x, y, h, w, t = item
        coords = [(-w, -h), (w, -h), (w, h), (-w, h)]
        p = Polygon(coords)
        #print(x,y,h,w,t)
        return translate(rotate(p, t), x, y)
Пример #56
0
    def setup_method(self):
        self.N = 10
        self.points = GeoSeries(Point(i, i) for i in range(self.N))

        values = np.arange(self.N)
        self.df = GeoDataFrame({'geometry': self.points, 'values': values})

        multipoint1 = MultiPoint(self.points)
        multipoint2 = rotate(multipoint1, 90)
        self.df2 = GeoDataFrame({'geometry': [multipoint1, multipoint2],
                                 'values': [0, 1]})
Пример #57
0
    def infrared_right(self):
        ir = Polygon([
            np.array(self._robot.pos.coords)[0] + (self._robot.bounding_x, self._robot.bounding_y),
            np.array(self._robot.pos.coords)[0] + (self._robot.bounding_x, self._robot.bounding_y) + (self.infrared_length, -self.infrared_width),
            np.array(self._robot.pos.coords)[0] + (self._robot.bounding_x, self._robot.bounding_y) + (self.infrared_length,  self.infrared_width)])

        ir = affinity.rotate(ir, self._robot.rotation + 0.07, origin=self._robot.pos, use_radians=True)

        return not self.area.contains(ir) \
            or np.array([ir.intersects(cube) for cube in self._red_cubes]).any() \
            or np.array([ir.intersects(cube) for cube in self._obstacles]).any()
Пример #58
0
 def __call__(self, point, step, rotation=0):
     grid = []
     if self.shape == 'diamond':
         grid = self.diamond(point, step)
     elif self.shape == 'square':
         grid = self.square(point, step)
     elif self.shape == 'hexagon':
         grid = self.hexagon(point, step)
     if rotation != 0:
         grid = [rotate(point, rotation, origin=point) for point in grid]
     return grid
Пример #59
0
 def __call__(self, point, mirror=False, rotation=0):
     panel = Polygon([(point.x + vx, point.y + vy)
                      for vx, vy in self._vertices])
     if mirror:
         panel = Polygon([(point.x + vx, point.y + vy)
                          for vx, vy in self._vertices_mirror])
     if rotation != 0:
         # FIXME: better to  rotate around vertex 0 than the center
         # of the polygon
         panel = rotate(panel, rotation)
     return panel
Пример #60
0
    def __init__(self, name, x, y, angle=0, size=None, shape=None, drill=None):
        self.name = name
        self.angle = angle

        point = affinity.rotate(Point(x, y), angle, origin=Point(0, 0))
        self.location = np.array([point.coords[0][0], point.coords[0][1], 1])

        # Optional properties for pcb export
        self.size = size
        self.shape = shape
        self.drill = drill