Exemple #1
0
    def show_results(self,
                     set_number,
                     seq_number,
                     frame_number,
                     clas_guess,
                     guess_pos,
                     guess_scores,
                     original_image=False):
        self.load_annotations()  # Will be needed

        if CaltechDataset.USE_CROPPING:
            if original_image:
                image = Image.open(
                    self.dataset_location +
                    '/images/set{:02d}/V{:03d}.seq/{}.jpg'.format(
                        set_number, seq_number, frame_number))
            else:
                image = Image.open(
                    self.dataset_location +
                    '/images-cropped/set{:02d}/V{:03d}.seq/{}.jpg'.format(
                        set_number, seq_number, frame_number))
            transform = np.load(
                self.dataset_location +
                '/images-cropped/set{:02d}/V{:03d}.seq/{}.transform.npy'.
                format(set_number, seq_number, frame_number))
        else:
            image = Image.open(self.dataset_location +
                               '/images/set{:02d}/V{:03d}.seq/{}.jpg'.format(
                                   set_number, seq_number, frame_number))
        dr = ImageDraw.Draw(image)

        # Retrieve objects for that frame in annotations
        try:
            objects = self.annotations['set{:02d}'.format(set_number)][
                'V{:03d}'.format(seq_number)]['frames']['{}'.format(
                    frame_number)]
        except KeyError as e:
            objects = None  # Simply no objects for that frame

        if objects:
            for o in objects:
                pos = (o['pos'][1], o['pos'][0], o['pos'][3], o['pos'][2]
                       )  # Convert to (y, x, h, w)
                if CaltechDataset.USE_CROPPING and not original_image:
                    pos = transform_cropped_pos(pos, transform)

                if o['lbl'] in ['person']:
                    good = True

                    # Remove objects with very small width (are they errors in labeling?!)
                    if pos[3] < CaltechDataset.MINIMUM_WIDTH:
                        good = False

                    if o['occl'] == 1:
                        if type(o['posv']) == int:
                            good = False
                        else:
                            visible_pos = (o['posv'][1], o['posv'][0],
                                           o['posv'][3], o['posv'][2]
                                           )  # Convert to (y, x, h, w)
                            if CaltechDataset.USE_CROPPING and not original_image:
                                visible_pos = transform_cropped_pos(
                                    visible_pos, transform)
                            if visible_pos[2] * visible_pos[
                                    3] < CaltechDataset.MINIMUM_VISIBLE_RATIO * pos[
                                        2] * pos[3]:
                                good = False
                                pos = visible_pos

                    if good:
                        dr.rectangle(
                            (pos[1], pos[0], pos[1] + pos[3], pos[0] + pos[2]),
                            outline='blue')
                    else:
                        dr.rectangle(
                            (pos[1], pos[0], pos[1] + pos[3], pos[0] + pos[2]),
                            outline='pink')
                else:
                    dr.rectangle(
                        (pos[1], pos[0], pos[1] + pos[3], pos[0] + pos[2]),
                        outline='black')

        if not CaltechDataset.USE_CROPPING or not original_image:
            for y in range(clas_guess.shape[0]):
                for x in range(clas_guess.shape[1]):
                    for anchor_id in range(clas_guess.shape[2]):
                        if clas_guess[y, x, anchor_id] == 0.0:  # Negative
                            dr.rectangle(
                                (CaltechDataset.OUTPUT_CELL_SIZE * x,
                                 CaltechDataset.OUTPUT_CELL_SIZE * y,
                                 CaltechDataset.OUTPUT_CELL_SIZE *
                                 (x + 1) - 1, CaltechDataset.OUTPUT_CELL_SIZE *
                                 (y + 1) - 1),
                                outline='red')
                        else:  # Positive
                            dr.rectangle(
                                (CaltechDataset.OUTPUT_CELL_SIZE * x,
                                 CaltechDataset.OUTPUT_CELL_SIZE * y,
                                 CaltechDataset.OUTPUT_CELL_SIZE *
                                 (x + 1) - 1, CaltechDataset.OUTPUT_CELL_SIZE *
                                 (y + 1) - 1),
                                outline='green')

        for row in range(guess_pos.shape[0]):
            pos = guess_pos[row]
            if CaltechDataset.USE_CROPPING and original_image:
                pos = untransform_cropped_pos(pos, transform)
            dr.rectangle((pos[1], pos[0], pos[1] + pos[3], pos[0] + pos[2]),
                         outline='green')
            dr.text((pos[1], pos[0]), '{:.3f}'.format(guess_scores[row]))

        image.show()
Exemple #2
0
def binary_classificn_pts(extent=0, datt=[], scale=1, r=np.eye(2), t1=0, t2=0, 
	trnsp1=120, trnsp2=120,
	trp1_hi=120, trp1_lo=120,
	trp2_hi=120, trp2_lo=120,
	hi1_ind=1000, lo1_ind=0,
	hi2_ind=1000, lo2_ind=0,
	xshift1=0, xshift2=0):
	# Basic stuff with points.
	w=5
	im = Image.new("RGB", (2048, 2048), (1, 1, 1))
	draw = ImageDraw.Draw(im, 'RGBA')
	if extent == 0:
		return (im, draw)
	means1_orig = np.array([500, 1500])
	means2_orig = np.array([1500, 500])

	means1 = generalized_planar_rotation(means1_orig, np.array([1000,1000]), r)
	means2 = generalized_planar_rotation(means2_orig, np.array([1000,1000]), r)
	p=0.3
	center_1_orig = means1_orig*p+means2_orig*(1-p)
	center_2_orig = means2_orig*p+means1_orig*(1-p)
	center_1 = means1*p+means2*(1-p)
	center_2 = means2*p+means1*(1-p)
	means = center_1
	stds = [300, 300]
	corr = 0.8         # correlation
	covs = [[stds[0]**2          , stds[0]*stds[1]*corr],
			[stds[0]*stds[1]*corr,           stds[1]**2]]
	np.random.seed(0)
	m_1 = np.random.multivariate_normal(center_1_orig, covs, 200)*scale
	m = m_1
	for i in range(m.shape[0]):
		r_pt = generalized_planar_rotation(m[i], np.array([1000,1000]), r)
		if extent > 0 and extent < 5:
			draw.ellipse((r_pt[0]-w,r_pt[1]-w,r_pt[0]+w,r_pt[1]+w), fill = (255,30,102), outline = (0,0,0))
	means = center_2
	np.random.seed(4)
	m_2 = np.random.multivariate_normal(center_2_orig, covs, 200)*scale
	m = m_2
	for i in range(m.shape[0]):
		r_pt = generalized_planar_rotation(m[i], np.array([1000,1000]), r)
		if extent > 1 and extent < 5:
			draw.ellipse((r_pt[0]-w,r_pt[1]-w,r_pt[0]+w,r_pt[1]+w), fill = (20,255,102), outline = (0,0,0))
	
	# Draw the separating line.
	center = (center_1+center_2)/2
	orthog = -np.dot(planar_rotation(-np.pi/2), (center_2-center_1))
	main_dircn = (center_2 - center_1)
	p=2.0
	pt_1 = center + orthog*p
	pt_2 = center - orthog*p
	if extent > 2:
		draw.line((pt_1[0], pt_1[1], pt_2[0], pt_2[1]), fill = 'grey', width = 7)

	avgs = []
	means = np.sum(m_1,axis=1)/2
	avgs2 = []
	means2 = np.sum(m_2,axis=1)/2
	for i in range(len(means)):
		avgs.append((((m_1[i][1]<m_1[i][0]))-0.5)*2*np.sqrt(sum((m_1[i]-means[i])**2)))
		avgs2.append((((m_2[i][1]<m_2[i][0]))-0.5)*2*np.sqrt(sum((m_2[i]-means2[i])**2)))
	avgs = np.array(avgs)
	avgs2 = np.array(avgs2)
	dat1 = m_1[avgs > np.percentile(avgs,97)]
	dat2 = m_2[avgs2 < np.percentile(avgs,4)]
	for i in dat1:
		datt.append(i)
	for i in dat2:
		datt.append(i)
	xs = [1000]
	for i in range(1,8):
		pt_1_a = pt_1 + main_dircn*i/7
		pt_1_b = pt_1 - main_dircn*i/7
		pt_2_a = pt_2 + main_dircn*i/7
		pt_2_b = pt_2 - main_dircn*i/7
		if extent > 3:
			draw.line((pt_1_a[0], pt_1_a[1], pt_2_a[0], pt_2_a[1]), fill = (255,255,255,100), width = 4)
			draw.line((pt_1_b[0], pt_1_b[1], pt_2_b[0], pt_2_b[1]), fill = (255,255,255,100), width = 4)
		xs.append(pt_1_a[0])
		xs.append(pt_1_b[0])
	xs.sort()
	xs.append(max(xs)+xs[1]-xs[0])
	xs.append(min(xs)-xs[1]+xs[0])
	# I basically want to transfer the last element to the first position
	# so sort is overkill. But it's a small array, so no matter.
	xs.sort()
	if extent > 4:
		drip_to_bins(draw, xs, m, t1, r, rgb=(20,255,102), transparency=trnsp1, trp_hi=trp1_hi, trp_lo=trp1_lo,
			hi_ind=hi1_ind,lo_ind=lo1_ind,xshift=xshift1)
		drip_to_bins(draw, xs, m_1, t2, r, rgb=(255,20,102), transparency=trnsp2, trp_hi=trp2_hi, trp_lo=trp2_lo,
			hi_ind=hi2_ind,lo_ind=lo2_ind,xshift=xshift2)
	return (im, draw)
def show_custom_labels(model, photo, min_confidence):

    rekognition = boto3.client('rekognition')

    # # Load image from S3 bucket
    # s3_connection = boto3.resource('s3')
    #
    # s3_object = s3_connection.Object(bucket, photo)
    # s3_response = s3_object.get()
    #
    # stream = io.BytesIO(s3_response['Body'].read())

    # read in photo
    image = cv2.imread(photo)

    # if has frame then resize and encode it as jpg
    hasFrame, imageBytes = cv2.imencode(".jpg", image)

    # run image against model
    response = rekognition.detect_custom_labels(Image={
        'Bytes': imageBytes.tobytes(),
    },
                                                ProjectVersionArn=model,
                                                MinConfidence=min_confidence)

    #convert from cv2 to PIL
    image_pil = Image.fromarray(cv2.cvtColor(image, cv2.COLOR_BGR2RGB))

    imgWidth, imgHeight = image_pil.size
    draw = ImageDraw.Draw(image_pil)

    # calculate and display bounding boxes for each detected custom label
    print('Detected custom labels for ' + photo)
    for customLabel in response['CustomLabels']:
        print('Label ' + str(customLabel['Name']))
        print('Confidence ' + str(customLabel['Confidence']))
        if 'Geometry' in customLabel:
            box = customLabel['Geometry']['BoundingBox']
            left = imgWidth * box['Left']
            top = imgHeight * box['Top']
            width = imgWidth * box['Width']
            height = imgHeight * box['Height']
            x = left + (width / 2)
            y = top - (height / 2)

            fnt = ImageFont.truetype('/Library/Fonts/Arial.ttf', 50)
            draw.text((left, top),
                      customLabel['Name'],
                      fill='#00d400',
                      font=fnt)

            print('Left: ' + '{0:.0f}'.format(left))
            print('Top: ' + '{0:.0f}'.format(top))
            print('Label Width: ' + "{0:.0f}".format(width))
            print('Label Height: ' + "{0:.0f}".format(height))
            print('X: {}, Y: {}'.format(x, y))

            points = ((left, top), (left + width, top), (left + width,
                                                         top + height),
                      (left, top + height), (left, top))
            draw.line(points, fill='#00d400', width=5)

    image_pil.show()

    return len(response['CustomLabels'])
Exemple #4
0
#print(ud)
#print(kn_fac_encodis)
count=0

for check in kn_fac_encodis:
    #print("Check",check)
    # Load an image with an unknown face
    unknown_image = face_recognition.load_image_file("E:\\Face Detection\\DEMO 3\\image\\tamizhh.jpg")  #am , sugu, suu , unknownface, tamizhh,
    # Find all the faces and face encodings in the unknown image
    face_locations = face_recognition.face_locations(unknown_image)   #face_locations = face_recognition.face_locations(image, model="cnn")
    #face_encodings = face_recognition.face_encodings(unknown_image, face_locations)
    # Convert the image to a PIL-format image so that we can draw on top of it with the Pillow library
    # See http://pillow.readthedocs.io/ for more about PIL/Pillow
    pil_image = Image.fromarray(unknown_image)
    # Create a Pillow ImageDraw Draw instance to draw with
    draw = ImageDraw.Draw(pil_image)
    #dupl=[]
    locations, face_encodings = get_face_embeddings_from_image(unknown_image)
    #print("Encoding_Face_embedding",face_encodings[0])
    #print("Encoding_Face_encoding",face_encodings)

    matches = face_recognition.compare_faces(check, face_encodings[0])
    face_distances = face_recognition.face_distance(check, face_encodings[0])
    print(face_distances)
    if face_distances[0]<0.44:
        print("Photo Matched.....!!!")
        count=count+1
        #print(di[str(check)])
        names.append(di[str(check)])
    else:
        print("Not Matched..!")
Exemple #5
0
def test():
    import torchvision

    transform = transforms.Compose([
        transforms.ToTensor(),
        transforms.Normalize((0.485,0.456,0.406), (0.229,0.224,0.225))
    ])

    dataType = 'train2017'
    root_path = "../COCO_dataset/images/%s"%(dataType)
    list_root_path = "./data/%s.txt"%(dataType)
    dataset = ListDataset(root=root_path,list_file=list_root_path, train=True, transform=transform, input_size=360)
    dataloader = torch.utils.data.DataLoader(dataset, batch_size=1, shuffle=True, num_workers=1, collate_fn=dataset.collate_fn)

    for images, loc_targets, cls_targets in dataloader:
        print(images.shape)
        print(loc_targets.shape)
        print(cls_targets.shape)
        grid = torchvision.utils.make_grid(images, 1)
        torchvision.utils.save_image(grid, 'a.jpg')

        print('Loading image..')
        net = RetinaNet()
        net.eval()

        img = Image.open('a.jpg')
        w = h = 360
        img = img.resize((w,h))

        print('Predicting..')
        x = transform(img)
        x = x.unsqueeze(0)
        x = Variable(x)

        use_cuda = torch.cuda.is_available()
        device = torch.device("cuda" if use_cuda else "cpu")
        print('Device used:', device)
        if torch.cuda.is_available():
            net = net.to(device)
            x = x.to(device)
            loc_targets = loc_targets.to(device)

        with torch.no_grad():
            loc_preds, cls_preds = net(x)
            print(loc_preds.shape)
            print(cls_preds.shape)
            print('Decoding..')
            encoder = DataEncoder()

            boxes, labels, _ = encoder.decode(loc_targets.data.cpu()[0], cls_preds.data.cpu().squeeze(), (w,h))
            print("Label : ",labels)
            draw = ImageDraw.Draw(img)
            # use a truetype font
            font = ImageFont.truetype("./font/DELIA_regular.ttf", 20)
            for i,(box,label) in enumerate(zip(boxes,labels)):
                draw.rectangle(list(box), outline=color_map(int(label)),width = 5)
                draw.rectangle(list([box[0],box[1]-17,box[0]+10*len(my_cate[int(label)])+5,box[1]]), outline=color_map(int(label)),width = 3,fill=color_map(int(label)))
                draw.text((box[0]+3, box[1]-16), my_cate[int(label)],font = font,fill = (0, 0, 0, 100),width = 5)

            plt.imshow(img)
            plt.savefig("./test.jpg")

        break
Exemple #6
0
def detectar_emociones(foto):
    data = open(foto, 'rb')

    #headers = {'Ocp-Apim-Subscription-Key': KEY} Se puede usar este header cuando usa un url de internet y en lugar de data usa json{url: url(entre comillas)}
    headers = {
        'Content-Type': 'application/octet-stream',
        'Ocp-Apim-Subscription-Key': SUBSCRIPTION_KEY
    }  #Funciona porque tiene el content  type
    params = {
        'returnFaceAttributes': 'emotion',
    }
    face_api_url = BASE_URL + 'detect'
    response = requests.post(face_api_url,
                             params=params,
                             headers=headers,
                             data=data)
    json_detected = response.json()

    face_ids = [d['faceId'] for d in json_detected]
    identified_faces = CF.face.identify(face_ids, PERSON_GROUP_ID)

    for identified in identified_faces:
        candidates_list = identified['candidates']
        print("Candidates", candidates_list)
        if candidates_list != []:
            candidates = candidates_list[0]
            persona = candidates['personId']
            persona_info = CF.person.get(PERSON_GROUP_ID, persona)
            person_name = persona_info['name']

            emociones = {}
            for resp in json_detected:
                if resp['faceId'] == identified['faceId']:
                    faceRectangle = resp['faceRectangle']
                    width = faceRectangle['width']
                    top = faceRectangle['top']
                    height = faceRectangle['height']
                    left = faceRectangle['left']
                    emociones = resp['faceAttributes']['emotion']
                    print("EMOCIONES", emociones)
                    break
            image = Image.open(foto)
            draw = ImageDraw.Draw(image)
            draw.rectangle((left, top, left + width, top + height),
                           outline='red')
            font = ImageFont.truetype('Roboto-Regular.ttf', 20)
            draw.text((0, 0), person_name, font=font, fill="black")
            #emociones = detectar_emociones(foto)
            y = 20
            font_emotion = ImageFont.truetype('Roboto-Regular.ttf', 15)
            for e in emociones:
                if emociones[e] > 0.0:
                    emocion = traducir_sentimiento(e)
                    draw.text((10, y),
                              emocion,
                              font=font_emotion,
                              fill="black")
                    draw.text((70, y),
                              str(round(emociones[e] * 100, 2)) + "%",
                              font=font_emotion,
                              fill="black")
                    y += 20
            image.show()
            return
    '''for j in json_detected:
Exemple #7
0
# left, top, right, bottom = 1100, 870, 1700, 1700
# cropped = imageObject.crop((left, top, right, bottom))
#
# # Display the cropped portion
#
# cropped.show()

# cropped_image.save(saved_location)

path = '/Users/jordanwalker/Downloads/lance-modis-sa/'

filelist = glob.glob(os.path.join(path, '*.jpg'))
filenames = sorted(x for x in filelist)

for im in filenames:
    saved_location = im.replace('lance-modis-sa', 'lance-modis-sa-name')
    im_object = im.split('/')
    img_split = im_object[-1].split('.')
    file_label = img_split[-3]

    imageObject = Image.open(im)
    draw = ImageDraw.Draw(imageObject)
    font = ImageFont.truetype('/Library/Fonts/Arial.ttf', 16)
    draw.text((5, 5), file_label[0:4], (255, 255, 255), font=font)
    imageObject.save(saved_location)

    # If you need to crop
    # left, top, right, bottom = 1100, 870, 1700, 1700
    # cropped = imageObject.crop((left, top, right, bottom))
    # cropped.save(saved_location)
Exemple #8
0
    async def seasoncreate(self, data, seasondata, season, profile,
                           seasonname):
        font_file = f"{bundled_data_path(self)}/fonts/RobotoRegular.ttf"
        bold_file = f"{bundled_data_path(self)}/fonts/RobotoBold.ttf"
        name_fnt = ImageFont.truetype(font_file, 42, encoding="utf-8")
        header_fnt = ImageFont.truetype(bold_file, 42, encoding="utf-8")
        operator = random.choice(self.bgs)

        bg_image = Image.open(
            f"{bundled_data_path(self)}/bg/{operator}.jpg").convert("RGBA")

        profile_image = Image

        profile_avatar = BytesIO()
        profile_url = data.avatar_url_256
        async with self.session.get(profile_url) as r:
            profile_img = await r.content.read()
            profile_avatar = BytesIO(profile_img)

        profile_image = Image.open(profile_avatar).convert("RGBA")

        # set canvas
        bg_color = (255, 255, 255, 0)
        result = Image.new("RGBA", (1600, 1080), bg_color)
        process = Image.new("RGBA", (1600, 1080), bg_color)

        # draw
        draw = ImageDraw.Draw(process)

        # puts in background
        bg_image = bg_image.resize((1920, 1090), Image.ANTIALIAS)
        bg_image = bg_image.crop((0, 0, 1920, 1080))
        result.paste(bg_image, (0, 0))

        aviholder = self.add_corners(
            Image.new("RGBA", (266, 266), (255, 255, 255, 255)), 10)
        process.paste(aviholder, (1295, 15), aviholder)
        process.paste(profile_image, (1300, 20))

        # op badge

        if season >= 14:
            ranks = self.ranksember
        else:
            ranks = self.ranks
        url = self.rankurl + ranks[seasondata["rank_text"]]

        process.paste(aviholder, (995, 15), aviholder)
        im = Image.open(BytesIO(await self.getimg(url)))
        im = im.resize((256, 256), Image.ANTIALIAS)
        process.paste(im, (1000, 20))

        # data
        # draw.text((440, 40), "Name: {}".format(self._truncate_text(data.username, 18)), fill=(255, 255, 255, 255), font=header_fnt)
        draw.text(
            (
                self._center(
                    440,
                    1000,
                    "Name: {}".format(self._truncate_text(data.username, 18)),
                    header_fnt,
                ),
                40,
            ),
            "Name: {}".format(self._truncate_text(data.username, 18)),
            fill=(255, 255, 255, 255),
            font=header_fnt,
        )
        draw.text(
            (
                self._center(440, 1000, "Platform: {}".format(
                    str(data.platform).title()), header_fnt),
                90,
            ),
            "Platform: {}".format(str(data.platform).title()),
            fill=(255, 255, 255, 255),
            font=header_fnt,
        )
        draw.text(
            (
                self._center(
                    440, 1000, "Region: {}".format(
                        self.regions[seasondata["region"]]), header_fnt),
                140,
            ),
            "Region: {}".format(self.regions[seasondata["region"]]),
            fill=(255, 255, 255, 255),
            font=header_fnt,
        )

        draw.text(
            (self._center(440, 1000, f"{seasonname} Statistics",
                          header_fnt), 190),
            f"{seasonname} Statistics",
            fill=(255, 255, 255, 255),
            font=header_fnt,
        )

        draw.text(
            (520, 320),
            "Games Played: {}".format(seasondata["wins"] +
                                      seasondata["losses"]),
            fill=(255, 255, 255, 255),
            font=name_fnt,
        )
        draw.text(
            (520, 380),
            "Wins: {}".format(seasondata["wins"]),
            fill=(255, 255, 255, 255),
            font=name_fnt,
        )
        draw.text(
            (960, 380),
            "Losses: {}".format(seasondata["losses"]),
            fill=(255, 255, 255, 255),
            font=name_fnt,
        )
        draw.text(
            (520, 440),
            "Abandons: {}".format(seasondata["abandons"]),
            fill=(255, 255, 255, 255),
            font=name_fnt,
        )
        try:
            wlr = round(
                seasondata["wins"] /
                (seasondata["wins"] + seasondata["losses"]), 2)
        except ZeroDivisionError:
            wlr = 0
        draw.text(
            (960, 440),
            "Total W/LR: {}%".format(wlr * 100),
            fill=(255, 255, 255, 255),
            font=name_fnt,
        )

        draw.text(
            (520, 520),
            "Kills: {}".format(seasondata["kills"]),
            fill=(255, 255, 255, 255),
            font=name_fnt,
        )
        draw.text(
            (960, 520),
            "Deaths: {}".format(seasondata["deaths"]),
            fill=(255, 255, 255, 255),
            font=name_fnt,
        )
        draw.text(
            (520, 580),
            "MMR: {}".format(seasondata["mmr"]),
            fill=(255, 255, 255, 255),
            font=name_fnt,
        )
        draw.text(
            (520, 640),
            "Max MMR: {}".format(seasondata["max_mmr"]),
            fill=(255, 255, 255, 255),
            font=name_fnt,
        )
        draw.text(
            (520, 700),
            "Previous Rank MMR: {}".format(seasondata["prev_rank_mmr"]),
            fill=(255, 255, 255, 255),
            font=name_fnt,
        )
        draw.text(
            (520, 760),
            "Next Rank MMR: {}".format(seasondata["next_rank_mmr"]),
            fill=(255, 255, 255, 255),
            font=name_fnt,
        )
        draw.text(
            (520, 820),
            "Rank: {}".format(seasondata["rank_text"]),
            fill=(255, 255, 255, 255),
            font=name_fnt,
        )
        if seasondata["rank_text"] == "Champions":
            draw.text(
                (960, 820),
                "Champion Rank Position: {}".format(
                    seasondata["champions_rank_position"]),
                fill=(255, 255, 255, 255),
                font=name_fnt,
            )
        draw.text(
            (520, 880),
            "Max Rank: {}".format(seasondata["max_rank_text"]),
            fill=(255, 255, 255, 255),
            font=name_fnt,
        )

        result = Image.alpha_composite(result, process)
        file = BytesIO()
        result.save(file, "png")
        file.name = f"season-{data.username}.png"
        file.seek(0)
        image = discord.File(file)
        return image
Exemple #9
0
    async def profilecreate(self, data):
        font_file = f"{bundled_data_path(self)}/fonts/RobotoRegular.ttf"
        bold_file = f"{bundled_data_path(self)}/fonts/RobotoBold.ttf"
        name_fnt = ImageFont.truetype(font_file, 42, encoding="utf-8")
        header_fnt = ImageFont.truetype(bold_file, 42, encoding="utf-8")
        operator = random.choice(self.bgs)

        bg_image = Image.open(
            f"{bundled_data_path(self)}/bg/{operator}.jpg").convert("RGBA")

        profile_image = Image

        profile_avatar = BytesIO()
        profile_url = data.avatar_url_256
        async with self.session.get(profile_url) as r:
            profile_img = await r.content.read()
            profile_avatar = BytesIO(profile_img)

        profile_image = Image.open(profile_avatar).convert("RGBA")

        # set canvas
        bg_color = (255, 255, 255, 0)
        result = Image.new("RGBA", (1280, 1080), bg_color)
        process = Image.new("RGBA", (1280, 1080), bg_color)

        # draw
        draw = ImageDraw.Draw(process)

        # puts in background
        bg_image = bg_image.resize((1920, 1090), Image.ANTIALIAS)
        bg_image = bg_image.crop((0, 0, 1920, 1080))
        result.paste(bg_image, (0, 0))

        aviholder = self.add_corners(
            Image.new("RGBA", (266, 266), (255, 255, 255, 255)), 10)
        process.paste(aviholder, (995, 15), aviholder)
        process.paste(profile_image, (1000, 20))

        # data
        draw.text(
            (
                self._center(
                    440,
                    1000,
                    "Name: {}".format(self._truncate_text(data.username, 18)),
                    header_fnt,
                ),
                40,
            ),
            "Name: {}".format(self._truncate_text(data.username, 18)),
            fill=(255, 255, 255, 255),
            font=header_fnt,
        )
        draw.text(
            (
                self._center(440, 1000, "Platform: {}".format(
                    str(data.platform).title()), header_fnt),
                90,
            ),
            "Platform: {}".format(str(data.platform).title()),
            fill=(255, 255, 255, 255),
            font=header_fnt,
        )
        draw.text(
            (self._center(440, 1000, "General Statistics", header_fnt), 140),
            "General Statistics",
            fill=(255, 255, 255, 255),
            font=header_fnt,
        )

        draw.text(
            (self._center(1000, 1256, f"Level: {data.level}",
                          header_fnt), 300),
            f"Level: {data.level}",
            fill=(255, 255, 255, 255),
            font=header_fnt,
        )
        draw.text(
            (520, 400),
            "Wins: {}".format(data.general_stats["wins"]),
            fill=(255, 255, 255, 255),
            font=name_fnt,
        )
        draw.text(
            (920, 400),
            "Losses: {}".format(data.general_stats["losses"]),
            fill=(255, 255, 255, 255),
            font=name_fnt,
        )
        draw.text(
            (520, 470),
            "Draws: {}".format(data.general_stats["draws"]),
            fill=(255, 255, 255, 255),
            font=name_fnt,
        )
        draw.text(
            (920, 470),
            "Total W/LR: {}%".format(
                round(
                    data.general_stats["wins"] /
                    data.general_stats["games_played"], 2) * 100),
            fill=(255, 255, 255, 255),
            font=name_fnt,
        )
        draw.text(
            (520, 540),
            "Lootbox %: {}%".format(data.lootbox_probability),
            fill=(255, 255, 255, 255),
            font=name_fnt,
        )
        draw.text(
            (520, 610),
            "Kills: {}".format(data.general_stats["kills"]),
            fill=(255, 255, 255, 255),
            font=name_fnt,
        )
        draw.text(
            (920, 610),
            "Deaths: {}".format(data.general_stats["deaths"]),
            fill=(255, 255, 255, 255),
            font=name_fnt,
        )
        draw.text(
            (520, 680),
            "Assists: {}".format(data.general_stats["assists"]),
            fill=(255, 255, 255, 255),
            font=name_fnt,
        )
        draw.text(
            (920, 680),
            "KDR: {}".format(data.general_stats["kd"]),
            fill=(255, 255, 255, 255),
            font=name_fnt,
        )
        draw.text(
            (520, 750),
            "Revives: {}".format(data.general_stats["revives"]),
            fill=(255, 255, 255, 255),
            font=name_fnt,
        )
        draw.text(
            (920, 750),
            "Suicides: {}".format(data.general_stats["suicides"]),
            fill=(255, 255, 255, 255),
            font=name_fnt,
        )
        draw.text(
            (520, 820),
            "Blind Kills: {}".format(data.general_stats["blind_kills"]),
            fill=(255, 255, 255, 255),
            font=name_fnt,
        )
        draw.text(
            (920, 820),
            "Melee Kills: {}".format(data.general_stats["melee_kills"]),
            fill=(255, 255, 255, 255),
            font=name_fnt,
        )
        draw.text(
            (520, 890),
            "Pentration Kills: {}".format(
                data.general_stats["penetration_kills"]),
            fill=(255, 255, 255, 255),
            font=name_fnt,
        )
        draw.text(
            (920, 890),
            "DBNOs: {}".format(data.general_stats["dbnos"]),
            fill=(255, 255, 255, 255),
            font=name_fnt,
        )

        m, _ = divmod(data.general_stats["playtime"], 60)
        h, m = divmod(m, 60)
        d, h = divmod(h, 24)
        draw.text(
            (520, 1010),
            f"Playtime: {d:d}d {h:d}h {m:02d}m",
            fill=(255, 255, 255, 255),
            font=name_fnt,
        )

        result = Image.alpha_composite(result, process)
        file = BytesIO()
        result.save(file, "png")
        file.name = f"general-{data.username}.png"
        file.seek(0)
        image = discord.File(file)
        return image
def plotBBoxes(image,
               bboxes,
               classes=None,
               scores=None,
               color='Chartreuse',
               linewidth=2,
               use_rgb=False):
    """Plot bounding boxes for given input objects

    Arguments:
    ----------
        image : numpy.array
            input image for drawing
        bboxes : list((x1, y1, x2, y2))
            input bounding boxes of objects to draw

    Keyword Arguments:
    ------------------
        classes : list(str) (default: None)
            list of classes for objects 
        color : str (default: `Chartreuse`) 
            color to plot
        linewidth : int (default: 2)
            how thick the shape is
        use_rgb : bool (default: False)
            whether using RGB image or not (apply for NDArray image)

    Returns:
    --------
        image : numpy.array
            output image after drawing
    """

    if len(bboxes) == 0:
        return image
        exit()

    if isinstance(image, np.ndarray):
        if not use_rgb:
            image = cv.cvtColor(image, cv.COLOR_BGR2RGB)
        image = Image.fromarray(image)

    W, H = image.size
    draw = ImageDraw.Draw(image)

    if classes is not None:
        font = ImageFont.truetype(font=cfg.FONT,
                                  size=np.floor(3e-2 * min(H, W) +
                                                0.5).astype('int32'))

        for i, ((x1, y1, x2, y2), cls) in enumerate(zip(bboxes, classes)):
            # draw bounding box
            draw.rectangle([x1, y1, x2, y2],
                           outline=ImageColor.getrgb(COLOR_MAP[cls]),
                           width=linewidth)
            # draw label
            text = cls
            if scores is not None:
                text = '{} {:.2f}'.format(cls, scores[i])

            label_size = draw.textsize(text, font)
            text_coor = np.array(
                [x1 + linewidth,
                 max(0, y1 - label_size[1] - 1)])
            rec_coor = np.array([x1, text_coor[1]])

            draw.rectangle([
                tuple(rec_coor),
                tuple(rec_coor + label_size + np.array([linewidth * 2, 0]))
            ],
                           fill=ImageColor.getrgb(COLOR_MAP[cls]))
            draw.text(text_coor,
                      text,
                      fill=ImageColor.getrgb('black'),
                      font=font)
    else:
        for i, (x1, y1, x2, y2) in enumerate(bboxes):
            draw.rectangle([x1, y1, x2, y2],
                           outline=ImageColor.getrgb(color),
                           width=linewidth)

    del draw
    return image
Exemple #11
0
    async def casualstatscreate(self, data):
        font_file = f"{bundled_data_path(self)}/fonts/RobotoRegular.ttf"
        bold_file = f"{bundled_data_path(self)}/fonts/RobotoBold.ttf"
        name_fnt = ImageFont.truetype(font_file, 42, encoding="utf-8")
        header_fnt = ImageFont.truetype(bold_file, 42, encoding="utf-8")
        operator = random.choice(self.bgs)

        bg_image = Image.open(
            f"{bundled_data_path(self)}/bg/{operator}.jpg").convert("RGBA")

        profile_image = Image

        profile_avatar = BytesIO()
        profile_url = data.avatar_url_256
        async with self.session.get(profile_url) as r:
            profile_img = await r.content.read()
            profile_avatar = BytesIO(profile_img)

        profile_image = Image.open(profile_avatar).convert("RGBA")

        # set canvas
        bg_color = (255, 255, 255, 0)
        result = Image.new("RGBA", (1280, 1080), bg_color)
        process = Image.new("RGBA", (1280, 1080), bg_color)

        # draw
        draw = ImageDraw.Draw(process)

        # puts in background
        bg_image = bg_image.resize((1920, 1090), Image.ANTIALIAS)
        bg_image = bg_image.crop((0, 0, 1920, 1080))
        result.paste(bg_image, (0, 0))

        aviholder = self.add_corners(
            Image.new("RGBA", (266, 266), (255, 255, 255, 255)), 10)
        process.paste(aviholder, (995, 15), aviholder)
        process.paste(profile_image, (1000, 20))

        # data
        # draw.text((440, 40), "Name: {}".format(self._truncate_text(data.username, 18)), fill=(255, 255, 255, 255), font=header_fnt)
        draw.text(
            (
                self._center(
                    440,
                    1000,
                    "Name: {}".format(self._truncate_text(data.username, 18)),
                    header_fnt,
                ),
                40,
            ),
            "Name: {}".format(self._truncate_text(data.username, 18)),
            fill=(255, 255, 255, 255),
            font=header_fnt,
        )
        draw.text(
            (
                self._center(440, 1000, "Platform: {}".format(
                    str(data.platform).title()), header_fnt),
                90,
            ),
            "Platform: {}".format(str(data.platform).title()),
            fill=(255, 255, 255, 255),
            font=header_fnt,
        )
        draw.text(
            (self._center(440, 1000, "Alltime Ranked Statistics",
                          header_fnt), 140),
            "Alltime Casual Statistics",
            fill=(255, 255, 255, 255),
            font=header_fnt,
        )

        draw.text(
            (self._center(1000, 1256, f"Level: {data.level}",
                          header_fnt), 300),
            f"Level: {data.level}",
            fill=(255, 255, 255, 255),
            font=header_fnt,
        )

        draw.text(
            (520, 400),
            "Games Played: {}".format(
                data.queue_stats["casual"]["games_played"]),
            fill=(255, 255, 255, 255),
            font=name_fnt,
        )
        draw.text(
            (520, 480),
            "Wins: {}".format(data.queue_stats["casual"]["wins"]),
            fill=(255, 255, 255, 255),
            font=name_fnt,
        )
        draw.text(
            (920, 480),
            "Losses: {}".format(data.queue_stats["casual"]["losses"]),
            fill=(255, 255, 255, 255),
            font=name_fnt,
        )
        draw.text(
            (520, 560),
            "Draws: {}".format(data.queue_stats["casual"]["draws"]),
            fill=(255, 255, 255, 255),
            font=name_fnt,
        )
        try:
            wlr = (round(
                data.queue_stats["casual"]["wins"] /
                data.queue_stats["casual"]["games_played"],
                2,
            ) * 100)
        except ZeroDivisionError:
            wlr = 0
        draw.text((520, 640),
                  "Total W/LR: {}%".format(wlr),
                  fill=(255, 255, 255, 255),
                  font=name_fnt)

        draw.text(
            (520, 800),
            "Kills: {}".format(data.queue_stats["casual"]["kills"]),
            fill=(255, 255, 255, 255),
            font=name_fnt,
        )
        draw.text(
            (920, 800),
            "Deaths: {}".format(data.queue_stats["casual"]["deaths"]),
            fill=(255, 255, 255, 255),
            font=name_fnt,
        )
        draw.text(
            (520, 880),
            "KDR: {}".format(data.queue_stats["casual"]["kd"]),
            fill=(255, 255, 255, 255),
            font=name_fnt,
        )

        m, _ = divmod(data.queue_stats["casual"]["playtime"], 60)
        h, m = divmod(m, 60)
        d, h = divmod(h, 24)
        draw.text(
            (520, 960),
            f"Playtime: {d:d}d {h:d}h {m:02d}m",
            fill=(255, 255, 255, 255),
            font=name_fnt,
        )

        result = Image.alpha_composite(result, process)
        file = BytesIO()
        result.save(file, "png")
        file.name = f"casual-{data.username}.png"
        file.seek(0)
        image = discord.File(file)
        return image
Exemple #12
0
def create_validate_code(size=(120, 30), chars=chars, mode="RGB", \
                         bg_color=(255, 255, 255), fg_color=(255, 0, 0), \
                         font_size=18, font_type="msyh.ttf", \
                         length=4, draw_points=True, point_chance = 2): 
    '''
    size: 图片的大小,格式(宽,高),默认为(120, 30)
    chars: 允许的字符集合,格式字符串
    mode: 图片模式,默认为RGB
    bg_color: 背景颜色,默认为白色
    fg_color: 前景色,验证码字符颜色
    font_size: 验证码字体大小
    font_type: 验证码字体,需要指定一个字体文件的路径
    length: 验证码字符个数
    draw_points: 是否画干扰点
    point_chance: 干扰点出现的概率,大小范围[0, 50]
    ''' 

    width, height = size
    img = Image.new(mode, size, bg_color)
    draw = ImageDraw.Draw(img)
 
    '''随机取出指定个数符串'''
    get_chars = lambda : random.sample(chars, length) 
 
    def create_points(): 
        '''绘制干扰点,遍历这个图片的所有点,根据概率决定时候加黑点点''' 
        chance = min(50, max(0, int(point_chance))) # 大小限制在[0, 50] 
 
        for w in xrange(width): 
            for h in xrange(height): 
                tmp = random.randint(0, 50) 
                if tmp > 50 - chance: 
                    draw.point((w, h), fill=(0, 0, 0))
 
    def create_strs():
        '''绘制验证码字符,验证码的主体''' 
        c_chars = get_chars() 
        strs = '%s' % ''.join(c_chars) 
 
        font = ImageFont.truetype(font_type, font_size) 
        font_width, font_height = font.getsize(strs) 
        
        #起码的一组参数是位置
        draw.text(((width - font_width) / 3, (height - font_height) / 4), 
                    strs, font=font, fill=fg_color) 
        return strs 
 
    if draw_points: 
        create_points()
    strs = create_strs() 
 
    #图形扭曲参数 
    params = [1 - float(random.randint(1, 2)) / 100, 0, 0, 0, 
              1 - float(random.randint(1, 10)) / 100, 
              float(random.randint(1, 2)) / 500, 0.001, 
              float(random.randint(1, 2)) / 500 ]

    img = img.transform(size, Image.PERSPECTIVE, params) # 创建扭曲
    img = img.filter(ImageFilter.EDGE_ENHANCE_MORE) # 滤镜,边界加强(阈值更大) 
    print strs 
    img.save("code1.jpg", "JPEG", quality=85)
Exemple #13
0
    def update_frame(self, frame):
        img = Image.fromarray(frame)
        draw = ImageDraw.Draw(img)

        # draw rectangle around the 5 first detected object with a score greater
        # than 60%
        if self.result_scores[0][0] > 0.60:
            y0 = int(self.get_object_location_y0(0) * frame.shape[0])
            x0 = int(self.get_object_location_x0(0) * frame.shape[1])
            y1 = int(self.get_object_location_y1(0) * frame.shape[0])
            x1 = int(self.get_object_location_x1(0) * frame.shape[1])
            label = self.get_label(0)
            accuracy = self.result_scores[0][0] * 100
            draw.rectangle([(x0, y0), (x1, y1)], outline=(0, 0, 255))
            draw.rectangle([(x0, y0),
                            (x0 +
                             ((len(label) + 4) * char_text_width), y0 + 14)],
                           (0, 0, 255))
            draw.text((x0 + 2, y0 + 2), label + " " + str(int(accuracy)) + "%",
                      (255, 255, 255))

        if self.result_scores[0][1] > 0.60:
            y0 = int(self.get_object_location_y0(1) * frame.shape[0])
            x0 = int(self.get_object_location_x0(1) * frame.shape[1])
            y1 = int(self.get_object_location_y1(1) * frame.shape[0])
            x1 = int(self.get_object_location_x1(1) * frame.shape[1])
            label = self.get_label(1)
            accuracy = self.result_scores[0][1] * 100
            draw.rectangle([(x0, y0), (x1, y1)], outline=(255, 0, 0))
            draw.rectangle([(x0, y0),
                            (x0 +
                             ((len(label) + 4) * char_text_width), y0 + 14)],
                           (255, 0, 0))
            draw.text((x0 + 2, y0 + 2), label + " " + str(int(accuracy)) + "%",
                      (255, 255, 255))

        if self.result_scores[0][2] > 0.60:
            y0 = int(self.get_object_location_y0(2) * frame.shape[0])
            x0 = int(self.get_object_location_x0(2) * frame.shape[1])
            y1 = int(self.get_object_location_y1(2) * frame.shape[0])
            x1 = int(self.get_object_location_x1(2) * frame.shape[1])
            label = self.get_label(2)
            accuracy = self.result_scores[0][2] * 100
            draw.rectangle([(x0, y0), (x1, y1)], outline=(0, 255, 0))
            draw.rectangle([(x0, y0),
                            (x0 +
                             ((len(label) + 4) * char_text_width), y0 + 14)],
                           (0, 255, 0))
            draw.text((x0 + 2, y0 + 2), label + " " + str(int(accuracy)) + "%",
                      (255, 255, 255))

        if self.result_scores[0][3] > 0.60:
            y0 = int(self.get_object_location_y0(3) * frame.shape[0])
            x0 = int(self.get_object_location_x0(3) * frame.shape[1])
            y1 = int(self.get_object_location_y1(3) * frame.shape[0])
            x1 = int(self.get_object_location_x1(3) * frame.shape[1])
            label = self.get_label(3)
            accuracy = self.result_scores[0][3] * 100
            draw.rectangle([(x0, y0), (x1, y1)], outline=(255, 255, 0))
            draw.rectangle([(x0, y0),
                            (x0 +
                             ((len(label) + 4) * char_text_width), y0 + 14)],
                           (255, 255, 0))
            draw.text((x0 + 2, y0 + 2), label + " " + str(int(accuracy)) + "%",
                      (255, 255, 255))

        if self.result_scores[0][4] > 0.60:
            y0 = int(self.get_object_location_y0(4) * frame.shape[0])
            x0 = int(self.get_object_location_x0(4) * frame.shape[1])
            y1 = int(self.get_object_location_y1(4) * frame.shape[0])
            x1 = int(self.get_object_location_x1(4) * frame.shape[1])
            label = self.get_label(4)
            accuracy = self.result_scores[0][4] * 100
            draw.rectangle([(x0, y0), (x1, y1)], outline=(0, 255, 255))
            draw.rectangle([(x0, y0),
                            (x0 +
                             ((len(label) + 4) * char_text_width), y0 + 14)],
                           (0, 255, 255))
            draw.text((x0 + 2, y0 + 2), label + " " + str(int(accuracy)) + "%",
                      (255, 255, 255))

        data = img.tobytes()
        data = GLib.Bytes.new(data)
        pixbuf = GdkPixbuf.Pixbuf.new_from_bytes(
            data, GdkPixbuf.Colorspace.RGB, False, 8, frame.shape[1],
            frame.shape[0], frame.shape[2] * frame.shape[1])
        self.image.set_from_pixbuf(pixbuf.copy())
Exemple #14
0
    def compute_matches(self,
                        set_number,
                        seq_number,
                        frame_number,
                        guess_pos,
                        guess_scores,
                        original_image=False,
                        display_image=False):
        self.load_annotations()  # Will be needed

        if CaltechDataset.USE_CROPPING:
            if display_image:
                if original_image:
                    image = Image.open(
                        self.dataset_location +
                        '/images/set{:02d}/V{:03d}.seq/{}.jpg'.format(
                            set_number, seq_number, frame_number))
                else:
                    image = Image.open(
                        self.dataset_location +
                        '/images-cropped/set{:02d}/V{:03d}.seq/{}.jpg'.format(
                            set_number, seq_number, frame_number))
            transform = np.load(
                self.dataset_location +
                '/images-cropped/set{:02d}/V{:03d}.seq/{}.transform.npy'.
                format(set_number, seq_number, frame_number))
        elif display_image:
            image = Image.open(self.dataset_location +
                               '/images/set{:02d}/V{:03d}.seq/{}.jpg'.format(
                                   set_number, seq_number, frame_number))

        if display_image:
            dr = ImageDraw.Draw(image)

        # Retrieve objects for that frame in annotations
        try:
            objects = self.annotations['set{:02d}'.format(set_number)][
                'V{:03d}'.format(seq_number)]['frames']['{}'.format(
                    frame_number)]
        except KeyError as e:
            objects = None  # Simply no objects for that frame

        # We attempt to mimic the reasonable test set
        # i.e. 50 pixels or taller, no occlusion (not even partial)
        persons = []
        undesirables = []
        if objects:
            for o in objects:
                good = False
                pos = (o['pos'][1], o['pos'][0], o['pos'][3], o['pos'][2]
                       )  # Convert to (y, x, h, w)
                if CaltechDataset.USE_CROPPING and not original_image:
                    pos = transform_cropped_pos(pos, transform)

                if o['lbl'] in ['person']:
                    good = True

                    # 50 pixels or taller
                    if pos[2] < 50:
                        good = False

                    if o['occl'] == 1:
                        good = False

                if good:
                    persons.append(pos)
                    if display_image:
                        dr.rectangle(
                            (pos[1], pos[0], pos[1] + pos[3], pos[0] + pos[2]),
                            outline='blue')
                else:
                    undesirables.append(pos)
                    if display_image:
                        dr.rectangle(
                            (pos[1], pos[0], pos[1] + pos[3], pos[0] + pos[2]),
                            outline='pink')

        # Move data to numpy
        persons = np.array(persons, dtype=np.float32)
        undesirables = np.array(undesirables, dtype=np.float32)

        # Sort guesses
        index = np.argsort(
            guess_scores[:])[::-1]  # Decreasing order with [::-1]
        guess_pos = guess_pos[index]
        guess_scores = guess_scores[index]

        default_false_positives = 0
        guess_matched = np.zeros(guess_scores.shape, dtype=np.bool)

        for row in range(guess_pos.shape[0]):
            pos = guess_pos[row]
            if CaltechDataset.USE_CROPPING and original_image:
                pos = untransform_cropped_pos(pos, transform)

            # Try matching
            matched = False
            if persons.shape[0] > 0:
                for r in range(persons.shape[0]):
                    if IoU(pos, persons[r]) > 0.5:
                        matched = True
                        persons = np.delete(persons, r, 0)
                        break

            if matched:
                guess_matched[row] = True
                if display_image:
                    dr.rectangle(
                        (pos[1], pos[0], pos[1] + pos[3], pos[0] + pos[2]),
                        outline='green')
            else:
                if undesirables.shape[0] > 0:
                    for r in range(undesirables.shape[0]):
                        if IoA(pos, undesirables[r]) > 0.5:
                            matched = True
                            break

                if not matched:
                    default_false_positives += 1
                    if display_image:
                        dr.rectangle(
                            (pos[1], pos[0], pos[1] + pos[3], pos[0] + pos[2]),
                            outline='red')
                elif display_image:
                    dr.rectangle(
                        (pos[1], pos[0], pos[1] + pos[3], pos[0] + pos[2]),
                        outline='yellow')

            if display_image:
                dr.text((pos[1], pos[0]), '{:.3f}'.format(guess_scores[row]))

        # Sorted scores of all matches made for computing curves
        matched_scores = guess_scores[guess_matched]
        default = np.array([default_false_positives, persons.shape[0]])

        if display_image:
            image.show()

        return matched_scores, default
Exemple #15
0
def interface():
    #Initialisation
    pygame.init()
    base, label, distance_matrix = init()

    #Création de la fenêtre
    window = pygame.display.set_mode((560, 340), pygame.RESIZABLE)

    #chargement et application de la zone de dessin et des boutons
    draw = pygame.image.load("vide.png").convert()
    validate = pygame.image.load("valider.png").convert()
    cancel = pygame.image.load("annuler.png").convert()
    b0 = pygame.image.load("0.png").convert()
    b1 = pygame.image.load("1.png").convert()
    b2 = pygame.image.load("2.png").convert()
    b3 = pygame.image.load("3.png").convert()
    b4 = pygame.image.load("4.png").convert()
    b5 = pygame.image.load("5.png").convert()
    b6 = pygame.image.load("6.png").convert()
    b7 = pygame.image.load("7.png").convert()
    b8 = pygame.image.load("8.png").convert()
    b9 = pygame.image.load("9.png").convert()
    blearn = pygame.image.load("?.png").convert()
    black = pygame.image.load("noir.png").convert()
    bRM = pygame.image.load("ADD.png").convert()
    window.blit(draw, (10, 10))
    window.blit(cancel, (120, 10))
    window.blit(validate, (230, 10))
    window.blit(bRM, (450, 10))
    window.blit(b0, (10, 120))
    window.blit(b1, (120, 120))
    window.blit(b2, (230, 120))
    window.blit(b3, (340, 120))
    window.blit(b4, (450, 120))
    window.blit(b5, (10, 230))
    window.blit(b6, (120, 230))
    window.blit(b7, (230, 230))
    window.blit(b8, (340, 230))
    window.blit(b9, (450, 230))

    #création de l'image destination et mise en blanc
    picture = Image.new("RGB", (100, 100))
    initPicture(picture)
    draw_img = ImageDraw.Draw(picture)

    #Raffraichissement de la fenêtre
    pygame.display.flip()

    learn = 0
    continuer = 1

    # saving the last px used for smoothing
    last_x = 0
    last_y = 0

    while continuer:
        for event in pygame.event.get():
            #gestion de la fermeture de la fenêtre
            if event.type == QUIT:
                close(base, label, distance_matrix)
                continuer = 0
                pygame.quit()


            if event.type == MOUSEBUTTONDOWN and event.button == 1 and \
            event.pos[0] > 11 and event.pos[0] < 109 and \
            event.pos[1] > 11 and event.pos[1] < 109 :
                last_x = event.pos[0]
                last_y = event.pos[1]

            #gestion du dessin
            if event.type == MOUSEMOTION and event.buttons[0] == 1 and \
            event.pos[0] > 11 and event.pos[0] < 109 and \
            event.pos[1] > 11 and event.pos[1] < 109 :
                learn = 1
                new_x = event.pos[0]
                new_y = event.pos[1]

                window.blit(black, (340, 10))

                draw_img.line(
                    (last_x - 10, last_y - 10, new_x - 10, new_y - 10),
                    fill='black',
                    width=5)
                last_x = new_x
                last_y = new_y
                #drawPixel(picture,event.pos[0]-10,event.pos[1]-10)
                picture.save("temp.png")
                draw = pygame.image.load("temp.png").convert()
                window.blit(draw, (10, 10))
                pygame.display.flip()

            #gestion du boulon annuler
            if event.type == MOUSEBUTTONDOWN and event.button == 1 and \
            event.pos[0] > 121 and event.pos[0] < 219 and \
            event.pos[1] > 11 and event.pos[1] < 109 :
                learn = 0
                initPicture(picture)
                picture.save("temp.png")
                draw = pygame.image.load("temp.png").convert()
                window.blit(draw, (10, 10))
                window.blit(black, (340, 10))
                pygame.display.flip()

            #gestion du bouton RM
            if event.type == MOUSEBUTTONDOWN and event.button == 1 and \
            event.pos[0] > 451 and event.pos[0] < 549 and \
            event.pos[1] > 11 and event.pos[1] < 109 :
                learn = 1
                window.blit(blearn, (340, 10))
                pygame.display.flip()

            #gestion du bouton valider
            if event.type == MOUSEBUTTONDOWN and event.button == 1 and \
            event.pos[0] > 231 and event.pos[0] < 329 and \
            event.pos[1] > 11 and event.pos[1] < 109 and learn == 1 :
                picture.save("new.png")

                #ouverture du fichier source
                new_picture = Image.open("new.png")
                word = picture2word(new_picture)

                digit = analyse.analyse_triangle_knn_multi(
                    word, base, label, distance_matrix, 3)

                word2 = None
                if (zoomout("new.png", "new2.png")):
                    new_picture2 = Image.open("new2.png")
                    word2 = picture2word(new_picture2)
                    digit2 = analyse.analyse_triangle_knn_multi(
                        word2, base, label, distance_matrix, 3)

                if digit == 0:
                    window.blit(b0, (340, 10))
                elif digit == 1:
                    window.blit(b1, (340, 10))
                elif digit == 2:
                    window.blit(b2, (340, 10))
                elif digit == 3:
                    window.blit(b3, (340, 10))
                elif digit == 4:
                    window.blit(b4, (340, 10))
                elif digit == 5:
                    window.blit(b5, (340, 10))
                elif digit == 6:
                    window.blit(b6, (340, 10))
                elif digit == 7:
                    window.blit(b7, (340, 10))
                elif digit == 8:
                    window.blit(b8, (340, 10))
                elif digit == 9:
                    window.blit(b9, (340, 10))
                else:
                    window.blit(blearn, (340, 10))


#                if digit != -1 :
#                    learn = 2
#                    base[digit].append(word)

#                if learn == 1 :
#                    window.blit(blearn, (340,10))
#                else :
#                    initPicture(picture)
#                    picture.save("temp.png")
#                    draw = pygame.image.load("temp.png").convert()
#                    window.blit(draw, (10,10))
                pygame.display.flip()

            #gestion des boutons chiffres
            if event.type == MOUSEBUTTONDOWN and event.button == 1 and \
            event.pos[0] > 11 and event.pos[0] < 109 and \
            event.pos[1] > 121 and event.pos[1] < 219 and learn == 1 :
                base.append(word)
                label.append(0)
                distance_matrix = update_matrix(base, distance_matrix, word)
                if (word2 != None):
                    base.append(word2)
                    label.append(0)
                    distance_matrix = update_matrix(base, distance_matrix,
                                                    word2)
                learn = 0
                initPicture(picture)
                picture.save("temp.png")
                draw = pygame.image.load("temp.png").convert()
                window.blit(draw, (10, 10))
                window.blit(black, (340, 10))
                pygame.display.flip()
            if event.type == MOUSEBUTTONDOWN and event.button == 1 and \
            event.pos[0] > 121 and event.pos[0] < 219 and \
            event.pos[1] > 121 and event.pos[1] < 219 and learn == 1 :
                base.append(word)
                label.append(1)
                distance_matrix = update_matrix(base, distance_matrix, word)
                if (word2 != None):
                    base.append(word2)
                    label.append(1)
                    distance_matrix = update_matrix(base, distance_matrix,
                                                    word2)
                learn = 0
                initPicture(picture)
                picture.save("temp.png")
                draw = pygame.image.load("temp.png").convert()
                window.blit(draw, (10, 10))
                window.blit(black, (340, 10))
                pygame.display.flip()
            if event.type == MOUSEBUTTONDOWN and event.button == 1 and \
            event.pos[0] > 231 and event.pos[0] < 329 and \
            event.pos[1] > 121 and event.pos[1] < 219 and learn == 1 :
                base.append(word)
                label.append(2)
                distance_matrix = update_matrix(base, distance_matrix, word)
                if (word2 != None):
                    base.append(word2)
                    label.append(2)
                    distance_matrix = update_matrix(base, distance_matrix,
                                                    word2)
                learn = 0
                initPicture(picture)
                picture.save("temp.png")
                draw = pygame.image.load("temp.png").convert()
                window.blit(draw, (10, 10))
                window.blit(black, (340, 10))
                pygame.display.flip()
            if event.type == MOUSEBUTTONDOWN and event.button == 1 and \
            event.pos[0] > 341 and event.pos[0] < 439 and \
            event.pos[1] > 121 and event.pos[1] < 219 and learn == 1:
                base.append(word)
                label.append(3)
                distance_matrix = update_matrix(base, distance_matrix, word)
                if (word2 != None):
                    base.append(word2)
                    label.append(3)
                    distance_matrix = update_matrix(base, distance_matrix,
                                                    word2)
                learn = 0
                initPicture(picture)
                picture.save("temp.png")
                draw = pygame.image.load("temp.png").convert()
                window.blit(draw, (10, 10))
                window.blit(black, (340, 10))
                pygame.display.flip()
            if event.type == MOUSEBUTTONDOWN and event.button == 1 and \
            event.pos[0] > 451 and event.pos[0] < 549 and \
            event.pos[1] > 121 and event.pos[1] < 219 and learn == 1 :
                base.append(word)
                label.append(4)
                distance_matrix = update_matrix(base, distance_matrix, word)
                if (word2 != None):
                    base.append(word2)
                    label.append(4)
                    distance_matrix = update_matrix(base, distance_matrix,
                                                    word2)
                learn = 0
                initPicture(picture)
                picture.save("temp.png")
                draw = pygame.image.load("temp.png").convert()
                window.blit(draw, (10, 10))
                window.blit(black, (340, 10))
                pygame.display.flip()
            if event.type == MOUSEBUTTONDOWN and event.button == 1 and \
            event.pos[0] > 11 and event.pos[0] < 109 and \
            event.pos[1] > 231 and event.pos[1] < 329 and learn == 1 :
                base.append(word)
                label.append(5)
                distance_matrix = update_matrix(base, distance_matrix, word)
                if (word2 != None):
                    base.append(word2)
                    label.append(5)
                    distance_matrix = update_matrix(base, distance_matrix,
                                                    word2)
                learn = 0
                initPicture(picture)
                picture.save("temp.png")
                draw = pygame.image.load("temp.png").convert()
                window.blit(draw, (10, 10))
                window.blit(black, (340, 10))
                pygame.display.flip()
            if event.type == MOUSEBUTTONDOWN and event.button == 1 and \
            event.pos[0] > 121 and event.pos[0] < 219 and \
            event.pos[1] > 231 and event.pos[1] < 329 and learn == 1 :
                base.append(word)
                label.append(6)
                distance_matrix = update_matrix(base, distance_matrix, word)
                if (word2 != None):
                    base.append(word2)
                    label.append(6)
                    distance_matrix = update_matrix(base, distance_matrix,
                                                    word2)
                learn = 0
                initPicture(picture)
                picture.save("temp.png")
                draw = pygame.image.load("temp.png").convert()
                window.blit(draw, (10, 10))
                window.blit(black, (340, 10))
                pygame.display.flip()
            if event.type == MOUSEBUTTONDOWN and event.button == 1 and \
            event.pos[0] > 231 and event.pos[0] < 329 and \
            event.pos[1] > 231 and event.pos[1] < 329 and learn == 1 :
                base.append(word)
                label.append(7)
                distance_matrix = update_matrix(base, distance_matrix, word)
                if (word2 != None):
                    base.append(word2)
                    label.append(7)
                    distance_matrix = update_matrix(base, distance_matrix,
                                                    word2)
                learn = 0
                initPicture(picture)
                picture.save("temp.png")
                draw = pygame.image.load("temp.png").convert()
                window.blit(draw, (10, 10))
                window.blit(black, (340, 10))
                pygame.display.flip()
            if event.type == MOUSEBUTTONDOWN and event.button == 1 and \
            event.pos[0] > 341 and event.pos[0] < 439 and \
            event.pos[1] > 231 and event.pos[1] < 329 and learn == 1 :
                base.append(word)
                label.append(8)
                distance_matrix = update_matrix(base, distance_matrix, word)
                if (word2 != None):
                    base.append(word2)
                    label.append(8)
                    distance_matrix = update_matrix(base, distance_matrix,
                                                    word2)
                learn = 0
                initPicture(picture)
                picture.save("temp.png")
                draw = pygame.image.load("temp.png").convert()
                window.blit(draw, (10, 10))
                window.blit(black, (340, 10))
                pygame.display.flip()
            if event.type == MOUSEBUTTONDOWN and event.button == 1 and \
            event.pos[0] > 451 and event.pos[0] < 549 and \
            event.pos[1] > 231 and event.pos[1] < 329 and learn == 1 :
                base.append(word)
                label.append(9)
                distance_matrix = update_matrix(base, distance_matrix, word)
                if (word2 != None):
                    base.append(word2)
                    label.append(9)
                    distance_matrix = update_matrix(base, distance_matrix,
                                                    word2)
                learn = 0
                initPicture(picture)
                picture.save("temp.png")
                draw = pygame.image.load("temp.png").convert()
                window.blit(draw, (10, 10))
                window.blit(black, (340, 10))
                pygame.display.flip()
Exemple #16
0
    async def operatorstatscreate(self, data, index, profile):
        font_file = f"{bundled_data_path(self)}/fonts/RobotoRegular.ttf"
        bold_file = f"{bundled_data_path(self)}/fonts/RobotoBold.ttf"
        name_fnt = ImageFont.truetype(font_file, 42, encoding="utf-8")
        header_fnt = ImageFont.truetype(bold_file, 42, encoding="utf-8")
        operator = random.choice(self.bgs)
        opdata = data.operators[index]

        bg_image = Image.open(
            f"{bundled_data_path(self)}/bg/{operator}.jpg").convert("RGBA")

        profile_image = Image

        profile_avatar = BytesIO()
        profile_url = data.avatar_url_256
        async with self.session.get(profile_url) as r:
            profile_img = await r.content.read()
            profile_avatar = BytesIO(profile_img)

        profile_image = Image.open(profile_avatar).convert("RGBA")

        # set canvas
        bg_color = (255, 255, 255, 0)
        result = Image.new("RGBA", (1600, 1080), bg_color)
        process = Image.new("RGBA", (1600, 1080), bg_color)

        # draw
        draw = ImageDraw.Draw(process)

        # puts in background
        bg_image = bg_image.resize((1920, 1090), Image.ANTIALIAS)
        bg_image = bg_image.crop((0, 0, 1920, 1080))
        result.paste(bg_image, (0, 0))

        aviholder = self.add_corners(
            Image.new("RGBA", (266, 266), (255, 255, 255, 255)), 10)
        process.paste(aviholder, (1295, 15), aviholder)
        process.paste(profile_image, (1300, 20))

        # op badge
        url = opdata["badge_image"]
        process.paste(aviholder, (995, 15), aviholder)
        im = Image.open(BytesIO(await self.getimg(url)))
        im = im.resize((256, 256), Image.ANTIALIAS)
        process.paste(im, (1000, 20))

        # data
        # draw.text((440, 40), "Name: {}".format(self._truncate_text(data.username, 18)), fill=(255, 255, 255, 255), font=header_fnt)
        draw.text(
            (
                self._center(
                    440,
                    1000,
                    "Name: {}".format(self._truncate_text(data.username, 18)),
                    header_fnt,
                ),
                40,
            ),
            "Name: {}".format(self._truncate_text(data.username, 18)),
            fill=(255, 255, 255, 255),
            font=header_fnt,
        )
        draw.text(
            (
                self._center(440, 1000, "Platform: {}".format(
                    str(data.platform).title()), header_fnt),
                90,
            ),
            "Platform: {}".format(str(data.platform).title()),
            fill=(255, 255, 255, 255),
            font=header_fnt,
        )
        draw.text(
            (self._center(440, 1000, f"{opdata['name']} Statistics",
                          header_fnt), 140),
            f"{opdata['name']} Statistics",
            fill=(255, 255, 255, 255),
            font=header_fnt,
        )

        draw.text(
            (520, 320),
            "Games Played: {}".format(opdata["wins"] + opdata["losses"]),
            fill=(255, 255, 255, 255),
            font=name_fnt,
        )
        draw.text((520, 380),
                  "Wins: {}".format(opdata["wins"]),
                  fill=(255, 255, 255, 255),
                  font=name_fnt)
        draw.text(
            (920, 380),
            "Losses: {}".format(opdata["losses"]),
            fill=(255, 255, 255, 255),
            font=name_fnt,
        )
        try:
            wlr = round(opdata["wins"] / (opdata["wins"] + opdata["losses"]),
                        2)
        except ZeroDivisionError:
            wlr = 0
        draw.text(
            (520, 440),
            "Total W/LR: {}%".format(wlr * 100),
            fill=(255, 255, 255, 255),
            font=name_fnt,
        )

        draw.text(
            (520, 520),
            "Kills: {}".format(opdata["kills"]),
            fill=(255, 255, 255, 255),
            font=name_fnt,
        )
        draw.text(
            (920, 520),
            "Deaths: {}".format(opdata["deaths"]),
            fill=(255, 255, 255, 255),
            font=name_fnt,
        )
        draw.text((520, 580),
                  "KDR: {}".format(opdata["kd"]),
                  fill=(255, 255, 255, 255),
                  font=name_fnt)
        draw.text(
            (520, 640),
            "Headshots: {}".format(opdata["headshots"]),
            fill=(255, 255, 255, 255),
            font=name_fnt,
        )
        y = 760
        for ability in opdata["abilities"]:

            draw.text(
                (520, y),
                "{}: {}".format(ability["ability"], ability["value"]),
                fill=(255, 255, 255, 255),
                font=name_fnt,
            )
            y += 80

        m, _ = divmod(opdata["playtime"], 60)
        h, m = divmod(m, 60)
        d, h = divmod(h, 24)
        draw.text(
            (520, 700),
            f"Playtime: {d:d}d {h:d}h {m:02d}m",
            fill=(255, 255, 255, 255),
            font=name_fnt,
        )

        result = Image.alpha_composite(result, process)
        result = result.crop((500, 0, 1600, 1080))
        file = BytesIO()
        result.save(file, "png")
        file.name = f"operator-{data.username}.png"
        file.seek(0)
        image = discord.File(file)
        return image
# http://www.pythonchallenge.com/pc/hex/copper.html
# Page source says 'or maybe white.gif would be more bright'

from PIL import Image, ImageDraw

# white.gif downloaded from http://www.pythonchallenge.com/pc/hex/white.gif
# white.gif is almost all black, with 1 pixel with (8, 8, 8)
# Only 1 pixel has different color
# The pixel is moving in the white.gif
# Need to emulate the joystick
img = Image.open('./resource/white.gif')
# Variable to store new image
new = Image.new('RGB', (500, 200))
draw = ImageDraw.Draw(new)
# Set first point to start at the edge of image
cx, cy = 0, 100
# Read all frames in white.gif
for frame in range(img.n_frames):
    # Get frame
    img.seek(frame)
    # getbbox() get black box boundary
    left, upper, right, lower = img.getbbox()

    # Calculates the position of the non-black pixel
    # Set movement direction accordingly
    dx = left - 100
    dy = upper - 100

    # If black pixel is reset to original position
    # Move cursor 50 pixels to the right for more space
    if dx == dy == 0:
Exemple #18
0
 def round_corner(self, radius):
     """Draw a round corner"""
     corner = Image.new("L", (radius, radius), 0)
     draw = ImageDraw.Draw(corner)
     draw.pieslice((0, 0, radius * 2, radius * 2), 180, 270, fill=255)
     return corner
Exemple #19
0
def show_image_analysis(image_path, analysis):
    import matplotlib.pyplot as plt
    from PIL import Image, ImageDraw
    import numpy as np

    # Display the image
    fig = plt.figure(figsize=(16, 8))
    a = fig.add_subplot(1, 2, 1)
    img = Image.open(image_path)

    # Get the caption
    caption_text = ''
    if (len(analysis.description.captions) == 0):
        caption_text = 'No caption detected'
    else:
        for caption in analysis.description.captions:
            caption_text = caption_text + " '{}'\n(Confidence: {:.2f}%)".format(
                caption.text, caption.confidence * 100)
    plt.title(caption_text)

    # Get objects
    if analysis.objects:
        # Draw a rectangle around each object
        for object in analysis.objects:
            r = object.rectangle
            bounding_box = ((r.x, r.y), (r.x + r.w, r.y + r.h))
            draw = ImageDraw.Draw(img)
            draw.rectangle(bounding_box, outline='magenta', width=5)
            plt.annotate(object.object_property, (r.x, r.y),
                         backgroundcolor='magenta')

    # Get faces
    if analysis.faces:
        # Draw a rectangle around each face
        for face in analysis.faces:
            r = face.face_rectangle
            bounding_box = ((r.left, r.top), (r.left + r.width,
                                              r.top + r.height))
            draw = ImageDraw.Draw(img)
            draw.rectangle(bounding_box, outline='lightgreen', width=5)
            annotation = 'Person aged approxilately {}'.format(face.age)
            plt.annotate(annotation, (r.left, r.top),
                         backgroundcolor='lightgreen')

    plt.axis('off')
    plt.imshow(img)

    # Add a second plot for addition details
    a = fig.add_subplot(1, 2, 2)

    # Get ratings
    ratings = 'Ratings:\n - Adult: {}\n - Racy: {}\n - Gore: {}'.format(
        analysis.adult.is_adult_content,
        analysis.adult.is_racy_content,
        analysis.adult.is_gory_content,
    )

    # Get tags
    tags = 'Tags:'
    for tag in analysis.tags:
        tags = tags + '\n - {}'.format(tag.name)

    # Print details

    details = '{}\n\n{}'.format(ratings, tags)
    a.text(0, 0.4, details, fontsize=12)
    plt.axis('off')
    plt.show()
Exemple #20
0
def draw_status_pie(status_totals: Counter, avatar_fp: Optional[BytesIO], *, show_totals: bool = True) -> BytesIO:

    image, draw = base_image()

    # Make pie max size if no totals
    if not show_totals:
        pie_size = IMAGE_SIZE
        pie_offset = (0,) * 2
    else:
        pie_size = int(IMAGE_SIZE * 0.66)
        pie_offset = (0, (IMAGE_SIZE - pie_size) // 2)

    # Draw status pie
    pie_0 = add((0,) * 2, pie_offset)
    pie_1 = add((pie_size,) * 2, pie_offset)

    degrees = 270.0
    for status, percentage in status_totals.most_common():
        start = degrees
        degrees += 360 * percentage
        draw.pieslice((pie_0, pie_1), start, degrees, fill=COLOURS[status])

    if avatar_fp is not None:
        # Load avatar image
        avatar = Image.open(avatar_fp)
        if avatar.mode != 'RGBA':
            avatar = avatar.convert('RGBA')
        avatar = avatar.resize((int(pie_size // 1.5),) * 2, resample=Image.LANCZOS)

        # Apply circular mask to image
        _, _, _, alpha = avatar.split()
        if alpha.mode != 'L':
            alpha = alpha.convert('L')

        mask = Image.new('L', avatar.size, 0)
        draw = ImageDraw.Draw(mask)
        draw.ellipse((0, 0) + avatar.size, fill=255)

        mask = ImageChops.darker(mask, alpha)
        avatar.putalpha(mask)

        # Overlay avatar
        image.paste(avatar, add((pie_size // 6,) * 2, pie_offset), avatar)

    # Add status percentages
    if show_totals:
        draw = ImageDraw.Draw(image)
        font = ImageFont.truetype('res/roboto-bold.ttf', IMAGE_SIZE // 20)

        x_offset = IMAGE_SIZE // 4 * 3
        y_offset = IMAGE_SIZE // 3
        circle_size = (IMAGE_SIZE // 30,) * 2

        for status, percentage in status_totals.most_common():
            offset = (x_offset, y_offset)

            draw.ellipse(offset + add(offset, circle_size), fill=COLOURS[status])
            draw.text((x_offset + IMAGE_SIZE // 20, y_offset - IMAGE_SIZE // 60), f'{percentage:.2%}', font=font, align='left', fill=WHITE)

            y_offset += IMAGE_SIZE // 8

    return as_bytes(resample(image))
Exemple #21
0
from PIL import Image, ImageDraw

# Image size (pixels)
WIDTH = 36000
HEIGHT = 24000

# Plot window
RE_START = -2
RE_END = 1
IM_START = -1
IM_END = 1

palette = []

im = Image.new('RGB', (WIDTH, HEIGHT), (0, 0, 0))
draw = ImageDraw.Draw(im)

im = Image.new('RGB', (WIDTH, HEIGHT), (0, 0, 0))
draw = ImageDraw.Draw(im)

for x in range(0, WIDTH):
    for y in range(0, HEIGHT):
        # Convert pixel coordinate to complex number
        c = complex(RE_START + (x / WIDTH) * (RE_END - RE_START),
                    IM_START + (y / HEIGHT) * (IM_END - IM_START))
        # Compute the number of iterations
        m = mandelbrot(c)
        # The color depends on the number of iterations
        color = 255 - int(m * 255 / MAX_ITER)
        # Plot the point
        draw.point([x, y], (color, color, color))
Exemple #22
0
def draw_status_log(status_log: List[LogEntry], *, timezone: datetime.timezone =
                    datetime.timezone.utc, show_labels: bool = False, num_days: int = 30) -> BytesIO:

    row_count = 1 + num_days + show_labels
    image, draw = base_image(IMAGE_SIZE * row_count, 1)

    # Set consts
    day_width = IMAGE_SIZE / (60 * 60 * 24)
    day_height = IMAGE_SIZE // row_count

    now = datetime.datetime.now(timezone)
    time_offset = now.utcoffset().total_seconds()  # type: ignore
    total_duration = 0.0

    if show_labels:
        time_offset += 60 * 60 * 24

    # Draw status log entries
    for status, _, timespan in status_log:
        duration: float = timespan.total_seconds()
        total_duration += duration
        new_time_offset = time_offset + duration

        start_x = round(time_offset * day_width)
        end_x = round(new_time_offset * day_width)
        draw.rectangle(((start_x, 0), (end_x, 1)), fill=COLOURS[status])

        time_offset = new_time_offset

    # Reshape Image
    pixels = numpy.array(image)
    # pixels = pixels[:, IMAGE_SIZE:]
    pixels = pixels.reshape(row_count, IMAGE_SIZE, 4)
    pixels = pixels.repeat(day_height, 0)
    image = Image.fromarray(pixels, 'RGBA')

    if show_labels:
        overlay = Image.new('RGBA', image.size, (0, 0, 0, 0))
        draw = ImageDraw.Draw(overlay)

        # Set offsets based on font size
        font = ImageFont.truetype('res/roboto-bold.ttf', IMAGE_SIZE // int(1.66 * num_days))
        text_width, text_height = draw.textsize('\N{FULL BLOCK}' * 2, font=font)
        height_offset = (day_height - text_height) // 2

        x_offset = text_width
        y_offset = day_height

        # Add date labels
        date = now - datetime.timedelta(seconds=total_duration)
        for _ in range(int(total_duration // ONE_DAY) + 2):  # 2 because of timezone offset woes

            # if weekend draw signifier
            if date.weekday() == 5:
                draw.rectangle((0, y_offset, IMAGE_SIZE, y_offset + (2 * day_height)), fill=TRANSLUCENT)

            # Add date
            _, text_height = draw.textsize(date.strftime('%b. %d'), font=font)
            draw.text((x_offset, y_offset + height_offset), date.strftime('%b. %d'), font=font, align='left', fill=WHITE)
            y_offset += day_height
            date += datetime.timedelta(days=1)

        # Add timezone label
        draw.text((x_offset, height_offset), str(timezone), font=font, align='left', fill='WHITE')

        # Add hour lines
        for i in range(1, 24):
            x_offset = ONE_HOUR * i
            colour = WHITE if not i % 6 else OPAQUE
            draw.line((x_offset, day_height, x_offset, IMAGE_SIZE), fill=colour, width=DOWNSAMPLE * 4)

        image = Image.alpha_composite(image, overlay)
        draw = ImageDraw.Draw(image)

        # Add time labels
        time = start_of_day(now)
        for x_offset in (ONE_HOUR * 6, ONE_HOUR * 12, ONE_HOUR * 18):
            time += datetime.timedelta(hours=6)
            text_width, _ = draw.textsize(time.strftime('%H:00'), font=font)
            draw.text((x_offset - (text_width // 2), height_offset), time.strftime('%H:00'), font=font, align='left', fill=WHITE)

    return as_bytes(resample(image))
def SavePILText(strAPODFileName):

    #use isfile logic to only create new ones, True to recreate them all
    if not os.path.isfile(strAPODPicsWithText + strAPODFileName):  #True:
        print "Building Image With Text"

        #strAPODDataFolder + strAPODFileName.replace('.jpg', '_Info.txt')
        strInfo = ""
        strTitle = ""
        strContents = ""

        #if strAPODFileName == "ison_encke_hi1_srem_a.jpg":
        #    print "stop here"
        #if strAPODFileName == "pileus_lowenstein_4320.jpg":
        #    print "stop here"

        try:
            with open(
                    strAPODDataFolder +
                    strAPODFileName.replace('.jpg', '_Info.txt'),
                    'r') as content_file:
                strInfo = content_file.read()
        except Exception as e:
            print str(e)

        try:
            with open(
                    strAPODDataFolder +
                    strAPODFileName.replace('.jpg', '_Title.txt'),
                    'r') as content_file:
                strTitle = content_file.read()
        except Exception as e:
            print str(e)

        if strTitle.strip() <> "":
            strContents = strTitle.strip()

        if strInfo.strip() <> "":
            if strContents <> "":
                strContents = strContents + ': ' + strInfo.strip()
            else:
                strContents = strInfo.strip()
        else:
            strContents = strInfo.strip()

        try:
            TEXTCOLOR = (0, 0, 0)
            IMGCOLOR = (0, 0, 0, 255)
            OPCOLOR = (150, 150, 150, 255)
            X = 10
            Y = 3
            fontsize = 24
            #how to I manage this on linux?
            font = ImageFont.truetype('arial.ttf', fontsize)
            im = PILImage.new(
                'RGBA', (1920, 1080),
                IMGCOLOR)  # PILImage.open('G:\\blank.png') #.convert('RGB')
            imgWidth, imgHeight = im.size
            draw = ImageDraw.Draw(im)

            sngHeight = imgHeight * 1.0
            sngWidth = imgWidth * 1.0

            bImageToTop = True

            #INSERT THE ORIGINAL INTO THE CANVAS
            strSource = strAPODPicturesFolder + strAPODFileName
            if os.path.isfile(strSource):
                imIN = PILImage.open(strSource)
                imgWidthIN, imgHeightIN = imIN.size

                if strAPODPicsVLF <> "":
                    #print "checking for very large image"
                    #convert very large images on the Pi down to QHD
                    # if dimentions larger than 3840×2160 scale down to that size first
                    sngWidthQHD = 3840.0
                    sngHeightQHD = 2160.0
                    if imgWidthIN > sngWidthQHD or imgHeightIN > sngHeightQHD:
                        #convert titan5km_huygens_big.jpg -resize 3840x2160 test.jpg
                        #subprocess.call(["ls", "-l"])
                        print "converting VLF"
                        #strArgs = " '" +  + "'"
                        #print "convert " + strArgs
                        #call(["ls", "-l"])
                        call([
                            "convert", strAPODPicturesFolder + strAPODFileName,
                            "-resize", "3840x2160",
                            strAPODPicsVLF + strAPODFileName
                        ])
                        print "reopening VLF"
                        imIN = PILImage.open(strAPODPicsVLF + strAPODFileName)
                        imgWidthIN, imgHeightIN = imIN.size

                bResized = False
                if imgHeightIN > sngHeight:
                    bResized = True
                    sngChange = sngHeight / imgHeightIN
                    imgHeightIN = int(sngHeight)
                    imgWidthIN = int(imgWidthIN * sngChange)
                if imgWidthIN > sngWidth:
                    bResized = True
                    sngChange = sngWidth / imgWidthIN
                    imgWidthIN = int(sngWidth)
                    imgHeightIN = int(imgHeightIN * sngChange)

                szNew = imgWidthIN, imgHeightIN
                if bResized:
                    imIN = imIN.resize(szNew, PILImage.ANTIALIAS)

                #does image go to right or to top?
                if ((imgWidthIN * 1.0) / imgHeightIN) > (
                    (imgWidth * 1.0) / imgHeight):
                    #print "Input Image More Landscape - print to top"
                    if imgHeightIN < (1080 / 2):
                        offset = ((imgWidth - imgWidthIN) / 2,
                                  (1080 / 2) - imgHeightIN
                                  )  #(imgHeight-imgHeightIN)/2)
                    else:
                        offset = ((imgWidth - imgWidthIN) / 2, 0
                                  )  #(imgHeight-imgHeightIN)/2)
                    im.paste(imIN, offset)
                else:
                    bImageToTop = False
                    #print "Input Image More Portrait - print to right"
                    offset = (min((1920 / 2), (imgWidth - imgWidthIN)),
                              (imgHeight - imgHeightIN) / 2)
                    im.paste(imIN, offset)

            #MANAGE THE TEXT OVERLAY
            #decide what gets printed on what line
            tmpLine = ""
            strLine = ""
            #print "Splitting Contents:" + strContents
            words = strContents.split(' ')
            #list of lines to print
            strLines = []
            bLines = False

            if bImageToTop == True:
                #print "printing image to top, text underneath"
                for word in words:
                    #print "10"
                    if strLine == "":
                        #print "20"
                        strLine = word
                    else:
                        #print "30"
                        strLine = strLine + ' ' + word
                    #print "35"
                    strLine = strLine.strip()
                    #print "40: " + strLine
                    if strLine <> "":
                        #print "45"
                        intWidth, intHeight = draw.textsize(strLine, font=font)
                        #print "50"
                        #print 'Text Render Width = ' + str(intWidth) + ', Text Render Height = ' + str(intHeight)
                        if intWidth > (imgWidth - 20):
                            #print "Drawing Text loop: " + tmpLine
                            #draw.text((X, Y), tmpLine, font=font, fill=TEXTCOLOR)
                            strLines.append(tmpLine)
                            #print "100 %s, %s", X, Y
                            #Y += 33 # intHeight * 1.1
                            #print "110"
                            strLine = word
                            tmpLine = strLine
                        else:
                            tmpLine = strLine
                #print "Drawing Text"
                #print "tmpLine = " + tmpLine
                if not tmpLine == "":
                    #draw.text((X, Y), tmpLine, font=font, fill=TEXTCOLOR)
                    strLines.append(tmpLine)
                else:
                    print "Nothing To Print"

                if True:  #False:
                    #Print On The Opacity Layer behind the text
                    #print "making opacity background"
                    intLineEstimate = len(strLines)
                    intRectHeight = intLineEstimate * 33  # 250 # calced by length of text
                    intGradHeight = 40
                    sngGradVal = 0
                    intGradMaxOpacity = 210
                    intX = 1920
                    intY = 1080

                    bgimg = PILImage.new('RGBA', (intX, intY), OPCOLOR)
                    gradient = PILImage.new('L', (1, intY))

                    for y in range(intY):
                        if (y < (intY - (intRectHeight + intGradHeight))):
                            gradient.putpixel((0, y), 0)
                        elif (y < (intY - intRectHeight)):
                            gradient.putpixel((0, y), int(sngGradVal))
                            sngGradVal = sngGradVal + (
                                (intGradMaxOpacity * 1.0) / intGradHeight)
                        else:
                            gradient.putpixel((0, y), intGradMaxOpacity)

                    # resize the gradient to the size of im...
                    alpha = gradient.resize(bgimg.size)
                    # put alpha in the alpha band of im...
                    bgimg.putalpha(alpha)
                    #draw bgimg onto im
                    im.paste(bgimg, (0, 0), bgimg)

                #print on the text
                bLines = False
                Y = (imgHeight - 10) - (len(strLines) * 33)
                for strLine in strLines:
                    if strLine <> "":
                        bLines = True
                        draw.text((X, Y), strLine, font=font, fill=TEXTCOLOR)
                        Y += 33
                        #print strLine
            else:
                intMaxDesiredLineWidth = max(
                    20,
                    min((1920 / 2), (1920 - imgWidthIN)) - (X * 2)) - 10
                #print "print image right, text to the left"
                if True:
                    #print "new logic"
                    intMaxLines = 32
                    intLinesUsed = 33
                    intTotalWidth, intTotalHeight = draw.textsize(strContents,
                                                                  font=font)
                    while intLinesUsed > intMaxLines:
                        #print "logic here"
                        #run draw logic to find number of current lines
                        intMaxDesiredLineWidth += 5
                        strLines[:] = []

                        #with PILImage.new('RGBA',(1920, 1080), IMGCOLOR) as imT:
                        if True:
                            imT = PILImage.new('RGBA', (1920, 1080), IMGCOLOR)
                            imgWidthT, imgHeightT = imT.size
                            drawT = ImageDraw.Draw(imT)

                            for word in words:
                                if strLine == "":
                                    strLine = word
                                else:
                                    strLine = strLine + ' ' + word
                                strLine = strLine.strip()
                                if strLine <> "":
                                    intWidth, intHeight = drawT.textsize(
                                        strLine, font=font)
                                    if intWidth > (intMaxDesiredLineWidth -
                                                   (X * 2)):
                                        strLines.append(tmpLine)
                                        strLine = word
                                        tmpLine = strLine
                                    else:
                                        tmpLine = strLine
                            if not tmpLine == "":
                                strLines.append(tmpLine)
                            else:
                                print "Nothing To Print"
                            intLinesUsed = len(strLines)
                            strLine = ""
                            tmpLine = ""
                else:
                    print "old logic"
                    intTotalWidth, intTotalHeight = draw.textsize(strContents,
                                                                  font=font)
                    intTotalPossibleLines = int(1080 / 33.0) - 3
                    intMaxDesiredLineWidth = max(
                        30,
                        min((1920 / 2), (1920 - imgWidthIN)) - (X * 2))
                    intCurrentLines = intTotalWidth / (intMaxDesiredLineWidth -
                                                       10)
                    intCurrentLines = (intTotalWidth *
                                       1.15) / (intMaxDesiredLineWidth)
                    #print "TotalPossibleLines: " + str(intTotalPossibleLines)
                    #print "TotalWidth: " + str(intTotalWidth)
                    #guess width per line
                    # if lines * maxdesiredlinewidth > inttotalwidth make maxdesiredlinewidth longer
                    while (intCurrentLines > intTotalPossibleLines) and (
                            intMaxDesiredLineWidth < 1920):
                        #print "recalc intMaxDesiredLineWidth"
                        intMaxDesiredLineWidth += 10
                        #intCurrentLines = (intTotalWidth * 1.1) / (intMaxDesiredLineWidth) # - ((X * 2) + 30))
                        intCurrentLines = (intTotalWidth * 1.15) / (
                            intMaxDesiredLineWidth)  # - 10)

                if len(strLines) == intMaxLines:
                    print "stop here"

                strLines[:] = []
                for word in words:
                    #print "10"
                    if strLine == "":
                        #print "20"
                        strLine = word
                    else:
                        #print "30"
                        strLine = strLine + ' ' + word
                    #print "35"
                    strLine = strLine.strip()
                    #print "40: " + strLine
                    if strLine <> "":
                        #print "45"
                        intWidth, intHeight = draw.textsize(strLine, font=font)
                        #print "50"
                        #print 'Text Render Width = ' + str(intWidth) + ', Text Render Height = ' + str(intHeight)
                        if intWidth > (intMaxDesiredLineWidth - (X * 2)):
                            #print "Drawing Text loop: " + tmpLine
                            #draw.text((X, Y), tmpLine, font=font, fill=TEXTCOLOR)
                            strLines.append(tmpLine)
                            #print "100 %s, %s", X, Y
                            #Y += 33 # intHeight * 1.1
                            #print "110"
                            #print "120"
                            strLine = word
                            tmpLine = strLine
                        else:
                            tmpLine = strLine
                #print "Drawing Text"
                #print "tmpLine = " + tmpLine
                if not tmpLine == "":
                    #draw.text((X, Y), tmpLine, font=font, fill=TEXTCOLOR)
                    strLines.append(tmpLine)
                else:
                    print "Nothing To Print"

                if True:  #False:
                    #Print On The Opacity Layer behind the text
                    #print "making opacity background"
                    #intLineEstimate = len(strLines)
                    intRectWidth = intMaxDesiredLineWidth  # intLineEstimate * 33 # 250 # calced by length of text
                    intGradWidth = 40

                    intGradMaxOpacity = 210
                    sngGradVal = intGradMaxOpacity
                    intX = 1920
                    intY = 1080

                    bgimg = PILImage.new('RGBA', (intX, intY), OPCOLOR)
                    gradient = PILImage.new('L', (intX, 1))

                    #make veritical into horizontal
                    for x in range(intX):
                        if (x < (intRectWidth)):  # + intGradWidth)):
                            gradient.putpixel((x, 0), intGradMaxOpacity)
                        #elif (x < (intRectWidth + intGradWidth)):
                        #    gradient.putpixel((x,0),int(sngGradVal))
                        #    sngGradVal = sngGradVal - ((intGradMaxOpacity * 1.0) / intGradWidth)
                        else:
                            gradient.putpixel((x, 0), 0)

                    # resize the gradient to the size of im...
                    alpha = gradient.resize(bgimg.size)
                    # put alpha in the alpha band of im...
                    bgimg.putalpha(alpha)
                    #draw bgimg onto im
                    im.paste(bgimg, (0, 0), bgimg)

                #print on the text
                Y = max(10, ((imgHeight - 10) - (len(strLines) * 33)) / 2)
                if Y < 50:
                    print "Y = " + str(Y)
                for strLine in strLines:
                    if strLine <> "":
                        bLines = True
                        draw.text((X, Y), strLine, font=font, fill=TEXTCOLOR)
                        Y += 33
                        #print strLine

            if bLines == True:
                print "Saving File " + strAPODPicsWithText + strAPODFileName
                im.save(strAPODPicsWithText + strAPODFileName)
                print "Done Building Cache Image With Text"
        except Exception as e:
            print str(e)
Exemple #24
0
def base_image(width: int = IMAGE_SIZE, height: int = IMAGE_SIZE) -> Tuple[Image.Image, ImageDraw.ImageDraw]:
    image = Image.new('RGBA', (width, height))
    draw = ImageDraw.Draw(image)

    return image, draw
    def save_qtype(qtype_list, save_filename, mode):

        if mode == 'val':
            savepath = os.path.join('./eval', save_filename)
            # TODO
            img_pre = '/tempspace/zwang6/VQA/Images/mscoco/val2014'
        elif mode == 'test-dev':
            savepath = os.path.join('./test-dev', save_filename)
            # TODO
            img_pre = '/tempspace/zwang6/VQA/Images/mscoco/test2015'
        elif mode == 'test':
            savepath = os.path.join('./test', save_filename)
            # TODO
            img_pre = '/tempspace/zwang6/VQA/Images/mscoco/test2015'
        else:
            raise Exception('Unsupported mode')
        if os.path.exists(savepath): shutil.rmtree(savepath)
        if not os.path.exists(savepath): os.makedirs(savepath)

        for qt in qtype_list:
            count = 0
            for t_question in stat_list:
                #print count, t_question
                if count < 40/len(qtype_list):
                    t_question_list = t_question['q_list']
                    saveflag = False
                    #print 'debug****************************'
                    #print qt
                    #print t_question_list
                    #print t_question_list[0] == qt[0]
                    #print t_question_list[1] == qt[1]
                    if t_question_list[0] == qt[0] and t_question_list[1] == qt[1]:
                        saveflag = True
                    else:
                        saveflag = False
                               
                    if saveflag == True:
                        t_iid = t_question['iid']
                        if mode == 'val':
                            t_img = Image.open(os.path.join(img_pre, \
                                'COCO_val2014_' + str(t_iid).zfill(12) + '.jpg'))
                        elif mode == 'test-dev' or 'test':
                            t_img = Image.open(os.path.join(img_pre, \
                                'COCO_test2015_' + str(t_iid).zfill(12) + '.jpg'))

                        # for caption
                        #print t_iid
                        #annIds = caps.getAnnIds(t_iid)
                        #anns = caps.loadAnns(annIds)
                        #cap_list = [ann['caption'] for ann in anns]
                        ans_list = t_question['ans_list']
                        draw = ImageDraw.Draw(t_img)
                        for i in range(len(ans_list)):
                            try:
                                draw.text((10,10*i), str(ans_list[i]))
                            except:
                                pass

                        ans = t_question['answer']
                        pred = t_question['pred']
                        if ans == -1:
                            pre = ''
                        elif ans == pred:
                            pre = 'correct  '
                        else:
                            pre = 'failure  '
                        #print ' aaa ', ans, pred
                        ans = re.sub( '/', ' ', str(ans))
                        pred = re.sub( '/', ' ', str(pred))
                        img_title = pre + str(' '.join(t_question_list)) + '.  a_' + \
                            str(ans) + ' p_' + str(pred) + '.png'
                        count += 1
                        write_log(os.path.join(savepath,img_title), 'visualize_log.txt')
                        t_img.save(os.path.join(savepath,img_title))
Exemple #26
0
from PIL import Image, ImageDraw, ImageFont
import matplotlib.font_manager

image = Image.new('RGB', (640, 360), (255, 255, 255))
drawer = ImageDraw.Draw(image)

font_list = matplotlib.font_manager.fontManager.ttflist


def size_to_line_height(fontpath, size):
    font_sample = ImageFont.truetype(fontpath, size)
    sample_size = drawer.textsize("Hello python language", font=font_sample)
    offset = font_sample.getoffset("Hello python language")
    print(sample_size, offset)
    return sample_size[1] + offset[1]


def drawText(text, x, y, font):
    size = drawer.textsize(text, font=font)
    offset = font.getoffset(text)
    print("size", size)
    print("offset", offset)
    print("size+offest", size[0] + offset[0], size[1] + offset[1])
    drawer.text((x, y), text, fill='black', font=font)
    drawer.rectangle(
        (x, y, x + size[0] + offset[0], y + size[1] + offset[1]), outline='black')

# drawing text

font_size = size_to_line_height('/Library/Fonts/ヒラギノ角ゴ Pro W6.otf', 40)
def text_mode(cam):
	text = ""
	word = ""
	count_same_frame = 0
	while True:
		img = cam.read()[1]
		img = cv2.resize(img, (640, 480))
		img, contours, thresh = get_img_contour_thresh(img)
		old_text = text
		if len(contours) > 0:
			contour = max(contours, key = cv2.contourArea)
			if cv2.contourArea(contour) > 10000:
				text = get_pred_from_contour(contour, thresh)
				if old_text == text:
					count_same_frame += 1
				else:
					count_same_frame = 0
				if count_same_frame > 20:
					word = word + text
					count_same_frame = 0
			elif cv2.contourArea(contour) < 1000:
				text = ""
		blackboard = np.zeros((480, 640, 3), dtype=np.uint8)
		b,g,r,a = 255,255,255,0
		img_pil = Image.fromarray(blackboard)

		draw = ImageDraw.Draw(img_pil)
		draw.text((180,50), " ", font =ImageFont.truetype('malgun.ttf', 36), fill=(255, 0,0, 0))
		draw.text((30, 100), "Predicted text-" + text, font = ImageFont.truetype('malgun.ttf', 36), fill = (255, 255, 0, 0))

		line_break_idx = word.rfind("\n")	#Line breaks on blackboard
		if line_break_idx==-1:
			if len(word) > 13:
				word += "\n"
		else:
			if len(word)-line_break_idx > 14:
				word += "\n"
		y0 = 150	
		dy = 50
		for i, line in enumerate(word.split('\n')):
			y = y0 + i*dy
			line = join_jamos(line)
			draw.text((30, y), line, font=ImageFont.truetype('malgun.ttf', 36), fill=(255, 255, 255, 0))

		blackboard = np.array(img_pil)
		cv2.putText(blackboard, " ", (450, 440), cv2.FONT_HERSHEY_TRIPLEX, 1, (255, 127, 0))

		cv2.rectangle(img, (x,y), (x+w, y+h), (0,255,0), 2)
		res = np.hstack((img, blackboard))
		cv2.imshow("Recognizing gesture", res)
		cv2.imshow("thresh", thresh)
		keypress = cv2.waitKey(1)
		if keypress == ord('q') or keypress == ord('c'):
			break
		if keypress == 13:	
			word = word + text
			count_same_frame = 0
		if keypress == 8: 
			word = word[:-1]

	if keypress == ord('c'):
		return 2
	else:
		return 0
from PIL import Image, ImageDraw, ImageFont
import math, os, sys, random
from HelperFunctions import *

# Parameters
img_name = 'Armenian'
font_size = (18, 24, 32)
font_color = (0, 0, 0)
font_path = os.path.join(os.getcwd(), 'DejaVuSans.ttf')
folder_path = os.path.join(os.getcwd(), 'Unicode-Values', 'Armenian')

# Create base image and draw object
base_image = Image.new('RGB', (500, 500), (255, 255, 255))
base_draw = ImageDraw.Draw(base_image)

# Load Font and get language data
dejavu_font_s = ImageFont.truetype(font_path, font_size[0])
dejavu_font_m = ImageFont.truetype(font_path, font_size[1])
dejavu_font_l = ImageFont.truetype(font_path, font_size[2])
Armenian = readPath(folder_path)
displayLangObject(Armenian)

base_draw.text((250, 25),
               img_name,
               font=dejavu_font_l,
               fill=font_color,
               align='center',
               anchor='mm')

x, y = 10, 30
for key in Armenian:
Exemple #29
0
# to chromedriver in your computer

driver = webdriver.Chrome('chromedriver',chrome_options=options)
  
driver.get("https://web.whatsapp.com/") 
wait = WebDriverWait(driver, 100)
print("Whatsapp connected")
prev="1"
while True:
    element1 = driver.find_elements_by_xpath('//*[@id="main"]/header/div[2]/div[1]')
    if(len(element1)>0):
        target=element1[0].text     
        a=target.split(' ')
        reciever=a[0]
        image = Image.open('w.png')
        draw = ImageDraw.Draw(image)
        font = ImageFont.truetype('Charm-Regular', size=32)
        font2= ImageFont.truetype('Acme-Regular', size=26)
        (x, y) = (50, 50)
        message = "Wishing " + reciever.upper() + " and Family "
        color = 'rgb(255,58,249)'
        draw.text((x, y), message, fill=color, font=font)
        message="a very Happy New Year "
        (x, y) = (60, 87)
        draw.text((x, y), message, fill=color, font=font)
        (x,y) =(50,132)
        message="May Light always surround you"
        draw.text((x, y), message, fill=color, font=font)
        (x, y) = (500,300)
        name = ' - - - Tanay Mishra'
        color = 'rgb(18, 20, 234)' 
Exemple #30
0
    def show_frame(self, set_number, seq_number, frame_number):
        self.load_annotations()  # Will be needed

        # Check the frame was prepared
        if not self.is_frame_prepared(set_number, seq_number, frame_number):
            self.prepare_frame(set_number, seq_number, frame_number)

        if CaltechDataset.USE_CROPPING:
            image = Image.open(self.dataset_location +
                               '/images-cropped/set{:02d}/V{:03d}.seq/{}.jpg'.
                               format(set_number, seq_number, frame_number))
            transform = np.load(
                self.dataset_location +
                '/images-cropped/set{:02d}/V{:03d}.seq/{}.transform.npy'.
                format(set_number, seq_number, frame_number))
        else:
            image = Image.open(self.dataset_location +
                               '/images/set{:02d}/V{:03d}.seq/{}.jpg'.format(
                                   set_number, seq_number, frame_number))
        dr = ImageDraw.Draw(image)

        # Retrieve objects for that frame in annotations
        try:
            objects = self.annotations['set{:02d}'.format(set_number)][
                'V{:03d}'.format(seq_number)]['frames']['{}'.format(
                    frame_number)]
        except KeyError as e:
            objects = None  # Simply no objects for that frame

        if objects:
            for o in objects:
                pos = (o['pos'][1], o['pos'][0], o['pos'][3], o['pos'][2]
                       )  # Convert to (y, x, h, w)
                if CaltechDataset.USE_CROPPING:
                    pos = transform_cropped_pos(pos, transform)

                if o['lbl'] in ['person']:
                    good = True

                    # Remove objects with very small width (are they errors in labeling?!)
                    if pos[3] < CaltechDataset.MINIMUM_WIDTH:
                        good = False

                    if o['occl'] == 1:
                        if type(o['posv']) == int:
                            good = False
                        else:
                            visible_pos = (o['posv'][1], o['posv'][0],
                                           o['posv'][3], o['posv'][2]
                                           )  # Convert to (y, x, h, w)
                            if CaltechDataset.USE_CROPPING:
                                visible_pos = transform_cropped_pos(
                                    visible_pos, transform)
                            if visible_pos[2] * visible_pos[
                                    3] < CaltechDataset.MINIMUM_VISIBLE_RATIO * pos[
                                        2] * pos[3]:
                                good = False
                                pos = visible_pos

                    if good:
                        dr.rectangle(
                            (pos[1], pos[0], pos[1] + pos[3], pos[0] + pos[2]),
                            outline='blue')
                    else:
                        dr.rectangle(
                            (pos[1], pos[0], pos[1] + pos[3], pos[0] + pos[2]),
                            outline='pink')
                else:
                    dr.rectangle(
                        (pos[1], pos[0], pos[1] + pos[3], pos[0] + pos[2]),
                        outline='black')

        clas_negative = np.load(
            self.dataset_location +
            '/prepared/set{:02d}/V{:03d}.seq/{}.negative.npy'.format(
                set_number, seq_number, frame_number))
        for i in range(clas_negative.shape[1]):
            y, x, anchor_id = clas_negative[:, i]
            dr.rectangle(
                (CaltechDataset.OUTPUT_CELL_SIZE * x,
                 CaltechDataset.OUTPUT_CELL_SIZE * y,
                 CaltechDataset.OUTPUT_CELL_SIZE *
                 (x + 1) - 1, CaltechDataset.OUTPUT_CELL_SIZE * (y + 1) - 1),
                outline='red')

        clas_positive = np.load(
            self.dataset_location +
            '/prepared/set{:02d}/V{:03d}.seq/{}.positive.npy'.format(
                set_number, seq_number, frame_number))
        for i in range(clas_positive.shape[1]):
            y, x, anchor_id = clas_positive[:, i]
            pos = self.get_anchor_at(anchor_id, y, x)
            dr.rectangle(
                (CaltechDataset.OUTPUT_CELL_SIZE * x,
                 CaltechDataset.OUTPUT_CELL_SIZE * y,
                 CaltechDataset.OUTPUT_CELL_SIZE *
                 (x + 1) - 1, CaltechDataset.OUTPUT_CELL_SIZE * (y + 1) - 1),
                outline='green')
            dr.rectangle((pos[1], pos[0], pos[1] + pos[3], pos[0] + pos[2]),
                         outline='green')

        image.show()