async def remix_meeme(upper_text, lower_text, picture_name, endname): main_image = remiximage(filename=picture_name) main_image.resize( 1024, int(((main_image.height * 1.0) / (main_image.width * 1.0)) * 1024.0)) upper_text = "\n".join(wrap(upper_text, get_warp_length(main_image.width))).upper() lower_text = "\n".join(wrap(lower_text, get_warp_length(main_image.width))).upper() lower_margin = MARGINS[lower_text.count("\n")] text_draw = Drawing() text_draw.font = join(getcwd(), "userbot/utils/styles/MutantAcademyStyle.ttf") text_draw.font_size = 100 text_draw.text_alignment = "center" text_draw.stroke_color = Color("black") text_draw.stroke_width = 3 text_draw.fill_color = Color("white") if upper_text: text_draw.text((main_image.width) // 2, 80, upper_text) if lower_text: text_draw.text((main_image.width) // 2, main_image.height - lower_margin, lower_text) text_draw(main_image) main_image.save(filename=endname)
def generate_meme(upper_text, lower_text, picture_name_orig, picture_name_target): main_image = Image(filename=join(TEMPLATES_FOLDER, picture_name_orig)) main_image.resize( 1024, int(((main_image.height * 1.0) / (main_image.width * 1.0)) * 1024.0)) upper_text = "\n".join(wrap(upper_text, get_warp_length(main_image.width))).upper() lower_text = "\n".join(wrap(lower_text, get_warp_length(main_image.width))).upper() lower_margin = MARGINS[lower_text.count("\n")] text_draw = Drawing() text_draw.font = join(getcwd(), "impact.ttf") text_draw.font_size = 70 text_draw.text_alignment = "center" text_draw.stroke_color = Color("black") text_draw.stroke_width = 3 text_draw.fill_color = Color("white") if upper_text: text_draw.text(int(main_image.width / 2), 80, upper_text) if lower_text: text_draw.text(int(main_image.width / 2), main_image.height - lower_margin, lower_text) text_draw(main_image) main_image.save(filename=join(getcwd(), MEME_FOLDER, picture_name_target))
def draw_strip(self, filename): led_width = 20 led_height = 20 color_width = int(led_width * 0.8) color_height = int(led_height * 0.8) img = Image(width=(led_width * self.led_count), height=led_height, background=Color('#000000')) draw = Drawing() draw.stroke_width = 3 for n in range(0, self.led_count): draw.fill_color = Color('#%02x%02x%02x' % (self.led_list[n][0], self.led_list[n][1], self.led_list[n][2])) draw.rectangle(left=int(led_width * n + 0.5 * (led_width - color_width)), top=int(0.5 * (led_height - color_height)), width=color_width, height=color_height) draw(img) img.save(filename=filename)
def generate_track(self) : draw = Drawing() draw.stroke_width = 2 draw.stroke_color = Color('red') draw.fill_color = Color('transparent') points = [] # Loop over the coordinates to create a list of tuples for coords in self.geojson['coordinates'] : pt = Point(coords[0], coords[1]) pt.project(self.rendering_zoom) x, y = pt.get_xy() x = round(x - (self.minxtile * 256)) y = round(y - (self.minytile * 256)) points.append((x, y)) # draw the polyline draw.polyline(points) # apply to the image draw(self.img) # self.rendering_bounds.nw.project(self.rendering_zoom) x = int(self.rendering_bounds.nw.tile_x - self.minxtile) y = int(self.rendering_bounds.nw.tile_y - self.minytile) self.crop(x, y) self.img.format = 'jpeg' # self.img.save(filename='image.jpg') return self.img.make_blob('jpeg')
def generate_meme(upper_text, lower_text, picture_name): MEME_FOLDER = "memes" MARGINS = [25, 65, 100, 135, 170] if not exists(join(getcwd(), MEME_FOLDER)): mkdir(join(getcwd(), MEME_FOLDER)) main_image = Image(filename=picture_name) main_image.resize( 500, int( ((main_image.height * 1.0) / (main_image.width * 1.0)) * 500.0)) upper_text = "\n".join(wrap(upper_text, get_warp_length(main_image.width))).upper() lower_text = "\n".join(wrap(lower_text, get_warp_length(main_image.width))).upper() lower_margin = MARGINS[lower_text.count("\n")] text_draw = Drawing() text_draw.font = join(getcwd(), "impact.ttf") text_draw.font_size = 40 text_draw.text_alignment = "center" text_draw.stroke_color = Color("black") text_draw.stroke_width = 3 text_draw.fill_color = Color("white") if upper_text: text_draw.text(main_image.width / 2, 40, upper_text) if lower_text: text_draw.text(main_image.width / 2, main_image.height - lower_margin, lower_text) text_draw(main_image) outname = "[MEME] " + picture_name main_image.save(filename=join(getcwd(), MEME_FOLDER, outname)) # if sys.platform.startswith('darwin'): # system('open "%s"' % (join(getcwd(), MEME_FOLDER, outname))) # elif name == 'nt': # system('start "%s"' % (join(getcwd(), MEME_FOLDER, outname))) # elif name == 'posix': # system('xdg-open "%s"' % (join(getcwd(), MEME_FOLDER, outname))) # else: # pass return MEME_FOLDER + '/' + outname
def make_og_meme(self, top, bottom): """Generate an OG Meme """ wand_t = Image(blob=self.image.read()) MARGINS = [50, 130, 200, 270, 340] # Set a minimum size wand_t.resize( 1024, int(((wand_t.height * 1.0) / (wand_t.width * 1.0)) * 1024.0)) use_top = True use_bottom = True if top == ' ': use_top = False if bottom == ' ': use_bottom = False if use_top: upper_text = "\n".join( wrap(top, self.get_warp_length(int(wand_t.width)))).upper() if use_bottom: lower_text = "\n".join( wrap(bottom, self.get_warp_length(int(wand_t.width)))).upper() lower_margin = MARGINS[lower_text.count("\n")] text_draw = Drawing() text_draw.font = "fonts/Anton-Regular.ttf" text_draw.font_size = 70 text_draw.text_alignment = "center" text_draw.stroke_color = Color("black") text_draw.stroke_width = 3 text_draw.fill_color = Color("white") if use_top: text_draw.text(int(wand_t.width / 2), 80, upper_text) if use_bottom: text_draw.text(int(wand_t.width / 2), int(wand_t.height - lower_margin), lower_text) text_draw(wand_t) return (wand_t)
def generar_meme(texto, nombre_imagen): imagen = Image(filename=nombre_imagen) imagen.resize(1024, int(((imagen.height * 1.0) / (imagen.width * 1.0)) * 1024.0)) texto = "\n".join(wrap(texto, get_length(imagen.width))).upper() text_draw = Drawing() text_draw.font = os.path.join(os.getcwd(), "impact.ttf") text_draw.font_size = 60 text_draw.text_alignment = "center" text_draw.stroke_color = Color("black") text_draw.stroke_width = 3 text_draw.fill_color = Color("white") if texto: text_draw.text(imagen.width * 60//100, imagen.height * 55//100, texto) text_draw(imagen) imagen.save(filename=os.path.join(os.getcwd(), "memes", "meme.jpg"))
def create_line_img(x_start, x_finish, brush_width, params, img, filename): step = 1.01 draw_img = Drawing() draw_img.stroke_color = Color("white") draw_img.fill_color = Color("white") draw_img.stroke_width = brush_width if x_start > x_finish: buf = x_start x_start = x_finish x_finish = buf x = x_start + step for i in range(3): while x < x_finish: x1 = x - step y1 = chosen_func(x1, params) y2 = chosen_func(x, params) draw_img.line((x1, y1), (x, y2)) x = x + 2 * step step -= 0.5 x = x_start + step draw_img.draw(img) img.save(filename=filename)
def _caption_akari(self): caption = 'わぁい{0} あかり{0}大好き'.format(self.text) drawing = Drawing() drawing.font = 'assets/fonts/rounded-mgenplus-1c-bold.ttf' drawing.font_size = self.width / 15 text = fill(caption, 23) drawing.gravity = 'south' drawing.text_interline_spacing = drawing.font_size / -5 offset = max(self.width / 400, 2) # first the shadow drawing.translate(offset, -offset) drawing.fill_color = Color('#000') drawing.fill_opacity = 0.5 drawing.text(0, 0, text) # then the text drawing.translate(-offset, offset) drawing.fill_color = Color('#fff') drawing.fill_opacity = 1.0 drawing.stroke_color = Color('#000') drawing.stroke_width = max(self.width / 600, 1) drawing.text(0, 0, text) return caption, drawing
# Make certain conversions on the background image. img.type = 'truecolor' img.alpha_channel = 'activate' # Determine the range of binsource lines we need to use. We're guaranteed # they're all in the binsource lines[] array. if bankNumber < 4: bankNumber = bankNumber ^ 2 startIndex = bankNumber * 4 * 8 * 4 + pageInBank * 4 * 8 endIndex = startIndex + 4 * 8 draw = Drawing() evilColor = Color("#FF00FF") extraColor = Color("#FF8000") draw.stroke_color = evilColor draw.stroke_width = 4 draw.fill_opacity = 0 # Draw empty frames around all of the rejected boxes. for i in range(0, len(rejectedBoxes)): boxFields = rejectedBoxes[i].split() boxLeft = int(boxFields[1]) boxBottom = backgroundHeight - 1 - int(boxFields[2]) boxRight = int(boxFields[3]) boxTop = backgroundHeight - 1 - int(boxFields[4]) draw.line((boxLeft, boxTop), (boxRight, boxTop)) draw.line((boxLeft, boxBottom), (boxRight, boxBottom)) draw.line((boxRight, boxTop), (boxRight, boxBottom)) draw.line((boxLeft, boxTop), (boxLeft, boxBottom)) # Loop on lines on the selected page. We're going to assume that the boxes are
else: imagesMatch.append(Image(filename="asciiFont/match127.png")) imagesNomatch = [] for ascii in range(128): filename = "asciiFont/nomatch" + str(ascii) + ".png" if os.path.isfile(filename): imagesNomatch.append(Image(filename=filename)) else: imagesNomatch.append(Image(filename="asciiFont/nomatch127.png")) # Prepare a drawing-context. draw = Drawing() evilColor = Color("#FF00FF") extraColor = Color("#FF8000") draw.stroke_color = evilColor draw.stroke_width = 4 * scale draw.fill_opacity = 0 # Draw empty frames around all of the rejected boxes. for i in range(0,len(rejectedBoxes)): boxTop = rejectedBoxes[i]['boxTop'] boxBottom= rejectedBoxes[i]['boxBottom'] boxLeft = rejectedBoxes[i]['boxLeft'] boxRight = rejectedBoxes[i]['boxRight'] draw.line((boxLeft,boxTop), (boxRight,boxTop)) draw.line((boxLeft,boxBottom), (boxRight,boxBottom)) draw.line((boxRight,boxTop), (boxRight,boxBottom)) draw.line((boxLeft,boxTop), (boxLeft,boxBottom)) # Loop on lines on the selected page. row = 0
# ----------gravity--------------------------------------------- draw.gravity = 'center' # -------------------------------------------------------------- # --------------shadow/border----------------------------------- if random.random() < 0.5: # shadow addx = math.ceil(random.gauss(0, 2)) addy = math.ceil(random.gauss(0, 2)) draw.fill_color = Color('black') draw.text(x=abs(addx), y=abs(addy), body=word) else: # border draw.stroke_color = Color('rgb('+str(color3[0])+','+str(color3[1])+','+str(color3[2])+')') draw.stroke_width = math.ceil(initialPointsize/10)-1 # -------------------------------------------------------------- # ----------print word------------------------------------------ draw.fill_color = Color('rgb('+str(color2[0])+','+str(color2[1])+','+str(color2[2])+')') # print('font_color =' + 'rgb('+str(color2[0])+','+str(color2[1])+','+str(color2[2])+')') draw.text(x=0, y=0, body=word) draw.draw(baseImage) # -------------------------------------------------------------- # ------------gray---------------------------------------------- baseImage.colorspace = 'gray' # -------------------------------------------------------------- print(word) baseImage.save(filename='.\\photoWand\\'+str(j+1)+'.jpg')
from wand.drawing import Drawing
def draw_faces(self, image, progress_tracker, with_back=True, only_back=False): margin_height = (self.paper['height'] - self.pattern_height()) / 2 margin_width = (self.paper['width'] - self.pattern_width()) / 2 face_sizes = { "front": (math.ceil(self.tuckbox['width'] * POINT_PER_MM), math.ceil(self.tuckbox['height'] * POINT_PER_MM)), "back": (math.ceil(self.tuckbox['width'] * POINT_PER_MM), math.ceil(self.tuckbox['height'] * POINT_PER_MM)), "left": (math.ceil(self.tuckbox['depth'] * POINT_PER_MM), math.ceil(self.tuckbox['height'] * POINT_PER_MM)), "right": (math.ceil(self.tuckbox['depth'] * POINT_PER_MM), math.ceil(self.tuckbox['height'] * POINT_PER_MM)), "top": (math.ceil(self.tuckbox['width'] * POINT_PER_MM), math.ceil(self.tuckbox['depth'] * POINT_PER_MM)), "bottom": (math.ceil(self.tuckbox['width'] * POINT_PER_MM), math.ceil(self.tuckbox['depth'] * POINT_PER_MM)), } face_positions = { "front": (math.floor((margin_width + self.tuckbox['depth']) * POINT_PER_MM), math.floor((margin_height + self.lip_size() + self.tuckbox['depth']) * POINT_PER_MM)), "back": (math.floor((margin_width + self.tuckbox['depth']*2 + self.tuckbox['width']) * POINT_PER_MM), math.floor((margin_height + self.lip_size() + self.tuckbox['depth']) * POINT_PER_MM)), "left": (math.floor(margin_width * POINT_PER_MM), math.floor((margin_height + self.lip_size() + self.tuckbox['depth']) * POINT_PER_MM)), "right": (math.floor((margin_width + self.tuckbox['depth'] + self.tuckbox['width']) * POINT_PER_MM), math.floor((margin_height + self.lip_size() + self.tuckbox['depth']) * POINT_PER_MM)), "top": (math.floor((margin_width + self.tuckbox['depth']) * POINT_PER_MM), math.floor((margin_height + self.lip_size()) * POINT_PER_MM)), "bottom": (math.floor((margin_width + self.tuckbox['depth']) * POINT_PER_MM), math.floor((margin_height + self.lip_size() + self.tuckbox['depth'] + self.tuckbox['height']) * POINT_PER_MM)), } if only_back: faces = ["back"] # We are drawing the second page with the back face only, making some assumptions on its position face_positions["back"] = (math.floor((margin_width + self.tuckbox['depth']) * POINT_PER_MM), math.floor((margin_height + self.lip_size() + self.tuckbox['depth']) * POINT_PER_MM)) else: faces = list(face_sizes.keys()) if not with_back: faces.remove("back") face_angles = {} for face in faces: face_angles[face] = self.options[face + "_angle"] if face+"_angle" in self.options else 0 # Apply those face pictures for counter, side in enumerate(faces): if side in self.faces: if self.faces[side][:1] == "#": # we are filling with color color_face_draw = Drawing() color_face_draw.stroke_width = 0 color_face_draw.fill_color = Color(self.faces[side]) color_face_draw.rectangle(left = face_positions[side][0], top = face_positions[side][1], width = face_sizes[side][0], height = face_sizes[side][1]) color_face_draw.draw(image) else: _, file_extension = os.path.splitext(os.path.basename(self.faces[side])) tmp_file = tempfile.NamedTemporaryFile(delete=False, suffix=file_extension) self.resize_rotate_image(self.faces[side], tmp_file.name, face_angles[side] * 90, *face_sizes[side]) with Image(filename=tmp_file.name) as i: image.composite(i, *face_positions[side]) if progress_tracker is not None: progress_tracker(10*(counter+2))
def draw_lip(self, top=False, bottom=False): if "back" not in self.faces: return None if not (top ^ bottom): # 1 and only 1 of top or bottom should be true return None # First draw a full mask with the lip shape lip_full_mask_image = Image(width=math.ceil(self.tuckbox['width'] * POINT_PER_MM), height=math.ceil(self.lip_size() * POINT_PER_MM)) lip_full_draw = Drawing() lip_full_draw.scale(POINT_PER_MM, POINT_PER_MM) # This cannot be too "thin" or the floodfill later would spill over lip_full_draw.stroke_width = max(2 / POINT_PER_MM, RESOLUTION / (200 * POINT_PER_MM)) lip_full_draw.fill_color = Color('white') lip_full_draw.color(0, 0, 'reset') lip_full_draw.draw(lip_full_mask_image) lip_full_draw.stroke_color = Color('black') # 1/2 left of lip lip_full_draw.bezier([(0, self.lip_size()), (0, self.lip_size() - .75*self.lip_size()), (.2 * self.tuckbox['width'], self.lip_size() - self.lip_size()), (.5 * self.tuckbox['width'], self.lip_size() - self.lip_size())]) # 1/2 right of lip lip_full_draw.bezier([(self.tuckbox['width'], self.lip_size()), (self.tuckbox['width'], self.lip_size() - .75*self.lip_size()), (.8 * self.tuckbox['width'], self.lip_size() - self.lip_size()), (.5 * self.tuckbox['width'], self.lip_size() - self.lip_size())]) lip_full_draw.draw(lip_full_mask_image) lip_full_draw.fill_color = Color('black') lip_full_draw.border_color = Color('black') lip_full_draw.color(.5 * self.tuckbox['width'], 0.8*self.lip_size(), 'filltoborder') lip_full_draw.draw(lip_full_mask_image) if self.faces['back'][:1] == "#": lip_image = Image(width = lip_full_mask_image.width, height = lip_full_mask_image.height, background = Color(self.faces['back'])) else: # Prepare the front image angle = 180 if "back_angle" not in self.options else (self.options["back_angle"]+2)*90 if bottom: angle = (angle + 180) % 360 _, file_extension = os.path.splitext(self.faces['back']) tmp_file = tempfile.NamedTemporaryFile(delete=False, suffix=file_extension) self.resize_rotate_image(self.faces['back'], tmp_file.name, angle, math.ceil(self.tuckbox['width'] * POINT_PER_MM), math.ceil(self.tuckbox['height'] * POINT_PER_MM)) lip_image = Image(filename=tmp_file.name) lip_image.crop(top=lip_image.height - lip_full_mask_image.height) # u = image pixel # h = height # j = row # Radius of the hold is {self.tuckbox['width']*.1} # if value is 1 (or more_, it's white # Top is the tip of the lip, bottom is attached to the box # finger_hold_size_save is the row # at which it should be no attenuation below finger_hold_size_save = str( int(lip_image.height - math.ceil(self.tuckbox['width'] * POINT_PER_MM * 0.1))) lip_image = lip_image.fx( "j>"+finger_hold_size_save+"?u:1+(u-1)*(j/"+finger_hold_size_save+")") lip_image.composite(operator='lighten', image=lip_full_mask_image) if bottom: lip_image.rotate(180) return lip_image
(0x6F,0x3D,0x86), (0x58,0x8D,0x43), (0x35,0x28,0x79), (0xB8,0xC7,0x6F), (0x6F,0x4F,0x25), (0x43,0x39,0x00), (0x9A,0x67,0x59), (0x44,0x44,0x44), (0x6C,0x6C,0x6C), (0x9A,0xD2,0x84), (0x6C,0x5E,0xB5), (0x95,0x95,0x95)] img = Image(width=160, height=200, resolution=300) drw = Drawing() drw.stroke_width = 0 bgcolor = 0 """ (WxH) Mc_data is a stream that describes a 40x25 cell multi color bitmap, as a matrix. Each cell is 4x8 px. The full stream is 8000 bytes long. Mc_data has each cell as its lines in order. Two contiguous cells: 00 01 02 03 | 32 33 34 35 | 04 05 06 07 | 36 37 38 39 | ... 28 29 30 31 | 60 61 62 63 | Its corresponding stream:
def draw_box(self, progress_tracker=None): if not self.check_paper_layout(): return None tuckbox_dimensions = ['width', 'height', 'depth'] paper_dimensions = ['width', 'height'] if ((not all(dimension in self.tuckbox for dimension in tuckbox_dimensions)) or (not all(dimension in self.paper for dimension in paper_dimensions))): return None # How much white space on the sides margin_height = (self.paper['height'] - self.pattern_height()) / 2 margin_width = (self.paper['width'] - self.pattern_width()) / 2 # Main box draw draw = Drawing() draw.scale(POINT_PER_MM, POINT_PER_MM) draw.stroke_color = Color('black') draw.stroke_width = RESOLUTION / (200 * POINT_PER_MM) draw.fill_opacity = 0 draw.translate(margin_width, margin_height + self.lip_size() + self.tuckbox['depth']) draw.push() # Finger holds draw finger_draw = Drawing(draw) finger_draw.fill_opacity = 1 finger_draw.fill_color = Color('white') finger_draw.push() # Dashed draw dashed_draw = Drawing(draw) dash_array = [min(self.tuckbox['depth'], self.tuckbox['width'], self.tuckbox['height'])/13] * 2 dashed_draw.stroke_color = Color('rgb(100,100,100)') dashed_draw.fill_opacity = 0 dashed_draw.stroke_width = RESOLUTION / (300 * POINT_PER_MM) dashed_draw.stroke_dash_array = dash_array dashed_draw.stroke_dash_offset = 1 # Folding guides draw folding_guides_draw = Drawing() folding_guides_draw.scale(POINT_PER_MM, POINT_PER_MM) folding_guides_draw.stroke_color = Color('black') folding_guides_draw.stroke_width = RESOLUTION / (200 * POINT_PER_MM) back_draw = Drawing(draw) back_dashed_draw = Drawing(dashed_draw) back_folding_guides_draw = Drawing(folding_guides_draw) if progress_tracker is not None: progress_tracker(5) two_openings = 'two_openings' in self.options and self.options['two_openings'] two_pages = 'two_pages' in self.options and self.options['two_pages'] dash_array = [min(self.tuckbox['depth'], self.tuckbox['width'], self.tuckbox['height'])/13] * 2 # # Draw the box (or the first page) # self.draw_front(draw, dashed_draw, two_openings) if two_pages: offset_left_to_back = self.tuckbox['depth'] else: offset_left_to_back = self.tuckbox['depth']*2 + self.tuckbox['width'] self.draw_back(offset_left_to_back, back_draw, back_dashed_draw, finger_draw, two_openings) if two_pages: back_draw.polyline([(self.tuckbox['depth'], 0), (self.tuckbox['depth'] * 0.2, 0), (self.tuckbox['depth'] * 0.2, self.tuckbox['height']), (self.tuckbox['depth'], self.tuckbox['height'])]) draw.line((self.tuckbox['depth']*2 + self.tuckbox['width'], 0), (self.tuckbox['depth']*2 + self.tuckbox['width'], self.tuckbox['height'])) if progress_tracker is not None: progress_tracker(10) # Create the image image = Image(width=math.ceil(self.paper['width'] * POINT_PER_MM), height=math.ceil(self.paper['height'] * POINT_PER_MM), background=Color('white')) image.resolution = RESOLUTION image.unit = 'pixelsperinch' if two_pages: image2 = Image(width=math.ceil(self.paper['width'] * POINT_PER_MM), height=math.ceil(self.paper['height'] * POINT_PER_MM), background=Color('white')) image2.resolution = RESOLUTION image2.unit = 'pixelsperinch' else: image2 = image # Draw the faces self.draw_faces(image, progress_tracker, with_back = not two_pages) if two_pages: self.draw_faces(image2, progress_tracker, only_back=True) # Draw the lip(s) lip = self.draw_lip(top=True) if lip is not None: image.composite(lip, math.floor((margin_width + self.tuckbox['depth']) * POINT_PER_MM), math.floor((margin_height) * POINT_PER_MM)) if two_openings: lip = self.draw_lip(bottom=True) if lip is not None: image.composite(lip, math.floor((margin_width + self.tuckbox['depth']) * POINT_PER_MM), math.floor((margin_height + self.tuckbox['depth']*2 + self.lip_size() + self.tuckbox['height']) * POINT_PER_MM)) if progress_tracker is not None: progress_tracker(80) # Draw all the lines over draw.draw(image) back_draw.draw(image2) finger_draw.draw(image2) self.draw_watermark(image) if two_pages: self.draw_watermark(image2) if progress_tracker is not None: progress_tracker(90) if "folds_dashed" in self.options and self.options["folds_dashed"]: dashed_draw.draw(image) back_dashed_draw.draw(image2) if "folding_guides" in self.options and self.options["folding_guides"]: front_vertical_folds = [margin_width + self.tuckbox['depth'], margin_width + self.tuckbox['depth'] + self.tuckbox['width']] if not two_pages: front_vertical_folds.extend([margin_width + self.tuckbox['depth']*2 + self.tuckbox['width'], margin_width + self.tuckbox['depth']*2 + self.tuckbox['width']*2]) back_vertical_folds = [margin_width + self.tuckbox['depth'], margin_width + self.tuckbox['depth'] + self.tuckbox['width']] front_horizontal_folds = [margin_height + self.lip_size(), margin_height + self.lip_size() + self.tuckbox['depth'], margin_height + self.lip_size() + self.tuckbox['depth'] + self.tuckbox['height']] if two_openings: front_horizontal_folds.append(margin_height + self.lip_size() + self.tuckbox['depth'] * 2 + self.tuckbox['height']) back_horizontal_folds = [] else: back_horizontal_folds = [margin_height + self.lip_size() + self.tuckbox['depth'] + self.tuckbox['height']] self.draw_folds(folding_guides_draw, front_vertical_folds, front_horizontal_folds, margin_height, margin_width) self.draw_folds(back_folding_guides_draw, back_vertical_folds, back_horizontal_folds, margin_height, margin_width) folding_guides_draw.draw(image) back_folding_guides_draw.draw(image2) if progress_tracker is not None: progress_tracker(100) if not two_pages: image2 = None return image, image2
def generate(count): # ---------------get three colors------------------------------- colorString = random.choice(result) color = [] for i in colorString: color += [int(i)] # for i in range(len(color)): # color[i] = math.floor(color[i]/255*65535) color1 = color[0:3] color2 = color[3:6] color3 = color[6:9] # -------------------------------------------------------------- # ----------get the base layer texture-------------------------- Scenes = pathwalk('./SceneData') randomScene = random.choice(Scenes) randomScene = randomScene[0] + '/' + randomScene[1] print(randomScene) randomSceneImage = Image(filename=randomScene) widthRange = randomSceneImage.size[0] - 100 heightRange = randomSceneImage.size[1] - 32 randomSceneImage.crop(left=random.randint(0, widthRange), top=random.randint(0, heightRange), width=100, height=32) # randomSceneImage.save(filename='.\\photoWand\\'+str(j+1) + '_texture.jpg') # -------------------------------------------------------------- # ----------create the base layer, base texture +base color----- baseImage = Image(width=100, height=32, background=Color('rgb('+str(color1[0])+','+str(color1[1])+','+str(color1[2])+')')) # print('base_color = ' + 'rgb('+str(color1[0])+','+str(color1[1])+','+str(color1[2])+')') baseImage.composite_channel(channel='undefined', image=randomSceneImage, operator='blend', left=0, top=0) baseImage.gaussian_blur(4, 10) baseImage.resolution = (96, 96) # -------------------------------------------------------------- # -----generate font-------------------------------------------- word = randomWords() fonts = pathwalk('./fonts/font_en/') randomFont = random.choice(fonts) randomFont = randomFont[0] + randomFont[1] initialPointsize = 45 draw = Drawing() draw.font = randomFont tmp = int(math.floor(abs(random.gauss(0, 1))*6)) if random.randint(1, 2) == 1: rotateX = random.randint(0, tmp) else: rotateX = random.randint(360-tmp, 360) draw.rotate(rotateX) # -------------------------------------------------------------- # --------get suitable FontPointSize---------------------------- draw.font_size = initialPointsize metric = draw.get_font_metrics(image=baseImage, text=word) while metric.text_width > 100 or metric.text_height > 36: initialPointsize -= 5 draw.font_size = initialPointsize metric = draw.get_font_metrics(image=baseImage, text=word) # -------------------------------------------------------------- # ----------italic---------------------------------------------- if random.random() > 0.5: draw.font_style = 'italic' # -------------------------------------------------------------- # ----------underline------------------------------------------- if random.random() > 0.5: draw.text_decoration = 'underline' # -------------------------------------------------------------- # ----------gravity--------------------------------------------- draw.gravity = 'center' # -------------------------------------------------------------- # --------------shadow/border----------------------------------- if random.random() < 0.5: # shadow addx = math.ceil(random.gauss(0, 2)) addy = math.ceil(random.gauss(0, 2)) draw.fill_color = Color('black') draw.text(x=abs(int(addx)), y=abs(int(addy)), body=word) else: # border draw.stroke_color = Color('rgb('+str(color3[0])+','+str(color3[1])+','+str(color3[2])+')') draw.stroke_width = math.ceil(initialPointsize/10)-1 # -------------------------------------------------------------- # ----------print word------------------------------------------ draw.fill_color = Color('rgb('+str(color2[0])+','+str(color2[1])+','+str(color2[2])+')') draw.text(x=0, y=0, body=word) draw.draw(baseImage) # -------------------------------------------------------------- # ------------gray---------------------------------------------- baseImage.colorspace = 'gray' # -------------------------------------------------------------- print(word) baseImage.save(filename='./photo_en/'+str(count+1)+'_'+word+'.jpg')
def makedrawing(): draw = Drawing() draw.fill_color = Color('white') draw.stroke_color = Color('black') draw.stroke_width = 1 return draw
# Make certain conversions on the background image. img.type = 'truecolor' img.alpha_channel = 'activate' # Determine the range of binsource lines we need to use. We're guaranteed # they're all in the binsource lines[] array. if bankNumber < 4: bankNumber = bankNumber ^ 2 startIndex = bankNumber * 4 * 8 * 4 + pageInBank * 4 * 8 endIndex = startIndex + 4 * 8 draw = Drawing() evilColor = Color("#FF00FF") extraColor = Color("#FF8000") draw.stroke_color = evilColor draw.stroke_width = 4 draw.fill_opacity = 0 # Draw empty frames around all of the rejected boxes. for i in range(0,len(rejectedBoxes)): boxFields = rejectedBoxes[i].split() boxLeft = int(boxFields[1]) boxBottom = backgroundHeight - 1 - int(boxFields[2]) boxRight = int(boxFields[3]) boxTop = backgroundHeight - 1 - int(boxFields[4]) draw.line((boxLeft,boxTop), (boxRight,boxTop)) draw.line((boxLeft,boxBottom), (boxRight,boxBottom)) draw.line((boxRight,boxTop), (boxRight,boxBottom)) draw.line((boxLeft,boxTop), (boxLeft,boxBottom)) # Loop on lines on the selected page. We're going to assume that the boxes are
else: imagesMatch.append(Image(filename="asciiFont/match127.png")) imagesNomatch = [] for ascii in range(128): filename = "asciiFont/nomatch" + str(ascii) + ".png" if os.path.isfile(filename): imagesNomatch.append(Image(filename=filename)) else: imagesNomatch.append(Image(filename="asciiFont/nomatch127.png")) # Prepare a drawing-context. draw = Drawing() evilColor = Color("#FF00FF") extraColor = Color("#FF8000") draw.stroke_color = evilColor draw.stroke_width = 4 * scale draw.fill_opacity = 0 # Draw empty frames around all of the rejected boxes. for i in range(0, len(rejectedBoxes)): boxTop = rejectedBoxes[i]['boxTop'] boxBottom = rejectedBoxes[i]['boxBottom'] boxLeft = rejectedBoxes[i]['boxLeft'] boxRight = rejectedBoxes[i]['boxRight'] draw.line((boxLeft, boxTop), (boxRight, boxTop)) draw.line((boxLeft, boxBottom), (boxRight, boxBottom)) draw.line((boxRight, boxTop), (boxRight, boxBottom)) draw.line((boxLeft, boxTop), (boxLeft, boxBottom)) # Loop on lines on the selected page. row = 0
def generate(count): # ---------------get three colors------------------------------- colorString = random.choice(result) color = [] for i in colorString: color += [int(i)] # for i in range(len(color)): # color[i] = math.floor(color[i]/255*65535) color1 = color[0:3] color2 = color[3:6] color3 = color[6:9] # -------------------------------------------------------------- # ----------get the base layer texture-------------------------- Scenes = pathwalk('./SceneData') randomScene = random.choice(Scenes) randomScene = randomScene[0] + '/' + randomScene[1] print(randomScene) randomSceneImage = Image(filename=randomScene) widthRange = randomSceneImage.size[0] - 100 heightRange = randomSceneImage.size[1] - 32 randomSceneImage.crop(left=random.randint(0, widthRange), top=random.randint(0, heightRange), width=100, height=32) # randomSceneImage.save(filename='.\\photoWand\\'+str(j+1) + '_texture.jpg') # -------------------------------------------------------------- # ----------create the base layer, base texture +base color----- baseImage = Image( width=100, height=32, background=Color('rgb(' + str(color1[0]) + ',' + str(color1[1]) + ',' + str(color1[2]) + ')')) # print('base_color = ' + 'rgb('+str(color1[0])+','+str(color1[1])+','+str(color1[2])+')') baseImage.composite_channel(channel='undefined', image=randomSceneImage, operator='blend', left=0, top=0) baseImage.gaussian_blur(4, 10) baseImage.resolution = (96, 96) # -------------------------------------------------------------- # -----generate font-------------------------------------------- word = randomWords() fonts = pathwalk('./fonts/font_en/') randomFont = random.choice(fonts) randomFont = randomFont[0] + randomFont[1] initialPointsize = 45 draw = Drawing() draw.font = randomFont tmp = int(math.floor(abs(random.gauss(0, 1)) * 6)) if random.randint(1, 2) == 1: rotateX = random.randint(0, tmp) else: rotateX = random.randint(360 - tmp, 360) draw.rotate(rotateX) # -------------------------------------------------------------- # --------get suitable FontPointSize---------------------------- draw.font_size = initialPointsize metric = draw.get_font_metrics(image=baseImage, text=word) while metric.text_width > 100 or metric.text_height > 36: initialPointsize -= 5 draw.font_size = initialPointsize metric = draw.get_font_metrics(image=baseImage, text=word) # -------------------------------------------------------------- # ----------italic---------------------------------------------- if random.random() > 0.5: draw.font_style = 'italic' # -------------------------------------------------------------- # ----------underline------------------------------------------- if random.random() > 0.5: draw.text_decoration = 'underline' # -------------------------------------------------------------- # ----------gravity--------------------------------------------- draw.gravity = 'center' # -------------------------------------------------------------- # --------------shadow/border----------------------------------- if random.random() < 0.5: # shadow addx = math.ceil(random.gauss(0, 2)) addy = math.ceil(random.gauss(0, 2)) draw.fill_color = Color('black') draw.text(x=abs(int(addx)), y=abs(int(addy)), body=word) else: # border draw.stroke_color = Color('rgb(' + str(color3[0]) + ',' + str(color3[1]) + ',' + str(color3[2]) + ')') draw.stroke_width = math.ceil(initialPointsize / 10) - 1 # -------------------------------------------------------------- # ----------print word------------------------------------------ draw.fill_color = Color('rgb(' + str(color2[0]) + ',' + str(color2[1]) + ',' + str(color2[2]) + ')') draw.text(x=0, y=0, body=word) draw.draw(baseImage) # -------------------------------------------------------------- # ------------gray---------------------------------------------- baseImage.colorspace = 'gray' # -------------------------------------------------------------- print(word) baseImage.save(filename='./photo_en/' + str(count + 1) + '_' + word + '.jpg')
draw.gravity = 'center' # -------------------------------------------------------------- # --------------shadow/border----------------------------------- if random.random() < 0.5: # shadow addx = math.ceil(random.gauss(0, 2)) addy = math.ceil(random.gauss(0, 2)) draw.fill_color = Color('black') draw.text(x=abs(addx), y=abs(addy), body=word) else: # border draw.stroke_color = Color('rgb(' + str(color3[0]) + ',' + str(color3[1]) + ',' + str(color3[2]) + ')') draw.stroke_width = math.ceil(initialPointsize / 10) - 1 # -------------------------------------------------------------- # ----------print word------------------------------------------ draw.fill_color = Color('rgb(' + str(color2[0]) + ',' + str(color2[1]) + ',' + str(color2[2]) + ')') # print('font_color =' + 'rgb('+str(color2[0])+','+str(color2[1])+','+str(color2[2])+')') draw.text(x=0, y=0, body=word) draw.draw(baseImage) # -------------------------------------------------------------- # ------------gray---------------------------------------------- baseImage.colorspace = 'gray' # -------------------------------------------------------------- print(word)