Ejemplo n.º 1
0
def score_hour_lines(draw: ImageDraw):
    for hour in range(HOURS):
        y = hour * HOUR_HEIGHT
        draw.line((
            (0, y),
            (NUM_DAYS * DAY_WIDTH, y),
        ), fill='grey')
Ejemplo n.º 2
0
    def _render(self, draw: ImageDraw.ImageDraw, image: Image.Image):
        rect = (self._position[0], self._position[1],
                self._position[0] + self._width, self._position[1] + self._height)
        # Border
        draw.rectangle(rect, fill=0, outline=1)

        # Fill
        p_range = abs(self._min_value) + abs(self._max_value)
        zero_pct = (0 + abs(self._min_value)) / p_range
        zero_pt = (self._position[0] + 2 + (zero_pct * (self._width - 4)),
                   self._position[1] + 2)
        val_pct = self._value / (self._max_value - self._min_value)
        fill_rect = (zero_pt[0], zero_pt[1],
                     zero_pt[0] + (val_pct * (self._width - 4)), zero_pt[1] + self._height - 4)
        draw.rectangle(fill_rect, fill=1)

        # Draw Zero Indicator
        draw.line((zero_pt[0], zero_pt[1] - 1,
                   zero_pt[0], zero_pt[1] + self._height - 2),
                  fill=255, width=1)

        # Draw Intervals
        if self._interval > 0:
            for i in range(0, self._max_value + 1, self._interval):
                itv_pct = i / p_range
                itv_pos = (zero_pt[0] + (itv_pct * (self._width - 4)), zero_pt[1] + (self._height / 2))
                draw.line((itv_pos[0], itv_pos[1], itv_pos[0], zero_pt[1] + self._height - 3),
                          fill=255, width=1)

            for i in range(0, self._min_value - 1, -self._interval):
                itv_pct = i / p_range
                itv_pos = (zero_pt[0] + (itv_pct * (self._width - 4)), zero_pt[1] + (self._height / 2))
                draw.line((itv_pos[0], itv_pos[1], itv_pos[0], zero_pt[1] + self._height - 3),
                          fill=255, width=1)
    def generate_image(self, num_digits=30, noise=None):
        if noise:
            a = np.array(np.random.random_integers(0, 64, (self._height, self._width)), dtype=np.uint8)
        else:
            a = np.zeros((self._height, self._width), dtype=np.uint8)

        im = Image.frombytes('L', (self._width, self._height), a.tobytes())
        canvas = ImageDraw(im)

        for i in range(num_digits):
            import random

            x = random.randint(0, self._width - self._char_size)
            y = random.randint(0, self._height - self._char_size)

            class_index = random.randint(0, self._num_classes - 1)
            ch = str(class_index)

            character_bitmap = self._factory.get_digit_image(ch)
            character_bitmap = character_bitmap.resize(
                (self._char_size, self._char_size)
            )

            canvas.bitmap((x, y), character_bitmap, fill=255)

        return im
Ejemplo n.º 4
0
    def _render(self, draw: ImageDraw.ImageDraw, image: Image.Image):
        rect = (self._position[0], self._position[1],
                self._position[0] + self._width, self._position[1] + self._height)

        draw.rectangle(rect,
                       fill=255 if self._filled else 0,
                       outline=self._bordered)
Ejemplo n.º 5
0
def word_wrap(text: str, draw: ImageDraw.ImageDraw, width: int) -> str:
    text_width, text_height = draw.multiline_textsize(text, font=font)
    if text_width > width:
        lines = text.splitlines()
        wrapped_text = []
        for line in lines:
            line_width, _ = draw.textsize(line, font=font)
            if line_width > width:
                new_line = ''
                last_line = new_line
                for word in line.split():
                    if len(new_line) > 0:
                        new_line += ' '
                    new_line += word
                    line_width, _ = draw.textsize(new_line, font=font)
                    if line_width > width:
                        wrapped_text.append(last_line)
                        new_line = word
                    last_line = new_line
                if len(last_line) > 0:
                    wrapped_text.append(last_line)
            else:
                wrapped_text.append(line)
        return '\n'.join(wrapped_text)
    else:
        return text
Ejemplo n.º 6
0
def line(draw: ImageDraw, coord1: Coordinate, coord2: Coordinate):
    """Draws a line between two given Coordinates.
    The color of the line depends on the Y value (low = black, high = white)

    Arguments:
        draw {ImageDraw} -- The ImageDraw to draw on
        coord1 {Coordinate} -- Coordinate of the original position
        coord2 {Coordinate} -- Coordinate of the next position
    """
    #               R    G    B
    # low    black: 0    0    0
    # high   white: 225  225  255

    # Limit elevation to be between 70 and 120
    ll = 70.0
    ul = 120.0

    pos1 = coord1.coord_3d
    pos2 = coord2.coord_3d
    elev = max(ll, min(pos1[1], ul))

    # The RGB tuple to make the gray for the given elevation
    gray = (int(scale(elev, (ll, ul), (0.0, 255.0))), ) * 3

    draw.line([(pos1[0], pos1[2]), (pos2[0], pos2[2])], gray, 4)
Ejemplo n.º 7
0
def color_pix(color):
    im = new_im('RGB', (128, 128))
    draw = ImageDraw(im, 'RGB')
    draw.rectangle((0, 0, 128, 128),
                   fill=(int(color[1:3], 16), int(color[3:5],
                                                  16), int(color[5:], 16)))
    return toqpixmap(im)
Ejemplo n.º 8
0
 def do_I_have_to_draw_you_a_picture(self):
     """ Return a little thumbs-up / thumbs-down image with text in it.
     """
     if self.success:
         bytes, color = _thumbs_up_bytes, _thumbs_up_color
     else:
         bytes, color = _thumbs_down_bytes, _thumbs_down_color
     
     thumb = Image.open(StringIO(bytes))
     image = Image.new('RGB', (256, 256), color)
     image.paste(thumb.resize((128, 128)), (64, 80))
     
     mapnik_url = 'http://tile.openstreetmap.org/%(zoom)d/%(column)d/%(row)d.png' % self.coord.__dict__
     mapnik_img = Image.open(StringIO(urlopen(mapnik_url).read()))
     mapnik_img = mapnik_img.convert('L').convert('RGB')
     image = Image.blend(image, mapnik_img, .15)
     
     draw = ImageDraw(image)
     margin, leading = 8, 12
     x, y = margin, margin
     
     for word in self.content.split():
         w, h = draw.textsize(word)
         
         if x > margin and x + w > 250:
             x, y = margin, y + leading
         
         draw.text((x, y), word, fill=(0x33, 0x33, 0x33))
         x += draw.textsize(word + ' ')[0]
     
     return image
Ejemplo n.º 9
0
def draw_eye_vector(drawer: ImageDraw.ImageDraw, eye_3d_vector: np.ndarray,
                    solver: PNP_solver.PoseEstimator,
                    rotation: np.ndarray, translation: np.ndarray, eye_pos: str) -> None:
    """Draw gaze vector eye from eye on a picture drawer

    :param drawer: where to draw
    :param eye_3d_vector: what vector(in camera coordinate system)
    :param solver:
    :param rotation: head rotation
    :param translation: head translation
    :param eye_pos: "l" for left, "r" for right
    :return:
    """
    if eye_pos == "l":
        eye_pos = (solver.model_points_68[36] + solver.model_points_68[39]) / 2.
    else:
        eye_pos = (solver.model_points_68[42] + solver.model_points_68[45]) / 2.

    eye_3d_vector = copy.deepcopy(eye_3d_vector) * -50

    # eye coordinate in camera coordinate system is determined
    to_camera_matrix = get_world_to_camera_projection_matrix(solver, rotation, translation)
    eye_pos = np.matmul(to_camera_matrix, [*eye_pos, 1])

    no_rot_vector, _ = cv2.Rodrigues(np.array([[1., 0., 0.], [0., 1., 0.], [0., 0., 1.]]))
    vect_start, _ = cv2.projectPoints(eye_pos, no_rot_vector, [0, 0, 0], solver.camera_matrix,
                                      solver.dist_coeefs)
    vect_finish, _ = cv2.projectPoints(eye_3d_vector + eye_pos, no_rot_vector, [0, 0, 0],
                                       solver.camera_matrix, solver.dist_coeefs)

    drawer.line([*vect_start, vect_start[0] + vect_finish[0], vect_start[1] + vect_finish[1]], fill=(0, 255, 0))
    drawer.ellipse([vect_start[0] - 2, vect_start[1] - 2, vect_start[0] + 2, vect_start[1] + 2])
Ejemplo n.º 10
0
def verification_code(request):
    """
    :param request:
    :return:
    about:生成4位随机验证码图
    """
    mode = 'RGB'
    size = (100, 34)
    color_bg = (get_bg_color(), get_bg_color(), get_bg_color())
    # 画布
    image = Image.new(mode=mode, size=size, color=color_bg)
    # 画笔
    image_draw = ImageDraw(image, mode=mode)
    image_font = ImageFont.truetype(settings.FONT_PATH, random.randrange(30, 34))
    # 绘制文字
    code = get_code()
    request.session['verification_code'] = code
    for i in range(4):
        fill = (get_color(), get_color(), get_color())
        image_draw.text(xy=(i * random.randrange(18, 28), random.randrange(5)), text=code[i], font=image_font, fill=fill)
    for i in range(2):
        fill = (get_color(), get_color(), get_color())
        xy1 = ((random.randrange(100), random.randrange(50)), (random.randrange(75), random.randrange(25)))
        image_draw.line(xy=xy1, fill=fill)
        xy2 = ((random.randrange(50), random.randrange(100)), (random.randrange(34), random.randrange(13)))
        image_draw.line(xy=xy2, fill=fill)
    for i in range(10):
        fill = (get_color(), get_color(), get_color())
        xy1 = ((random.randrange(100), random.randrange(50)), (random.randrange(75), random.randrange(25)))
        image_draw.point(xy=xy1, fill=fill)
    # 变成比特流
    fp = BytesIO()
    image.save(fp, 'png')
    return HttpResponse(fp.getvalue(), content_type='image/png')
Ejemplo n.º 11
0
def add_polygon_to_image(draw: ImageDraw.ImageDraw,
                         poly_points: list,
                         scale: float,
                         line_color: str,
                         fill_color: str = None) -> None:
    """Draw a polygon on an image

    This will draw a polygon on the passed-in image in the specified
    colors and scale.

    :param draw: The drawable surface to write on
    :param poly_points: A sequence of points representing the polygon,
        where each point has float members (x, y)
    :param scale: Scale to multiply each point to match the image scaling
    :param line_color: The color for the outline of the polygon. The string value
        must be a color string suitable for use with PIL - see :mod:`PIL.ImageColor`
    :param fill_color: The color for the inside of the polygon. The string value
        must be a color string suitable for use with PIL - see :mod:`PIL.ImageColor`
    """
    if len(poly_points) < 2:
        # Need at least 2 points to draw any lines
        return

    # Convert poly_points to the PIL format and scale them to the image
    pil_poly_points = []
    for pt in poly_points:
        pil_poly_points.append((pt.x * scale, pt.y * scale))

    draw.polygon(pil_poly_points, fill=fill_color, outline=line_color)
Ejemplo n.º 12
0
def getcode(request):
    mode = 'RGB'
    size = [200, 100]
    color_bg = getcolor()
    image = Image.new(mode=mode, size=size, color=color_bg)
    imagedraw = ImageDraw(image, mode=mode)

    iamgefont = ImageFont.truetype(settings.FONT_PATH, 30)
    verify_code = 'Come'
    for i in range(len(verify_code)):
        # file text填充色
        fill = getcolor()
        imagedraw.text(xy=(30 * i, 30), text=verify_code[i], font=iamgefont, fill=fill)
    # 干扰点
    for i in range(1000):
        xy = (random.randrange(size[0]), random.randrange(size[1]))
        fill = getcolor()
        imagedraw.point(xy=xy, fill=fill)
    # 画圆 xy区域,四元数组  start int end int 圆经过strat和end
    start = random.randrange(size[0])
    end = random.randrange(size[1])
    fill = getcolor()
    imagedraw.arc(xy=(0, 0, 200, 100), start=start, end=end, fill=fill)
    for i in range(10):
        imagedraw.line(xy=(
        random.randrange(size[0]), random.randrange(size[1]), (random.randrange(size[0]), random.randrange(size[1]))),
                       fill=getcolor())
    fp = BytesIO()

    image.save(fp, 'png')
    cache.set('code', verify_code)

    return HttpResponse(fp.getvalue(), content_type='image/png')
Ejemplo n.º 13
0
def add_img_box_to_image(
        draw: ImageDraw.ImageDraw,
        box: util.ImageRect,
        color: str,
        text: Union[ImageText, Iterable[ImageText]] = None) -> None:
    """Draw a box on an image and optionally add text.

    This will draw the outline of a rectangle to the passed in image
    in the specified color and optionally add one or more pieces of text
    along the inside edge of the rectangle.

    :param draw: The drawable surface to write on
    :param box: The ImageBox defining the rectangle to draw
    :param color: A color string suitable for use with PIL - see :mod:`PIL.ImageColor`
    :param text: The text to display - may be a single ImageText instance,
        or any iterable (eg a list of ImageText instances) to display multiple pieces of text.
    """
    x1, y1 = box.x_top_left, box.y_top_left
    x2, y2 = (box.x_top_left + box.width), (box.y_top_left + box.height)
    draw.rectangle([x1, y1, x2, y2], outline=color)
    if text is not None:
        if isinstance(text, collections.Iterable):
            for t in text:
                t.render(draw, (x1, y1, x2, y2))
        else:
            text.render(draw, (x1, y1, x2, y2))
Ejemplo n.º 14
0
def __draw_header_without_profile_pic(
    tweet_info: TweetInfo,
    graphic_settings: GraphicSettings,
    wip_img: Image.Image,
    draw_interface: ImageDraw.ImageDraw,
    coordinates: Tuple[int],
    header_height: int,
    font_header: ImageFont.FreeTypeFont,
) -> int:
    """Draw the graphic's header: username and user tag only.

    Parameters
    ----------
    tweet_info : TweetInfo
        Dictionary with all the tweet's information.
    graphic_settings : GraphicSettings
        Dictionary with the graphic's settings.
    wip_img : Image.Image
        Work-in-progress tweet graphic.
    draw_interface : ImageDraw.ImageDraw
        Interface used to draw in the Image.
    coordinates : Tuple[int]
        Initial coordinates at which to draw the header.
    header_height : int
        Total height of the header.
    font_header : ImageFont.FreeTypeFont
        Font used for the header.
    profile_picture : Image.Image
        Profile picture ready to be drawn in the graphic.

    Returns
    -------
    int
        Vertical coordinate at which to start drawing the tweet body.
    """
    x = coordinates[0]
    y = coordinates[1]

    username = tweet_info["user_name"]
    user_name = wrap(username, 19)
    user_tag = tweet_info["user_tag"]
    text_color = graphic_settings["color_scheme"][1]
    margin = graphic_settings["margin_bottom"]
    profile_pic_width = graphic_settings["profile_pic_size"][0]

    # Draw the username
    user_name = wrap(username, 38)
    for line in user_name:
        draw_interface.text((x, y), line, font=font_header, fill=text_color)
        y += font_header.size + margin

    # Draw the user tag
    draw_interface.text((x, y), user_tag, font=font_header, fill=text_color)

    # Calculate the vertical coordinate at which to start drawing the\
    # tweet text
    return_y = coordinates[1] + header_height + margin

    # Return the current vertical coordinate
    return return_y
Ejemplo n.º 15
0
def build_monster(seed=None, size=None):
    #capture random state
    rand_state = random.getstate()

    if not seed:
        seed = md5(str(random.getrandbits(128))).hexdigest()

    random.seed(seed)

    parts = (
        ('legs', random.randint(0, 4), random.randint(1, 5)),
        ('hair', random.randint(0, 4), random.randint(1, 5)),
        ('arms', random.randint(0, 4), random.randint(1, 5)),
        ('body', random.randint(0, 4), random.randint(1, 15)),
        ('eyes', random.randint(0, 4), random.randint(1, 15)),
        ('mouth', random.randint(0, 4), random.randint(1, 10)),
    )

    #restore random state
    random.setstate(rand_state)

    # make a base monster:
    monster_im = Image.new('RGB', (120, 120))
    monster_id = ImageDraw(monster_im)
    monster_id.rectangle((0, 0, 120, 120), fill="white", outline="white")

    for part, flip, index in parts:
        f = path(__file__).dirname().abspath() / 'parts' / '%s_%d.png' % (part, index)
        part_im = Image.open(f)
        monster_im.paste(part_im, (0, 0), part_im)

    if size:
        monster_im = monster_im.resize(size, Image.ANTIALIAS)
    return monster_im
Ejemplo n.º 16
0
 def _draw_num(self,
               num: int,
               draw: ImageDraw,
               x_offset: float = 0,
               y_offset: float = 0):
     for points in self.num_points(num, x_offset, y_offset):
         draw.polygon(points, fill=self.fg)
Ejemplo n.º 17
0
 def _render_label_box(
         self,
         draw: ImageDraw.ImageDraw,
         top_left: Tuple[int, int],
         text: str,
         padding: int = 10,
         background_color: Tuple[int, int, int] = (255, 255, 255),
         outline_color: Tuple[int, int, int] = (0, 0, 0),
         text_color: Tuple[int, int, int] = (0, 0, 0),
 ):
     text_size = draw.textsize(text, font=self.font)
     offset_x, offset_y = self.font.getoffset(text)
     text_width = text_size[0] + offset_x
     text_height = text_size[1] + offset_y
     x, y = top_left
     bottom_right = (
         x + self.border * 2 + padding * 2 + text_width,
         y + padding + text_height,
     )
     box_coords = [top_left, bottom_right]
     draw.rectangle(
         box_coords,
         fill=background_color,
         outline=outline_color,
         width=self.border,
     )
     text_coordinate = (
         x + self.border + padding - offset_x,
         y + self.border + padding - offset_y + 1,
     )
     draw.text(text_coordinate, text, font=self.font, fill=text_color)
Ejemplo n.º 18
0
def makeCircleMaskImage(width, height):
    center = (width / 2, height / 2)
    smallerDimension = min(width, height)
    image = Image.new('1', (width, height))
    draw = ImageDraw(image)
    draw.ellipse(boundingBoxSquare(center, smallerDimension), fill='white')
    return image
Ejemplo n.º 19
0
def draw_title(
        draw: ImageDraw.ImageDraw,
        title_font: ImageFont.FreeTypeFont,
        title: str,
        sub_title: Optional[str] = None,
        sub_title_font: Optional[ImageFont.FreeTypeFont] = None) -> None:
    size_width, size_height = draw.textsize(title, title_font)
    x_padding = 20
    y_padding = 4

    draw.rectangle(((0, 0), (size_width + x_padding, size_height + y_padding)),
                   fill=0x00)
    draw.text(((size_width + x_padding) // 2, (size_height + y_padding) // 2),
              title,
              fill="white",
              font=title_font,
              anchor='mm')
    if (sub_title):
        if (not sub_title_font):
            sub_title_font = title_font
        sub_title_size_width, _ = draw.textsize(sub_title, sub_title_font)
        draw.rectangle(((size_width + x_padding, 0),
                        (size_width + x_padding + sub_title_size_width + 40,
                         size_height + y_padding)),
                       fill=0xff,
                       outline=0,
                       width=4)
        draw.text(((size_width + x_padding + (sub_title_size_width + 40) // 2),
                   (size_height + y_padding) // 2),
                  sub_title,
                  fill="black",
                  font=sub_title_font,
                  anchor='mm')
Ejemplo n.º 20
0
    def run(self):  # no need to overwrite parent's init

        turtle = self.turtle
        colors = self.colors

        if self.load_from_cache():
            return

        self.canvas.begin_new()
        im_draw = ImageDraw(self.canvas.pil_image)

        color = self.colors["1"]

        # Calculate size, and scale to fill the frame
        t_width = turtle.rightmost[0] - turtle.leftmost[0]
        t_height = turtle.bottommost[1] - turtle.topmost[1]

        if t_width / t_height > 1:  # fat image scale according to width
            scale_factor = self.canvas.c_width / t_width
        else:
            scale_factor = self.canvas.c_height / t_height

        left_margin = (self.canvas.c_width - scale_factor * t_width) / 2
        top_margin = (self.canvas.c_height - scale_factor * t_height) / 2

        x_shift = left_margin - scale_factor * turtle.leftmost[0]
        y_shift = top_margin - scale_factor * turtle.topmost[1]

        coordinates = []

        for item in turtle.lines:
            if self._stop_drawing.isSet():
                return
            if isinstance(item, PlaceHolder):
                coordinates.append(item)
            else:
                coordinates.append((item[0] * scale_factor + x_shift,
                                    item[1] * scale_factor + y_shift,
                                    item[2] * scale_factor + x_shift,
                                    item[3] * scale_factor + y_shift))

        i = 0
        for item in coordinates:
            if self._stop_drawing.isSet():
                return

            "Update canvas after each 3000 stroke"
            i += 1
            if i > 3000:
                self.canvas.update_image()
                i = 0
            if isinstance(item, PlaceHolder):  # not a list of coordinates
                if item.value in colors:
                    color = colors[item.value]
            else:
                im_draw.line(item, color)

        self.canvas.update_image()

        self.save_to_cache()
Ejemplo n.º 21
0
 def draw_route_frame(self, route: list, frame: int,
                      draw: ImageDraw.ImageDraw) -> None:
     """Draws single frame of route for single player."""
     first_pos = (self.gran * int((route[frame]['x_pos']) + 20),
                  self.gran * int(route[frame]['y_pos']))
     second_pos = (self.gran * int((route[frame + 1]['x_pos']) + 20),
                   self.gran * int(route[frame + 1]['y_pos']))
     draw.line((first_pos, second_pos), fill=255, width=self.gran*1)
Ejemplo n.º 22
0
def draw_line(draw: ImageDraw.ImageDraw, target, offset=(0, 0), scale=1.0):
    vertexes = []
    for vertex in target['vertexes']:
        x = vertex['x'] * scale + offset[0]
        y = vertex['y'] * scale + offset[1]
        vertexes.append((int(x), int(y)))
    # draw
    draw.line(vertexes)
Ejemplo n.º 23
0
 def plot_square(self, route_start: dict,
                 draw: ImageDraw.ImageDraw) -> None:
     """Plots square to signify player at start of route."""
     x_pos, y_pos = route_start['x_pos'], route_start['y_pos']
     draw.rectangle((self.gran * (int(x_pos) + self.gran * 10 - 1),
                     self.gran * (int(y_pos) + 1),
                     self.gran * (int(x_pos) + self.gran * 10 + 1),
                     self.gran * (int(y_pos) - 1)), fill=255)
Ejemplo n.º 24
0
 def draw(self, features: List, osm_helper: OsmHelper, camera: Camera,
          image_draw: ImageDraw):
     for point, text in sorted(features, key=itemgetter(1)):
         x, y = camera.gps_to_px(point)
         width, height = image_draw.textsize(text, font=self.font)
         image_draw.text((x - width // 2, y - height // 2),
                         text=text,
                         fill=self.fill,
                         font=self.font)
Ejemplo n.º 25
0
def fill_rainbows(image, angle=0):
    draw_api = ImageDraw(image)
    for col in range(IMG_SIZE):
        hue = (col * MAX_HUE / IMG_SIZE + angle) % MAX_HUE
        colour_string = "hsl(%d, 100%%, 50%%)" % (hue)
        # logging.warning("colour_string: %s" % colour_string)
        rgb = ImageColor.getrgb(colour_string)
        # logging.warning("rgb: %s" % (rgb,))
        draw_api.line([(col, 0), (col, IMG_SIZE)], fill=rgb)
Ejemplo n.º 26
0
def draw_linestring(image, linestring, color=255):
    """Draw a linestring in the given color at the given location"""
    pil_image = fromarray(image)
    validated_color = color
    draw = ImageDraw(pil_image)
    if len(image.shape) > 2 and image.shape[2] > 1:
        validated_color = tuple(color)
    draw.line(linestring.coords, fill=validated_color)
    return np.asarray(pil_image)
Ejemplo n.º 27
0
def draw_poly(image, polygon, color=255):
    """Draw a polygon in the given color at the given location"""
    pil_image = fromarray(image)
    validated_color = color
    draw = ImageDraw(pil_image)
    if len(image.shape) > 2 and image.shape[2] > 1:
        validated_color = tuple(color)
    draw.polygon(polygon.boundary.coords, fill=validated_color, outline=validated_color)
    return np.asarray(pil_image)
Ejemplo n.º 28
0
def draw_username(
    txt_draw: ImageDraw.ImageDraw,
    position: Point,
    username="******",
    fill=TITLE_COLOR,
):
    x0 = position.x + MSG_PADDING_H
    y0 = position.y + MSG_PADDING_V
    txt_draw.text((x0, y0), username, font=FONTS['bold'], fill=fill)
Ejemplo n.º 29
0
 def __init__(self, size=(200, 100), mode='RGB', font_path=settings.FONT_PATH):
     self.size = size
     mode = mode
     bg_color = self.RGB()
     self.image = Image.new(mode=mode, size=self.size, color=bg_color)
     self.draw = ImageDraw(self.image, mode)
     self.font = ImageFont.truetype(font_path, 20)
     self.code_length = 4
     self.code = self.CAPTCHA()
Ejemplo n.º 30
0
    def draw(self, verbose=False):
        """ Draw map out to a PIL.Image and return it.
        """
        # image and filename
        img = Image.new('RGB', (self.width, self.height), 0x00)
        
        if verbose:
            print 'Laying out faces...'

        face = icosahedron.vertex2face(icosahedron.latlon2vertex(self.latitude, self.longitude))
        
        face.orient_north(self.latitude, self.longitude)
        face.center_on(self.latitude, self.longitude)
        
        face.scale(self.side)
        face.translate(img.size[0]/2, img.size[1]/2)
        
        faces = face.arrange_neighbors(self.join)
        
        if verbose:
            print 'Drawing faces...'
        
        applied = []
        
        for f, face in icosahedron.faces.items():
            if face in faces:
                applied += apply_face(img, ['%02d' % f], face, UP, verbose=verbose)
                
        lock = threading.Lock()
        
        pasters = [TilePaster(img, srcPath, affineData, lock, verbose) for (srcPath, affineData) in applied]
        
        for paster in pasters:
            paster.start()
    
        while True:
            time.sleep(.25)
            remaining = sum(map(int, [paster.isAlive() for paster in pasters]))
            if remaining == 0:
                break
        
        if verbose:
            print 'Drawing lines...'

        draw = ImageDraw(img)
        
        for face in faces:
            for edge in face.edges():
                x1, y1 = face.project_vertex(edge.vertexA)
                x2, y2 = face.project_vertex(edge.vertexB)
                
                if edge.kind == icosahedron.LAND:
                    draw.line((x1, y1, x2, y2), fill=(0x00, 0xCC, 0x00, 0x80))
                elif edge.kind == icosahedron.WATER:
                    draw.line((x1, y1, x2, y2), fill=(0x00, 0x66, 0xFF, 0x80))

        return img
Ejemplo n.º 31
0
    def __generate_copyright_image(self, size):
        text_layer = Image.new('RGBA', size, (255, 255, 255, 0))

        draw_object = ImageDraw(text_layer)
        opacity = self.count_opacity_num()
        position = self.count_copyright_text_position(size)
        draw_object.text(position, self.copyright_text, fill=(255, 255, 255, opacity))

        return text_layer
Ejemplo n.º 32
0
def draw_quantity(draw: ImageDraw.ImageDraw,
                  mid_point: tuple[int, int],
                  value: str,
                  unit: str,
                  fonts: Fonts,
                  font: str = 'font_sm',
                  font_unit: str = 'font_xs') -> None:
    (x, y) = mid_point
    draw.text((x - 7, y), value, font=fonts[font], fill=0, anchor='rs')
    draw.text((x + 7, y), unit, font=fonts[font_unit], fill=0, anchor='ls')
Ejemplo n.º 33
0
def draw_ant(draw: ImageDraw.ImageDraw, ant: Ant):
    y, x = ant.position
    pos = (np.array([x, y]) + .5) * c.C2P
    rot = rotation(-ant.direction * TAU / 8)
    start = rot @ np.array([0., -c.C2P / 3]) + pos
    end = rot @ np.array([0., c.C2P / 3]) + pos

    color = (255, 0, 0) if ant.food else (0, 0, 0)

    draw.line(start.tolist() + end.tolist(), fill=color, width=2)
Ejemplo n.º 34
0
 def draw_flag_path(self, image, flag_path):
     flag_path = flag_path[0]
     pen = ImageDraw(image)
     x = 0
     while x < len(flag_path) - 1:
         x1, y1 = flag_path[x]
         x2, y2 = flag_path[x + 1]
         pen.line(((x1 * 40) + 20, (y1 * 40) + 20, (x2 * 40) + 20,
                   (y2 * 40) + 20), "yellow", width=4)
         x += 1
Ejemplo n.º 35
0
def score_hour_lines(draw: ImageDraw):
    for hour in range(HOURS):
        y = hour * HOUR_HEIGHT
        draw.line(
            (
                (0, y),
                (NUM_DAYS * DAY_WIDTH, y),
            ),
            fill='grey'
        )
Ejemplo n.º 36
0
    def __init__(self, *args, **kwargs):
        global src, dst
        self.g = TPS_generate(src, dst)

        self.img = Image.new("L", (500, 500), 255)
        draw = ImageDraw(self.img)
        for d in xrange(10, 250, 10):
            draw.ellipse((d, d, 500 - d, 500 - d))

        return super(TestImages, self).__init__(*args, **kwargs)
Ejemplo n.º 37
0
def draw_weekday_names(draw: ImageDraw):
    for day_num, day_name in enumerate(calendar.day_abbr):
        draw.text(
            (
                day_num * DAY_WIDTH,
                (7 * HOUR_HEIGHT) + (HOUR_HEIGHT / 2)
            ),
            day_name.upper(),
            fill='black',
            font=SOURCE_CODE_PRO
        )
Ejemplo n.º 38
0
def create_test_image(w, h, c='RGB'):
    colors = {
        'RGB': {1: '#DDEEFF', 2: '#667788', 3: '#887766'},
        'CMYK': {1: (120, 130, 140, 25), 2: (80, 100, 120, 50), 3: (120, 100, 80, 75)},
    }
    color = colors[c]
    img = Image.new(c, (w, h), color=color[1])
    d = ImageDraw(img)
    d.line((-1, -1) + img.size, fill=color[2], width=2)
    d.line((-1, img.size[1], img.size[0], -1), fill=color[3], width=2)
    return img
Ejemplo n.º 39
0
def procesar():
    sqs = boto3.resource('sqs')
    queue = sqs.get_queue_by_name(QueueName='designMatchQueue')

    print 'Queue'
    print str(queue.url)

    print 'Entra a procesar'
    lista_disenios = Connection().db.disenios.find({'estado' : 'En proceso'})
    print 'lista_disenios'
    print lista_disenios
    for disenio in lista_disenios:
        disenio = Connection.db.disenios.find_one({'_id' : ObjectId(disenio['_id'])})

        if disenio['estado']=='En proceso':
            Connection().db.disenios.update({"_id": ObjectId(disenio['_id'])}, {"$set": {'fechaInicioProceso': timezone.now(),
                                                                                         'fechaModificacion': timezone.now(),
                                                                                         'estado': 'Procesando'}})

            print 'Procesando disenio... ' + str(disenio['disenioOriginal'])
            imageS3 = default_storage.open(disenio['disenioOriginal'])
            imagenOrg = Image.open(imageS3)
            #Redimensionar
            imagenPro = imagenOrg.resize((800,600),Image.ANTIALIAS)
            #Marca de agua
            watermark = Image.new("RGBA", imagenPro.size)
            waterdraw = ImageDraw(watermark, "RGBA")
            font = ImageFont.truetype("fonts/DejaVuSans.ttf", 25)
            waterdraw.text((50,50), disenio['nombres'] + ' ' + disenio['apellidos'] + ' ' + str(disenio['fechaCreacion']), (255,255,255), font=font)
            watermask = watermark.convert("L").point(lambda x: min(x, 100))
            watermark.putalpha(watermask)
            imagenPro.paste(watermark, None, watermark)
            #Nueva extension
            nombreImagen = disenio['disenioOriginal'].split('/')[1].split('.')[0]
            #time.sleep(90)
            nuevaRuta = 'diseniosProcesados/' + nombreImagen + '_procesada.png'
            #Guardar local
            #imagenPro.save(nuevaRuta)
            #Guardar en base
            fh = default_storage.open(nuevaRuta, 'w')
            imagenPro.save(fh)
            fh.close()
            print "Imagen guardada en S3 " + nuevaRuta

            Connection().db.disenios.update({"_id": ObjectId(disenio['_id'])}, {"$set": {'disenioProcesado': nuevaRuta,
                                                                                         'fechaModificacion': timezone.now(),
                                                                                         'estado': 'Disponible'}})

            prompt(disenio)
Ejemplo n.º 40
0
def render(rgb_from_coords=None, filename="mandelbrot.png"):
    """
    Display an image of dimensions MAX_X, MAX_Y, delegating to rgb_from_coords
    to choose the colour for the current pixel.
    :param rgb_from_coords:Function mapping x, y to (r, g, b).
    """
    if rgb_from_coords is None:
        raise ValueError("Pass in a callback function (x, y)->(r,g,b).")
    img = Image.new("RGB", (MAX_X, MAX_Y))
    draw = ImageDraw(img)
    t1 = time.time()
    for coords in it.product(range(MAX_X), range(MAX_Y)):
        rgb = rgb_from_coords(*coords)
        draw.point(coords, rgb)
    t2 = time.time()
    print("Calculation and rendering took", t2-t1, "seconds in total.")
    img.save(filename)
Ejemplo n.º 41
0
def draw_rectangle(colours: dict, class_: TimetableClass, draw: ImageDraw,
                   start: int, stop: int):
    colour = colours[class_.name.split(' - ')[0]]
    fill, outline = colour, 'black'
    draw.rectangle(
        (start, stop),
        fill=fill,
        outline=outline
    )

    colour = tuple(min(x - 20, 256) for x in colour)
    draw.rectangle(
        (
            start,
            (stop[0], start[1] + (HOUR_HEIGHT * (2/3)))
        ),
        fill=colour,
        outline=outline
    )
Ejemplo n.º 42
0
def draw_label(draw: ImageDraw, start: ('x', 'y'), class_: TimetableClass):
    unit_name, class_type = class_.name.split(' - ')
    unit_initials = ''.join(
        word[:1]
        for word in unit_name.split()
        if word[:1].isupper() or word[:1].isdigit()
    )
    start = (start[0] + 2, start[1] - 3)
    draw.text(
        start,
        unit_initials,
        font=SOURCE_CODE_PRO
    )
    if class_type in CLASS_TYPES:
        class_type = CLASS_TYPES[class_type]
    else:
        class_type = class_type[:3].upper()
    draw.text(
        (start[0], start[1] + 20),
        class_type,
        font=SOURCE_CODE_PRO
    )
Ejemplo n.º 43
0
def do_label(fname):
    print "Processing %s" % fname
    # remove directory and file extension
    label = fname.split('/')[-1].replace(".png", "")

    img = Image.open(fname)
    img = img.convert("RGBA")

    # label
    draw = ImageDraw(img, "RGBA")
    font = ImageFont.truetype("arial.ttf", 12)
    draw.setfont(font)
    draw.text((6, 6), label, (0, 0, 0, 255))
    draw.text((5, 5), label, (255, 255, 255, 255))

    # border
    img2 = Image.new("RGBA", img.size, (0, 0, 0, 0))
    draw = ImageDraw(img2, "RGBA")
    draw.rectangle((0, 0, img.size[0] - 1, img.size[1] - 1), None, (255, 255, 192, 48))
    img.paste(img2, img2)

    img.save(fname)
Ejemplo n.º 44
0
    def run(self):  # no need to overwrite parent's init

        turtle = self.turtle
        colors = self.colors

        if self.load_from_cache():
            return

        self.canvas.begin_new()
        im_draw = ImageDraw(self.canvas.pil_image)

        color = self.colors["1"]

        # Calculate size, and scale to fill the frame
        t_width = turtle.rightmost[0] - turtle.leftmost[0]
        t_height = turtle.bottommost[1] - turtle.topmost[1]

        if t_width / t_height > 1:  # fat image scale according to width
            scale_factor = self.canvas.c_width / t_width
        else:
            scale_factor = self.canvas.c_height / t_height

        left_margin = (self.canvas.c_width - scale_factor*t_width) / 2
        top_margin = (self.canvas.c_height - scale_factor*t_height) / 2

        x_shift = left_margin - scale_factor*turtle.leftmost[0]
        y_shift = top_margin - scale_factor*turtle.topmost[1]

        coordinates = []

        for item in turtle.lines:
            if self._stop_drawing.isSet():
                return
            if isinstance(item, PlaceHolder):
                coordinates.append(item)
            else:
                coordinates.append((item[0]*scale_factor+x_shift,
                                    item[1]*scale_factor+y_shift,
                                    item[2]*scale_factor+x_shift,

                                    item[3]*scale_factor+y_shift))

        i = 0
        for item in coordinates:
            if self._stop_drawing.isSet():
                return

            "Update canvas after each 3000 stroke"
            i += 1
            if i > 3000:
                self.canvas.update_image()
                i = 0
            if isinstance(item, PlaceHolder):  # not a list of coordinates
                if item.value in colors:
                    color = colors[item.value]
            else:
                im_draw.line(item, color)

        self.canvas.update_image()

        self.save_to_cache()
Ejemplo n.º 45
0
    max_z_pos = -sys.maxint - 1

    for r_ in blocks:
        if(r_.x_pos_real > max_x_pos):
            max_x_pos = r_.x_pos_real
        elif(r_.x_pos_real < min_x_pos):
            min_x_pos = r_.x_pos_real

        if(r_.z_pos_real > max_z_pos):
            max_z_pos = r_.z_pos_real
        elif(r_.z_pos_real < min_z_pos):
            min_z_pos = r_.z_pos_real

    width = abs(max_z_pos - min_z_pos)+4
    height = abs(max_x_pos - min_x_pos)+4
    print('width {0}, height {1}'.format(width, height))
    
    img = Image.new("RGB", (width, height), "white")
    draw = ImageDraw(img)

    

    for r_ in blocks:
        chunk_x = r_.x_pos_chunk
        chunk_z = r_.z_pos_chunk
        for x_ in range(16):
            for z_ in range(16):
                draw.point((chunk_z + z_ - min_x_pos + 2, chunk_x + x_ - max_x_pos + 2), r_.color)
        draw.point((r_.x_pos_real - min_x_pos + 2, r_.z_pos_real - min_z_pos + 2), "black")
    img.save("img.png", "PNG")
Ejemplo n.º 46
0
def annotate(image, text):
    draw = ImageDraw(image)
    font = truetype("Helvetica.otf", 16)
    draw.text((0, 0), text, (255, 255, 255), font=font)
Ejemplo n.º 47
0
import dymaxion
import PIL.Image as Image
from PIL.ImageDraw import ImageDraw

min_x, min_y, max_x, max_y = 9999, 9999, -9999, -9999

points = []
img = Image.new("L", (800, 400), 0x00)
draw = ImageDraw(img)

for lat in range(-90, 90, 3):
    for lon in range(-180, 180, 3):
        x, y = dymaxion.project(lon, lat)
        x, y = x, -y  # upside-down!

        min_x, min_y = min(x, min_x), min(y, min_y)
        max_x, max_y = max(x, max_x), max(y, max_y)

        # print (lat, lon), '->', (x, y)
        points.append((x, y, lat, lon))

print(min_x, min_y), (max_x, max_y)

top, left, bottom, right = 10, 10, img.size[1] - 10, img.size[0] - 10

mx = (right - left) / (max_x - min_x)
my = (bottom - top) / (max_y - min_y)

mx, my = min(mx, my), min(mx, my)

bx = left - mx * min_x
Ejemplo n.º 48
0
def getalbums(**kwargs):
    items = kwargs.get('items', [])
    app_id = kwargs.get('app_id', '')
    app_secret = kwargs.get('app_secret', '')
    try:
        oauth = urllib2.urlopen(
            'https://graph.facebook.com/oauth/access_token?'
            'client_id=%s&client_secret=%s&grant_type=client_credentials' %
            (app_id, app_secret))
        txt = oauth.read()
        access_token = re.search('access_token=(.*)', txt).groups()[0]
    except Exception as e:
        print e
        sys.exit(0)

    facebook = hammock.Hammock("https://graph.facebook.com")

    # 851 315
    # 840 300
    # 120 100

    images = []
    for item in items:
        try:
            metadata = facebook.__getattr__(item).GET(
                "", params={"access_token": access_token}
            ).json()
            feed = facebook.__getattr__(metadata['id']).GET(
                "albums", params={"access_token": access_token}
            ).json()
            filtered = [
                i for i in feed['data']
                if not i['name']
                in (
                    u'Profile Pictures',
                    u'Cover Photos',
                    u'Timeline Photos'
                )]
            shuffle(filtered)
            items = []
            for album in filtered:
                photos = facebook.__getattr__(album['id']).GET(
                    "photos", params={"access_token": access_token}
                ).json()
                chosen = sample(
                    photos['data'],
                    choice(range(1, int(math.ceil(len(filtered) ** 0.5))))
                )
                items.extend(chosen)
            shuffle(items)
            for c in items:
                print "processing", c['source']
                try:
                    data = StringIO(urllib2.urlopen(c['source']).read())
                    img = Image.open(data)
                    if choice((0, 1)):
                        img = img.resize((
                            img.size[0] / 2,
                            img.size[1] / 2),
                            Image.ANTIALIAS)
                    if img.size[0] < img.size[1]:  # portrait
                        img = img.crop((
                            max(img.size[0] / 2 - 120 * choice((1, 2)), 0),
                            max(img.size[1] / 2 - 105 * choice((2, 3)), 0),
                            min(img.size[0] / 2 + 120, img.size[0]),
                            min(img.size[1] / 2 + 105, img.size[1]),
                        ))
                    else:  # landscape
                        img = img.crop((
                            max(img.size[0] / 2 - 120 * choice((2, 3)), 0),
                            max(img.size[1] / 2 - 105 * choice((1, 2)), 0),
                            min(img.size[0] / 2 + 120, img.size[0]),
                            min(img.size[1] / 2 + 105, img.size[1]),
                        ))
                    draw = ImageDraw(img)
                    draw.rectangle(
                        [1, 1,
                         img.size[0] - 2, img.size[1] - 2],
                        outline="white"
                    )
                    draw.rectangle(
                        [0, 0,
                         img.size[0] - 1, img.size[1] - 1],
                        outline="white"
                    )
                    images.append(
                        Rectangle(
                            0, 0,
                            img.size[0],
                            img.size[1],
                            img
                        ))
                except Exception as e:
                    print e
                    #pass
        except Exception as e:
            print e
            sys.exit(0)

        container = Rectangle(
            0, 0,
            1440, 500,
            Image.open("template.png"))

        guillotine_baf_las(container, images)
        depth_composite(container, container, 0, 0)
        offset = choice(tuple(i for i in range(0, 100, 10)))
        crop = container.image.crop((
            offset, offset,
            851 + offset, 315 + offset
        ))
        draw = ImageDraw(crop)
        draw.rectangle(
            (0, 0,
             crop.size[0] - 1,
             crop.size[1] - 1),
            outline="white"
        )
        draw.rectangle(
            (1, 1,
             crop.size[0] - 2,
             crop.size[1] - 2),
            outline="white"
        )
        crop.save(open("result.png", "w"))
Ejemplo n.º 49
0
import dymaxion
import os, tempfile, subprocess
import PIL.Image as Image
from PIL.ImageDraw import ImageDraw as IDraw
from PIL.ImageStat import Stat as IStat

min_x, min_y, max_x, max_y = 9999, 9999, -9999, -9999

points = []
img = Image.new('RGB', (1440, 900), 0x00)
draw = IDraw(img)

sources = (('world.topo.bathy.200407.3x21600x21600.A1.v', 'world.topo.bathy.200407.3x21600x21600.B1.v', 'world.topo.bathy.200407.3x21600x21600.C1.v', 'world.topo.bathy.200407.3x21600x21600.D1.v'),
           ('world.topo.bathy.200407.3x21600x21600.A2.v', 'world.topo.bathy.200407.3x21600x21600.B2.v', 'world.topo.bathy.200407.3x21600x21600.C2.v', 'world.topo.bathy.200407.3x21600x21600.D2.v'))

def source(lat, lon):
    if lat > 0:
        row = 0
    else:
        row = 1

    if lon < -90:
        col = 0
    elif lon < 0:
        col = 1
    elif lon < 90:
        col = 2
    else:
        col = 3

    image = sources[row][col]
    def renderTile(self, width, height, srs, coord):
        """
        """
        img = Image.new('RGB', (width, height), colors[0])
        draw = ImageDraw(img)
        
        interactivity_array = []
        
        base_zoom = coord.zoom
        base_row = coord.row
        base_column = coord.column
        
        #We're showing detail for three zooms in from here, as fat pixels (32 pix)
        #256 pixels / tile = 8 pixels / tile = 32 pixels (which is 2^5)

        tile_pixel_width = 256
        #print 'coord:', coord
        #print 'base_zoom:', base_zoom
        
        # 256 pixel tile == 2^8 pixel tile, so this is a constant
        tile_power_of_two = 8
        
        # we want 8x8 fatbits == 2^3 pixel fatbits
        #TODO: use self.cell_size to find log of 2 to x?
        pixel_power_of_two = int(log( self.cell_size, 2 ))
        
        fat_pixel_width = 2**pixel_power_of_two
        self.fat_pixel_count = 2**(tile_power_of_two - pixel_power_of_two)

        # adjust the coord to be the pixel zoom
        coord = coord.zoomBy(tile_power_of_two - pixel_power_of_two)
        
        #print "fat_pixel_count: ", fat_pixel_count
        #print "coord: ", coord       
        #print 'over_sample_zoom_tile_width: ', over_sample_zoom_tile_width
        
        #find the fat_pixel with the maximum photo count
        max_count = 0
        top_count = 0
        top_margin = 0
        
        #We should be seeing 64 cells (8x8) output image
        for row in range( self.fat_pixel_count ):
            for col in range( self.fat_pixel_count ):
                
                ul = coord.right(col).down(row)
                lr = ul.right().down()
                
                #Calculate key for the size dict
                subquad = Coordinate(ul.row, ul.column, ul.zoom)
                
                #print 'subquad:', subquad
                
                # these values should always be within (0, 256)
                x1 = col * fat_pixel_width
                x2 = (col + 1) * fat_pixel_width
                y1 = row * fat_pixel_width
                y2 = (row + 1) * fat_pixel_width
                
                #Draw fat pixel based on the returned color based on count (size) in that subquad in the dictionary
                #Implied that no-data is color[0], above where the img is instantiated
                
                enumeration = count_votes( self, subquad )
                                
                if max_count < enumeration["photo_count_total"]:
                    max_count = enumeration["photo_count_total"]
                
                if top_count < enumeration["photo_count0"]:
                    top_count = enumeration["photo_count0"]
                    
                if self.output_format == "utf_grid":
                    nw = osm.coordinateLocation(subquad)
                    se = osm.coordinateLocation(subquad.right().down())

                    lat = (nw.lat - se.lat) / 2 + se.lat
                    lon = (se.lon - nw.lon) / 2 + nw.lon
                                        
                    interactivity_array.append( {   "photo_count_total":enumeration["photo_count_total"], 
                                                    "woe_id":enumeration["woe_id0"], 
                                                    #"woe_id_lau":enumeration["woe_id0_lau"], 
                                                    #"woe_id_adm2":enumeration["woe_id0_adm2"], 
                                                    #"woe_id_adm1":enumeration["woe_id0_adm1"], 
                                                    "woe_id_adm0":enumeration["woe_id0_adm0"],
                                                    "name":enumeration["name0"], 
                                                    "photo_count":enumeration["photo_count0"],
                                                    "margin":enumeration["margin0"],
                                                    "latitude":lat,
                                                    "longitude":lon, 
                                                    "x1": str(nw.lon),
                                                    "y1": str(se.lat),
                                                    "x2": str(se.lon),
                                                    "y2": str(nw.lat),
                                                    "row":str(base_row + row),
                                                    "col":str(base_column + col),
                                                    "zoom": coord.zoom } )
                elif self.method == "size_log":
                    draw.rectangle((x1, y1, x2, y2), size_color_log(int( enumeration[self.input_field]) ))
                elif self.method == "size":
                    draw.rectangle((x1, y1, x2, y2), size_color(int( enumeration[self.input_field]) ))
                elif self.method == "unique_id":
                    draw.rectangle((x1, y1, x2, y2), size_color_unique_id(int( enumeration[self.input_field]) )) 

        if self.output_format == "utf_grid":
            #print "interactivity_array: ", interactivity_array
            #grid_utf = create_utf_grid( self, interactivity_array )
            grid_utf = { 'grid':['','.'] }
                
            if max_count == 0:
                raise NothingToSeeHere()
            
            is_saveable = False
            
            # Are we at the last requested zoom?
            if coord.zoom == self.max_zoom:
                is_saveable = True
            # Are we at the minimum viable zoom but with little to no data?
            if (coord.zoom >= self.min_zoom) and (max_count <= self.min_size):
                is_saveable = True
            # Are we viable zoom, viable count, and no ambiguity as to the 100% within margin the winner?
            if (coord.zoom >= (self.min_zoom + 2)) and (max_count > self.max_size) and ((top_count >= (max_count * self.margin_percent)) or ((max_count - top_count) < self.min_size)):
                is_saveable = True
            # Don't want to dig for needles
            #if coord.zoom == 17 and base_row == 50816 and base_column == 21045:
            #    print '(coord.zoom >= (self.min_zoom + 1)) and ((max_count - top_count) < self.min_size):'
            #    print coord.zoom,(self.min_zoom + 1),max_count, top_count, self.min_size
            if (coord.zoom >= (self.min_zoom + 1)) and ((max_count - top_count) < self.min_size):
            #(max_count > self.min_size) and 
                is_saveable = True

            # and (interactivity_array["margin"] >= self.margin_percent)

            if is_saveable:
                #print "should save to DB"
                #print "interactivity_array: ", interactivity_array                
                saveTileToDatabase( self, interactivity_array )
                raise NothingMoreToSeeHere( SaveableResponse(json.dumps(grid_utf)) )
            else:            
                return SaveableResponse(json.dumps(grid_utf))
                
        elif self.output_format == "geojson":
            grid_utf = create_utf_grid( self, interactivity_array )
            return SaveableResponse(json.dumps(grid_utf))
        else:
            return img
Ejemplo n.º 51
0
    def renderTile(self, width, height, srs, coord):
        # return an object with a PIL-like save() method for a tile

        _width, _height = width / self.scale, height / self.scale

        img = Image.new("RGB", (_width, _height), (0, 0, 0))
        draw = ImageDraw(img)

        #
        # Prepare query geometry.
        #

        ul = self.layer.projection.coordinateProj(coord)
        lr = self.layer.projection.coordinateProj(coord.down().right())

        x_offset, y_offset = -ul.x, -ul.y
        x_scale, y_scale = _width / (lr.x - ul.x), _height / (lr.y - ul.y)
        transform = x_offset, y_offset, x_scale, y_scale

        buf = (lr.x - ul.x) / 2
        bbox = (
            "ST_SetSRID(ST_Buffer(ST_MakeBox2D(ST_MakePoint(%.3f, %.3f), ST_MakePoint(%.3f, %.3f)), %.3f, 2), 900913)"
            % (ul.x, ul.y, lr.x, lr.y, buf)
        )
        colors = product(range(0, 0xFF, 4), range(0, 0xFF, 4), range(0x66, 0xFF, 4))

        #
        # Draw the grid itself and note object color keys as we go.
        #

        objects = {}
        db = connect(database="geodata", user="******").cursor()

        for (id, type, name, shape) in get_landusages_imposm(db, bbox, *transform):
            rgb = colors.next()
            objects[rgb] = "land", type, name, id

            for geom in getattr(shape, "geoms", [shape]):
                for ring in [geom.exterior] + list(geom.interiors):
                    draw.polygon(list(ring.coords), fill=rgb)

        if coord.zoom >= 17:
            for (id, type, shape) in get_buildings_imposm(db, bbox, *transform):
                rgb = colors.next()
                objects[rgb] = "building", name, id

                for geom in getattr(shape, "geoms", [shape]):
                    for ring in [geom.exterior] + list(geom.interiors):
                        draw.polygon(list(ring.coords), fill=rgb)

        if coord.zoom >= 15:
            road_lines = get_roads_imposm(db, bbox, *transform)
        else:
            road_lines = get_mainroads_imposm(db, bbox, *transform) + get_motorways_imposm(db, bbox, *transform)

        for (id, type, name, way) in road_lines:
            rgb = colors.next()
            objects[rgb] = "road", type, name, id

            for geom in getattr(way, "geoms", [way]):
                stroke = {18: 4, 17: 3}.get(coord.zoom, 2)
                draw.line(list(geom.coords), fill=rgb, width=stroke)

        db.close()

        #
        # Collect actual rgb values from image and sort them by frequency
        # so we can build up a grid with the most number of one-and-two-digit
        # numbers that are also keys into the details array.
        #

        data = [(r, g, b) for (r, g, b) in img.getdata()]
        rgb_counts = {}

        for rgb in data:
            rgb_counts[rgb] = rgb_counts.get(rgb, 0) + 1

        rgb_counts = sorted(rgb_counts.items(), key=itemgetter(1), reverse=True)
        rgb_indexes = [key for (key, count) in rgb_counts]

        #
        # Build a details array and a two-dimensional column-major grid.
        #

        details = [objects.get(rgb, None) for rgb in rgb_indexes]

        grid = []

        for row in range(_height):
            row, data = data[:_width], data[_width:]
            row = [rgb_indexes.index(rgb) for rgb in row]
            grid.append(row)

        return GridResponse(img.resize((width, height), Image.NEAREST), [details, grid])