示例#1
0
    def __init__(self, *args):

        """ The parameter *args* is an iterable of :class:`PyGeoPortail.Geometry.Vector2D` that defines the
        vertexes.
        """

        array = self._check_arguments(args)
        
        self.vertexes = array[:]
        self.edges = [p1 - p0 for p0, p1 in closed_pairwise(self.vertexes)]
示例#2
0
    def intersec_with_grid(self, grid_step):

        interval = self.to_interval()
        interval_on_grid = IntervalInt2D((self._to_grid(interval.x.inf, grid_step),
                                          self._to_grid(interval.x.sup, grid_step)),
                                         (self._to_grid(interval.y.inf, grid_step),
                                          self._to_grid(interval.y.sup, grid_step)))
        # print(interval, interval_on_grid)
        
        Y_min = interval_on_grid.y.inf
        rows = [[] for i in range(interval_on_grid.y.length())]
        for p0, p1 in closed_pairwise(self.vertexes):
            # print('\nEdge', p0, p1)
            X0, Y0 = self._to_grid(p0.x, grid_step), self._to_grid(p0.y, grid_step)
            X1, Y1 = self._to_grid(p1.x, grid_step), self._to_grid(p1.y, grid_step)
            # print('({}, {}) -> ({}, {})'.format(X0, Y0, X1, Y1))
            
            line = Line2D.from_two_points(p0, p1)
            
            if Y0 == Y1:
                pass
            elif Y1 > Y0:
                rows[Y0 - Y_min].append(OpenInterval(X0, 1))
                for Y in range(Y0 +1, Y1 +1):
                    y = Y * grid_step
                    x = line.get_x_from_y(y)
                    X = self._to_grid(x, grid_step)
                    YY = Y - Y_min
                    if X1 < X0:
                        YY -= 1
                    open_interval = OpenInterval(X, 1)
                    # print(Y, x, y, X, YY, open_interval)
                    rows[YY].append(open_interval)
                rows[Y1 - Y_min].append(OpenInterval(X1, 1))
            elif Y1 < Y0:
                rows[Y1 - Y_min].append(OpenInterval(X1, -1))
                for Y in range(Y1 +1, Y0 +1):
                    y = Y * grid_step
                    x = line.get_x_from_y(y)
                    X = self._to_grid(x, grid_step)
                    YY = Y - Y_min
                    if X1 < X0:
                        YY -= 1
                    open_interval = OpenInterval(X, -1)
                    # print(Y, x, y, X, YY, open_interval)
                    rows[YY].append(open_interval)
                rows[Y0 - Y_min].append(OpenInterval(X0, -1))
        
        runs = []
        for i, row in enumerate(rows):
            row.sort()
            Y = Y_min + i
            # print('{}: {}'.format(Y, ' '.join([str(x) for x in row])))
            previous_interval = row[0]
            x_inf = previous_interval.x
            intervals = [IntervalInt(x_inf, x_inf)]
            for open_interval in row[1:]:
                if open_interval.is_gap(previous_interval):
                    x_inf = open_interval.x
                    intervals.append(IntervalInt(x_inf, x_inf))
                else:
                    intervals[-1].sup = open_interval.x
                previous_interval = open_interval
            # print('    ' + ' '.join([str(x) for x in intervals]))
            # runs.append((Y, IntervalInt(row[0].x, row[-1].x)))
            for interval in intervals:
                runs.append((Y, interval))
        
        return TilePolygon(self, runs)