def create_noise_dots(image, color, width=3, number=30): draw = Draw(image) w, h = image.size for _ in range(number): xx = random.randint(1, width) yy = random.randint(1, width) x = random.randint(0, w - xx) y = random.randint(0, h - yy) draw.ellipse(((x, y), (x + xx, y + yy)), fill=color if rand_bool() else random_color()) return image
def create_frame(self, spoke: int = 0, spoke_frame: int = 0) -> PILImage: image = Image.new('RGBA', self.size, self.bg) draw = Draw(image, 'RGBA') # type: ImageDraw opacity_step_pct = (1 - self.opacity_min_pct) / self.spokes a_offset = int(255 * (spoke_frame * self.frame_fade_pct)) # log.debug(f'Creating frame for focused {spoke=} {spoke_frame=} {opacity_step_pct=} {a_offset=}') for i, r, box in self._iter_boxes(spoke): a = int(255 * (1 - (i * opacity_step_pct))) - a_offset # log.debug(f' Drawing spoke={i} with {box=} alpha={a} {r=} area={pi * r ** 2:,.2f} px') draw.ellipse(box, fill=(*self.rgb, a)) return image
def make_mask(self, f): im = Image.new("L", (self.hw, self.hw)) draw_mask = Draw(im) box_list = [] for i, o in enumerate(f.transpose()): r = int(o[-1] * self.hw / 2) p = [int((x + 1) * self.hw / 2.0) for x in o[1::-1]] box = (p[0] - r, p[1] - r, p[0] + r, p[1] + r) box_list.append(box) if not all(0 <= b <= self.hw for b in box): continue draw_mask.ellipse(box, fill=i + 1, outline=i + 1) return np.array(im), box_list
def draw_point(self, latlong): if self._image: tmp = self._image.copy() draw = Draw(tmp) pix = MapData.latlng_to_pixel(latlong) # tilepix = (pix[0] - (self._pxcenter[0]-TILESIZE/2), pix[1] - (self._pxcenter[1]-TILESIZE/2)) tilepix = (pix[0] - self._pxtopleft[0], pix[1] - self._pxtopleft[1]) draw.ellipse([(tilepix[0] - 5, tilepix[1] - 5), (tilepix[0] + 5, tilepix[1] + 5)], fill=ImageColor.getrgb('red')) return tmp
def make_mask(f, hw): im = Image.new("L", (hw, hw)) draw_mask = Draw(im) for i, o in enumerate(f.transpose()): if np.linalg.norm(o[:3]) == 0: continue r = int(o[-1] * hw / 2) p = [int((x + 1) * hw / 2.0) for x in o] box = (p[0] - r, p[1] - r, p[0] + r, p[1] + r) if i < 5: draw_mask.ellipse(box, fill=i + 1, outline=i + 1) else: draw_mask.rectangle(box, fill=i + 1, outline=i + 1) return np.array(im)
def processPoint(arr, coords): blank = Image.new('RGB', (len(arr[0]), len(arr))) drawer = Draw(blank, 'RGBA') elrad = 4 for i in range(len(coords[0])): pointArr = [] pointArr.append(coords[0][i] - elrad) pointArr.append(coords[1][i] - elrad) pointArr.append(coords[0][i] + elrad) pointArr.append(coords[1][i] + elrad) drawer.ellipse(pointArr, (255, 255, 255, 25)) arr = np.asarray(blank) arr = arr[:, :, 0] return arr
def draw_circle(x: float, y: float, radius: int, color: int, draw_object: ImageDraw.Draw) -> None: """ Args: x: x coordinate of center y: y coordinate of center color: a number from 1 to 10 to represent the color of the circle. radius: the radius Returns: """ draw_object.ellipse((x - radius, y - radius, x + radius, y + radius), fill=COLOR_DICT[color])
def create_noise_circles(image, number): w, h = image.size while number: distance = random.randint(1, 10) x1 = random.randint(0, w) x2 = x1 + distance y1 = random.randint(0, h) y2 = y1 + distance points = [x1, y1, x2, y2] draw = Draw(image) color = random_color(10, 200, random.randint(220, 225)) draw.ellipse(points, fill=color, outline=color) number -= 1 return image
def fast_paint(image: Image, brushes: List[int] = [2, 4, 8, 16, 32], blur_factor: int = 2, threshold: int = 100) -> Image: width, height = image.size canvas = Image.new('RGB', image.size, color=(255, 255, 255)) draw_canvas = Draw(canvas) canvas_data = np.array(canvas) # Run through each brush size from large to small for brush_size in sorted(brushes, reverse=True): size_2 = brush_size // 2 blurred_image = image.filter(GaussianBlur(blur_factor * brush_size)) blurred_image_data = np.array(blurred_image) to_brush_positions = [] # Run through each image with squares of brush_size width for x in range(size_2, width - size_2, brush_size): for y in range(size_2, height - size_2, brush_size): canvas_data[x - size_2:x + size_2, y - size_2:y + size_2] # Calculate the error between points in area points_in_area = [(i, j) for i in range(x - size_2, x + size_2) for j in range(y - size_2, y + size_2)] distances = [(distance_rgb(image(point), blurred_image.getpixel(point)), point) for point in points_in_area] error = sum(score for score, _ in distances) print(error) if error > threshold: _, max_point = max(distances) to_brush_positions.append({ 'point': max_point, 'color': image.getpixel(max_point) }) # Paint circles of shuffled brush positions and colors shuffle(to_brush_positions) for to_paint in to_brush_positions: x, y = to_paint['point'] left_up = (x - size_2, y - size_2) right_down = (x + size_2, y + size_2) draw_canvas.ellipse([left_up, right_down], fill=to_paint['color']) return canvas
def draw(self, image_to_draw_on): drawing_context = Draw(image_to_draw_on) if self.bounding_box: coords = Shape.scale_float_coords_to_image_size(self.bounding_box, image_to_draw_on) else: coords = Shape.scale_float_coords_to_image_size(self.vertices, image_to_draw_on) if self.kind == "chord": drawing_context.chord(coords, self.start_angle, self.end_angle, fill=self.color) elif self.kind == "ellipse": drawing_context.ellipse(coords, fill=self.color) elif self.kind == "pieslice": drawing_context.pieslice(coords, self.start_angle, self.end_angle, fill=self.color) elif self.kind == "polygon": drawing_context.polygon(coords, fill=self.color) else: raise Exception("unsupported kind")
def drawPointObjects(im, data, **kwargs): if ('drawIm' in kwargs): drawIm = kwargs['drawIm'] else: drawIm = Draw(im) if ('fillColor' in kwargs): fillColor = kwargs['fillColor'] else: fillColor = 'red' if ('elrad' in kwargs): fillColor = kwargs['elrad'] else: elrad = 3 coords = data for i in range(len(coords[0])): pointArr = [] pointArr.append(coords[0][i] - elrad) pointArr.append(coords[1][i] - elrad) pointArr.append(coords[0][i] + elrad) pointArr.append(coords[1][i] + elrad) drawIm.ellipse(pointArr, fill=fillColor) return im
def visualize_sift_descriptors(img, *, n=100): """ Visualize the image with the sift descriptors. """ from PIL import Image from PIL.ImageDraw import Draw image = Image.fromarray(img) draw = Draw(image) descriptors_magnitude = { coords: np.sum(descriptor) for coords, descriptor in create_sift_descriptors(img).items() } sorted_descriptors = sorted(descriptors_magnitude.items(), key=operator.itemgetter(1)) for ((x, y), _) in sorted_descriptors[-n:]: draw.ellipse([(x - 2, y - 2), (x + 2, y + 2)], fill='red') return image
def draw_balloon(img_draw: ImageDraw.Draw, points: Box, fill=None, width=0): r_x0 = points.top_left.x r_y0 = points.top_left.y + BOX_RADIUS r_x1 = points.bottom_right.x r_y1 = points.bottom_right.y - BOX_RADIUS img_draw.rectangle([r_x0, r_y0, r_x1, r_y1], fill=fill, width=width) r_x0 = points.top_left.x + BOX_RADIUS r_y0 = points.top_left.y r_x1 = points.bottom_right.x - BOX_RADIUS r_y1 = points.bottom_right.y img_draw.rectangle([r_x0, r_y0, r_x1, r_y1], fill=fill, width=width) diam = 2 * BOX_RADIUS c_x0 = points.top_left.x c_y0 = points.top_left.y c_x1 = c_x0 + diam c_y1 = c_y0 + diam img_draw.ellipse([c_x0, c_y0, c_x1, c_y1], fill=fill, width=width) c_x0 = points.bottom_right.x - diam c_x1 = c_x0 + diam img_draw.ellipse([c_x0, c_y0, c_x1, c_y1], fill=fill, width=width) c_y0 = points.bottom_right.y - diam c_y1 = c_y0 + diam img_draw.ellipse([c_x0, c_y0, c_x1, c_y1], fill=fill, width=width) arrow_x = 10 arrow_y = 10 if BOX_RADIUS < 10 else BOX_RADIUS arrow = [ (points.top_left.x - arrow_x, points.bottom_right.y), (points.top_left.x, points.bottom_right.y - arrow_y), (points.top_left.x + diam, points.bottom_right.y - arrow_y), (points.top_left.x + diam, points.bottom_right.y), ] img_draw.polygon(arrow, fill=fill)
def generate_captcha(directory="tmp", letters=ascii_uppercase+digits, length=3, font_size=30, lines=5, mode="ellipse", font="FreeSerif.ttf"): """ Returns a tuple : (path, code) """ dimensions = ((length + 1) * font_size, int(font_size * 2)) path = "%s%s" % (os.path.join(directory, "".join(choice(ascii_letters) for i in xrange(7))), ".png") code = "".join(choice(letters) for i in range(length)) background_color = tuple( [randrange(190, 230) for i in xrange(3)] ) master = new_image("RGB", dimensions, background_color) # On colle les lettres for i, l in enumerate(code): img, mask = generate_letter(l, font_size, font) for _ in xrange(3): # On colle plusieurs fois pour plus de netteté master.paste(img, (font_size / 2 + font_size * i , font_size / 3), mask) # Et on dessine quelques jolies lignes draw = Draw(master) for i in xrange(lines): color = tuple( [randrange(128, 190) for i in xrange(3)] ) #pen = Pen("black", opacity=64) #pen.color = color w = dimensions[0] h = dimensions[1] geom = (randrange(0, int(w * 3. / 4)), randrange(0, h), randrange(int(w * 1. / 4), w), randrange(0, h)) if mode == "mixed": mode_ = choice( ("ellipse", "line") ) else: mode_ = mode if mode_ == "ellipse": draw.ellipse(geom, None, color) else: draw.line(geom, color, 1) with open(path, "w") as f: master.save(f) return (path, code)
def paint(self, draw: ImageDraw.Draw, regions: RegionMap) -> None: angle = radians(180.0 - 30) # 30 degrees c, s = cos(angle), sin(angle) d = self.p1[0] - self.p0[0], self.p1[1] - self.p0[1] left = d[0] * c - d[1] * s, d[0] * s + d[1] * c right = d[0] * c + d[1] * s, -d[0] * s + d[1] * c lf = self.size / (d[0]**2 + d[1]**2)**0.5 # Draw arrow shaft draw.line([self.p0, self.p1], fill=self.color, width=self.width) # Draw dot draw.ellipse( (self.p1[0] - 5, self.p1[1] - 5, self.p1[0] + 5, self.p1[1] + 5), fill=self.color) # Draw left arrow wing draw.line( [(self.p1[0] + lf * left[0], self.p1[1] + lf * left[1]), self.p1], fill=self.color, width=self.width) # Draw right arrow wing draw.line([(self.p1[0] + lf * right[0], self.p1[1] + lf * right[1]), self.p1], fill=self.color, width=self.width)
detected_faces = detect_faces(img) #crop the detected face img = Image.fromarray(img).crop(detected_faces[0]) #color quantization quantized_image = color_quant(img) face = Image.fromarray(quantized_image) median = ImageStat.Stat(face).median #to convert BGR to RGB org_img = image[:, :, ::-1].copy() #draw an ellipse with fill color as the detected skin color out = Image.fromarray(org_img) d = Draw(out) d.ellipse(((0, 0), (0.2 * image.shape[0], 0.2 * image.shape[1])), fill=tuple(median)) #output the results #plt.imshow(res2) #plt.show() #plt.imshow(out) #plt.axis('off') #plt.show() success += 1 out.save('../results/out3/out_file_' + str(success) + '.jpg') print('Success ' + str(success)) except: fail += 1 print('Fail ' + str(fail))
make_sure_path_exists(overlay_path) # Superimpose smoothed midlines on the (cropped) original image sequence for i in range(Nf): shift = -offsets[i] # im = Image.open(original_images.format(i+1)) # im = im.crop((0, 680, 2260, 680+810)) im = open_png(sillhouette_path.format(i+1)) im = Image.fromarray(im.astype(np.uint8)).convert('RGB') d = Draw(im) y = smid[:,i].astype(int)+shift[1] x = (np.arange(smid.shape[0])*end[i]/float(smid.shape[0]-1)).astype(int)+shift[0] d.line(zip(x,y), fill=(255,0,0), width=3 ) tp = tip_locations[i] d.ellipse((tp[0]-1, tp[1]-1, tp[0]+1, tp[1]+1), fill=(0,0,255)) im.save(overlay_path+'orig_{}.png'.format(i)) # Calculate scaling between transformed and y-coordinate # in pixels - dy/di sc = end / float(smid.shape[0]-1) # Evaluate derivatives of the smoothed midline - dx/dy and d^2 x / dy^2 # Use scaling factor to give in terms of pixel coordinates d = u(range(new_mid.shape[0]), range(new_mid.shape[1]), dx=1)/sc dd = u(range(new_mid.shape[0]), range(new_mid.shape[1]), dx=2)/sc/sc # Calculate distance # ds = ds / di. Use d^2 d/dy^2 = 1 + (dx/dy)^2 and dy/di = sc
def image_crop( image: Union[bytes, Image], crop: Optional[Crop] = None, width_preview: Optional[int] = None, image_alt: Optional[str] = None, min_width: Optional[int] = None, min_height: Optional[int] = None, max_width: Optional[int] = None, max_height: Optional[int] = None, # FIXME: Changing these properties, the component is rerendered unfortunately. # ---- # keep_selection: Optional[bool] = None, # disabled: Optional[bool] = None, # locked: Optional[bool] = None, rule_of_thirds: Optional[bool] = None, circular_crop: Optional[bool] = None, # ---- key: Optional[str] = None, ) -> Optional[Image]: import dataclasses from io import BytesIO from os import path import streamlit as st from PIL.Image import composite as composite_image from PIL.Image import new as new_image from PIL.Image import open as open_image from PIL.ImageDraw import Draw from streamlit.components import v1 as components from streamlit.elements.image import image_to_url global _impl if _impl is None: if _DEBUG: option_address = st.get_option("browser.serverAddress") option_port = st.get_option("browser.serverPort") _impl = ( components.declare_component( "image_crop", url="http://localhost:3001", ), lambda s: f"http://{option_address}:{option_port}" + s, ) else: _impl = ( components.declare_component( "image_crop", path=path.join(path.dirname(path.abspath(__file__)), "frontend/build"), ), lambda s: s, ) if isinstance(image, Image): image_ = image else: image_ = open_image(BytesIO(image)) width, _ = image_.size src = image_to_url( image_, width=min(width, width_preview) if width_preview else width, clamp=False, channels="RGB", output_format="auto", image_id="foo", ) crop_ = None if crop is None else dataclasses.asdict(crop) default = { "width": 0.0, "height": 0.0, "x": 0.0, "y": 0.0, } component, build_url = _impl result = component( src=build_url(src), image_alt=image_alt, minWidth=min_width, minHeight=min_height, maxWidth=max_width, maxHeight=max_height, # FIXME: Changing these properties, the component is rerendered unfortunately. # ---- keepSelection=None, disabled=None, locked=None, ruleOfThirds=rule_of_thirds, circularCrop=circular_crop, # ---- crop=crop_, key=key, default=default, ) w, h = image_.size w_crop = int(w * float(result["width"]) / 100) h_crop = int(h * float(result["height"]) / 100) x0 = int(w * float(result["x"]) / 100) y0 = int(h * float(result["y"]) / 100) x1 = x0 + w_crop y1 = y0 + h_crop if w_crop <= 0 or h_crop <= 0: return None else: image_crop = image_.crop((x0, y0, x1, y1)) if circular_crop: background = new_image("RGBA", (w_crop, h_crop), (0, 0, 0, 0)) mask = new_image("L", (w_crop, h_crop), 0) draw = Draw(mask) draw.ellipse((0, 0, w_crop, h_crop), fill="white") image_crop = composite_image(image_crop, background, mask) return image_crop