def update(self, frames): """ Given a image, find when to trigger and return bounding boxes of people in the trigger region Parameters: frames (dict): dictionary of frames from all the cameras Returns: bboxes (ndarry): bounding boxes of detected objects sampimg (ndarray): cropped image of the trigger region """ img = frames[self._camera_id] chkimg = cv2.cvtColor(crop_image(img, self._check_coords), cv2.COLOR_BGR2GRAY) score, diff = compare_ssim(self._ref_img, chkimg, full=True) if self._check == 1: if score > self._close_thresh: sampimg = crop_image(img, self._sample_coords) bboxes, scores = self._detector.get_bboxes(sampimg) self._check = 0 return True, bboxes, sampimg else: if score < self._open_thresh: self._check = 1 return False, None, None
def run_mot_and_fill_gallery(video_loader, gallery, detector, sort_trackers, output_files): # Iterate through frames of all cameras iterator = tqdm(video_loader) for findex, frames in iterator: if findex >= 400: iterator.close() break # Iterate through each camera for vidname, frame in frames.items(): # Get bounding boxes of all people boxes, scores = detector.get_bboxes(frame) # Send people bounding boxes to tracker # Get three things: normal Sort output (tracking bounding boxes it wants to send), corresponding track objects, and objects of new tracks tracker = sort_trackers[vidname] dets = np.column_stack((np.reshape(boxes, [-1, 4]), scores)) matched_tracks, matched_kb_trackers, new_kb_trackers = tracker.update( dets) gallery.update(vidname, frame, matched_tracks) # Find indexes of returned bounding boxes that meet ideal ratio trkbboxes = np.array(matched_tracks) widths = trkbboxes[:, 2] - trkbboxes[:, 0] heights = trkbboxes[:, 3] - trkbboxes[:, 1] aspectratio = heights / widths readybools = np.isclose(aspectratio, 2, rtol=0.25) indexes = np.arange(len(matched_tracks))[readybools] # Iterate through returned bounding boxes for ind, trk in enumerate(matched_tracks): box = ((int(trk[0]), int(trk[1])), (int(trk[2]), int(trk[3]))) # If bounding box meets ideal ratio, save image of person as reference if ind in indexes: cropimg = crop_image(frame, box) if cropimg.size > 5: fd, temp_file_name = tempfile.mkstemp(suffix='.jpg') cv2.imwrite(temp_file_name, cropimg) os.close(fd) matched_kb_trackers[ind].save_img(temp_file_name) # Write bounding box, frame number, and trackid to file output_files[vidname].write("%d,%d,%.2f,%.2f,%.2f,%.2f\n" % (findex, trk[4], box[0][0], box[0][1], box[1][0], box[1][1])) # Iterate through new tracks and add their current bounding box to list of track references for trk in new_kb_trackers: d = trk.get_state()[0] box = ((int(d[0]), int(d[1])), (int(d[2]), int(d[3]))) cropimg = crop_image(frame, box) if cropimg.size > 5: fd, temp_file_name = tempfile.mkstemp(suffix='.jpg') cv2.imwrite(temp_file_name, cropimg) os.close(fd) trk.save_img(temp_file_name)
def get_eye_frame_cropped(self, frame, coords_data_crop_l, coords_data_crop_r): img_left_eye = utils.crop_image(frame, coords_data_crop_l[0], coords_data_crop_l[1], coords_data_crop_l[2], coords_data_crop_l[3]) img_right_eye = utils.crop_image(frame, coords_data_crop_r[0], coords_data_crop_r[1], coords_data_crop_r[2], coords_data_crop_r[3]) return img_left_eye, img_right_eye
def prepare_data(datasets, annotations, threthoud_pos, threthoud_neg, save_path): global COUNT_FACE, COUNT_BACKGROUND for i in range(len(datasets)): image_dir, num_of_faces, gts = datasets[i] gts = convert_to_xywh(ellipse_to_rectangle(num_of_faces, gts)) for gt in gts: img = crop_image(image_dir, gt) if len(img) == 0: continue a, b, c = img.shape if a == 0 or b == 0 or c == 0: continue COUNT_FACE += 1 path = ''.join( [save_path, '1/', str(i), '_', str(COUNT_FACE), '.jpg']) cv2.imwrite(path, img) for candidate in generate_selective_search(image_dir): x, y, w, h = candidate ious = [] img = crop_image(image_dir, candidate) if len(img) == 0: continue for gt in gts: ious.append( IOU_calculator(x + w / 2, y + h / 2, w, h, gt[0] + gt[2] / 2, gt[1] + gt[3] / 2, gt[2], gt[3])) if max(ious) > threthoud_pos: COUNT_FACE += 1 path = ''.join( [save_path, '1/', str(i), '_', str(COUNT_FACE), '.jpg']) cv2.imwrite(path, img) elif max(ious) < threthoud_neg: COUNT_BACKGROUND += 1 path = ''.join([ save_path, '0/', str(i), '_', str(COUNT_BACKGROUND), '.jpg' ]) cv2.imwrite(path, img) print( f"====>>> {i}/{len(datasets)}: Face: {COUNT_FACE}, Background: {COUNT_BACKGROUND}" )
def crop_video(subdir, sub_set, video): video_crop_base_path = join(save_base_path, sub_set, video) if not isdir(video_crop_base_path): makedirs(video_crop_base_path) xmls = sorted(glob.glob(join(ann_base_path, subdir, video, '*.xml'))) for xml in xmls: xmltree = ET.parse(xml) objects = xmltree.findall('object') objs = [] filename = xmltree.findall('filename')[0].text im = cv2.imread( xml.replace('xml', 'JPEG').replace('Annotations', 'Data')) avg_chans = np.mean(im, axis=(0, 1)) for object_iter in objects: trackid = int(object_iter.find('trackid').text) bndbox = object_iter.find('bndbox') bbox = [ int(bndbox.find('xmin').text), int(bndbox.find('ymin').text), int(bndbox.find('xmax').text), int(bndbox.find('ymax').text) ] z, x = utils.crop_image(im, bbox, padding=avg_chans) # cv2.imwrite(join(video_crop_base_path, '{:06d}.{:02d}.z.jpg'.format(int(filename), trackid)), z) cv2.imwrite( join(video_crop_base_path, '{:06d}.{:02d}.x.jpg'.format(int(filename), trackid)), x)
def crop_img(xml, sub_set_crop_path): xmltree = ET.parse(xml) objects = xmltree.findall('object') frame_crop_base_path = join(sub_set_crop_path, xml.split('/')[-1].split('.')[0]) if not isdir(frame_crop_base_path): makedirs(frame_crop_base_path) img_path = xml.replace('xml', 'JPEG').replace('Annotations', 'Data') im = cv2.imread(img_path) avg_chans = np.mean(im, axis=(0, 1)) for id, object_iter in enumerate(objects): bndbox = object_iter.find('bndbox') bbox = [ int(bndbox.find('xmin').text), int(bndbox.find('ymin').text), int(bndbox.find('xmax').text), int(bndbox.find('ymax').text) ] z, x = utils.crop_image(im, bbox, padding=avg_chans) cv2.imwrite( join(frame_crop_base_path, '{:06d}.{:02d}.x.jpg'.format(0, id)), x)
def __getitem__(self, i): sample = self.samples[i] full_path = sample['full_path'] bbox = sample['bboxes'][0] img = cv.imread(full_path) img = crop_image(img, bbox) img = cv.resize(img, (im_size, im_size)) # img aug img = img[..., ::-1] # RGB img = transforms.ToPILImage()(img) img = self.transformer(img) age = sample['attr']['age'] / 100. pitch = (sample['attr']['angle']['pitch'] + 180) / 360 roll = (sample['attr']['angle']['roll'] + 180) / 360 yaw = (sample['attr']['angle']['yaw'] + 180) / 360 beauty = sample['attr']['beauty'] / 100. expression = name2idx(sample['attr']['expression']['type']) gender = name2idx(sample['attr']['gender']['type']) glasses = name2idx(sample['attr']['glasses']['type']) race = name2idx(sample['attr']['race']['type']) return img, np.array([age, pitch, roll, yaw, beauty]), expression, gender, glasses, race
def compute_disparity(left_image, right_image, maximum_disparity, noise_filter, width): """ Input: -Left & Rectified Right Images, Maximum Disparity Value -Noise filter: increase to be more aggressive Output: -Disparity between images, scaled appropriately """ # convert to grayscale (as the disparity matching works on grayscale) grayL, grayR = convert_to_grayscale([left_image, right_image]) # perform preprocessing - raise to the power, as this subjectively appears # to improve subsequent disparity calculation grayL = np.power(grayL, 0.75).astype('uint8') grayR = np.power(grayR, 0.75).astype('uint8') # compute disparity image from undistorted and rectified stereo images # (which for reasons best known to the OpenCV developers is returned scaled by 16) disparity = stereoProcessor.compute(grayL, grayR) # filter out noise and speckles (adjust parameters as needed) cv2.filterSpeckles(disparity, 0, 4000, maximum_disparity - noise_filter) # threshold the disparity so that it goes from 0 to max disparity _, disparity = cv2.threshold(disparity, 0, maximum_disparity * 16, cv2.THRESH_TOZERO) # scale the disparity to 8-bit for viewing disparity_scaled = (disparity / 16.).astype(np.uint8) # crop area not seen by *both* cameras and and area with car bonnet disparity_scaled = utils.crop_image(disparity_scaled, 0, 390, 135, width) return disparity_scaled
def crop_video(subdir, subset, video): video_dir = join(subdir, video) video_crop_base_path = join(save_base_path, subset, video) if not isdir(video_crop_base_path): makedirs(video_crop_base_path) if debug: print("crop video: {}".format(video)) frames = sorted(glob.glob(join(video_dir, '*.jpg'))) with open(join(video_dir, 'groundtruth.txt')) as f: ann = f.readlines() with open(join(video_dir, 'absence.label')) as f: absense = f.readlines() for id, frame in enumerate(frames): im = cv2.imread(frame) avg_chans = np.mean(im, axis=(0, 1)) bbox = [float(s) for s in ann[id].split(',')] if (bbox[2] == 0 and bbox[3] == 0) or int(absense[id]) == 1: continue trackid = 0 bbox = [bbox[0], bbox[1], bbox[0] + bbox[2], bbox[1] + bbox[3]] filename = frame.split('/')[-1].split('.')[0] z, x = utils.crop_image(im, bbox, padding=avg_chans) cv2.imwrite( join(video_crop_base_path, '{:06d}.{:02d}.x.jpg'.format(int(filename), trackid)), x)
def split_AFLW(test_path, dataset_path): """ 指定した角度ごとにフォルダを分割 """ # フォルダを生成 10度づつに分割 os.makedirs(test_path, exist_ok=True) degree = -90 folder_name = '' test_dict = {} while degree < 90: folder_name = degree test_dir = os.path.join(test_path, str(folder_name)) test_dict[degree] = test_dir os.makedirs(test_dir, exist_ok=True) degree += 10 degree_th = 10 jpg_images = glob.glob(dataset_path + '/*.jpg') for jpg_imgae in jpg_images: mat_file = utils.get_matpath(jpg_imgae) pitch, yaw, roll = utils.get_degree_from_mat(mat_file) if abs(pitch) <= 90: # ファイル名を取得 file_name = os.path.basename(jpg_imgae) save_path = os.path.join( test_dict[int(pitch - pitch % 10)], file_name ) img = utils.crop_image(mat_file, jpg_imgae) img.save(save_path)
def align_faces(faces, image, predictor, required_size=(160, 160)): # Récupération de la taille de l'image (s_height, s_width) = image.shape[:2] aligned_faces = [] # Boucler sur les visages détecté for i, det in enumerate(faces): # Récupérer les traits du visage shape = predictor(image, det) # Récupérer les coordonnées des yeux grâce au traits du visages left_eye = extract_left_eye_center(shape) right_eye = extract_right_eye_center(shape) # Récupérer la matice de rotation du visage grace à la position des yeux M = get_rotation_matrix(left_eye, right_eye) # Appliquer une rotation à l'image afin d'avoir le ième visage aligné rotated = cv2.warpAffine( image, M, (s_width, s_height), flags=cv2.INTER_CUBIC) # Rogner l'image afin de garder uniquement le ième visage cropped = crop_image(rotated, det) cropped = cv2.resize(cropped, required_size) # Ajouter le visage rogné à la liste aligned_faces.append(cropped) return asarray(aligned_faces)
def telemetry(sid, data): if data: # The current steering angle of the car steering_angle = data["steering_angle"] # The current throttle of the car throttle = data["throttle"] # The current speed of the car speed = data["speed"] # The current image from the center camera of the car imgString = data["image"] image = Image.open(BytesIO(base64.b64decode(imgString))) image_array = crop_image(np.asarray(image)) steering_angle = float( model.predict(image_array[None, :, :, :], batch_size=1)) min_speed = 8 max_speed = 10 if float(speed) < min_speed: throttle = 1.0 elif float(speed) > max_speed: throttle = -1.0 else: throttle = 0.1 print(steering_angle, throttle) send_control(steering_angle, throttle) # save frame if args.image_folder != '': timestamp = datetime.utcnow().strftime('%Y_%m_%d_%H_%M_%S_%f')[:-3] image_filename = os.path.join(args.image_folder, timestamp) image.save('{}.jpg'.format(image_filename)) else: # NOTE: DON'T EDIT THIS. sio.emit('manual', data={}, skip_sid=True)
def of_dataset(folder="testset", model=None, view=False): '''measure the error across the given dataset, it compares the measured points with the annotated ground truth, optionally you can [view] the results''' assert (model) # load face and landmark detectors utils.load_shape_predictor(model) # utils.init_face_detector(True, 150) # init average-error err = 0 num = 0 for img, lmarks, path in utils.ibug_dataset(folder): # detections face = utils.prominent_face(utils.detect_faces(img, detector="dlib")) measured = utils.detect_landmarks(img, face) # get error num += 1 err += normalized_root_mean_square(lmarks, measured) # results: if view is True: utils.draw_rect(img, face, color=Colors.yellow) utils.draw_points(img, lmarks, color=Colors.green) utils.draw_points(img, measured, color=Colors.red) utils.show_image(utils.show_properly(utils.crop_image(img, face))) print(err, num, err / num) print("average NRMS Error for {} is {}".format(folder, err / num))
def __init__(self, camera_id, ref_img, open_thresh, close_thresh, check_coords, sample_coords, detector): """ the constructor for BboxTrigger class Parameters: _camera_id (str): name of the camera location _ref_img (cv2 image): reference image (ex. Closed door) _open_thresh (int): threshold value for opening a door _close_thresh (int): threshold value for closing a door _check_coords (list): 2D list of coordinates to check _sample_coords (list): 2D list of trigger coordinates _detector (detector.py): object detector (default FasterRCNN) """ self._camera_id = camera_id self._open_thresh = open_thresh self._close_thresh = close_thresh self._check_coords = check_coords self._sample_coords = sample_coords self._detector = detector # ideally this is not here in the future either self._ref_img = cv2.cvtColor(crop_image(ref_img, check_coords), cv2.COLOR_BGR2GRAY) self._check = 0
def crop_video(subdir, subset, video): video_crop_base_path = join(save_base_path, subset, video) if not isdir(video_crop_base_path): makedirs(video_crop_base_path) #print("crop video: {}".format(video)) frames = glob.glob(join(subdir, 'videos', video, '*.jpg')) def index_keys(text): return int(text.split('/')[-1].split('.')[0]) frames = sorted(frames, key=index_keys) with open(join(subdir, 'anno', video + '.txt')) as f: ann = f.readlines() for id, frame in enumerate(frames): im = cv2.imread(frame) avg_chans = np.mean(im, axis=(0, 1)) bbox_str = [float(s) for s in ann[id].split(',')] trackid = 0 bbox = [ bbox_str[0], bbox_str[1], bbox_str[0] + bbox_str[2], bbox_str[1] + bbox_str[3] ] filename = frame.split('/')[-1].split('.')[0] z, x = utils.crop_image(im, bbox, padding=avg_chans) cv2.imwrite( join(video_crop_base_path, '{:06d}.{:02d}.x.jpg'.format(int(filename), trackid)), x)
def test_shot(): size = utils.check_os() pixel_json = utils.get_pixel_config(size) blank_area = pixel_json['blank_area'] question_area = pixel_json['question_area'] blank_area_point = blank_area['x1'], blank_area['y1'], blank_area[ 'x2'], blank_area['y2'] question_area_point = question_area['x1'], question_area[ 'y1'], question_area['x2'], question_area['y2'] backup_img = None if os.path.exists('image/backup.png'): backup_img = Image.open('image/backup.png') else: print('image/backup.png位置图片不存在') exit(-1) utils.crop_image(backup_img, question_area_point, 'image/crop_test.png') utils.crop_image(backup_img, blank_area_point, 'image/blank_test.png')
def test_shot(is_ios): size = utils.check_os(is_ios) pixel_json = utils.get_pixel_config(size) blank_area = pixel_json['blank_area'] question_area = pixel_json['question_area'] blank_area_point = blank_area['x1'], blank_area['y1'], blank_area[ 'x2'], blank_area['y2'] question_area_point = question_area['x1'], question_area[ 'y1'], question_area['x2'], question_area['y2'] backup_img = None if os.path.exists('image/backup.png'): backup_img = Image.open('image/backup.png') else: utils.pull_from_screen_ios() backup_img = Image.open('image/backup.png') utils.crop_image(backup_img, question_area_point, 'image/crop_test.png') utils.crop_image(backup_img, blank_area_point, 'image/blank_test.png')
def detect_phase(image_path): img = np.copy(image_path) box = utils.find_circles(img, mg_ratio=0.4, n_circles=1) for b in box: crop = utils.crop_image(image_path, b) resized_im = utils.resize_image(crop) #cv.imwrite("Detector_samples/detection_phase_steps/final1.png", resized_im*255) return resized_im
class Life(pygame.sprite.Sprite): life_sprites = utils.load_image(config.images['lives']) image_blue = utils.crop_image(life_sprites, pygame.Rect(6, 2, 88, 84)) image_red = utils.crop_image(life_sprites, pygame.Rect(6, 90, 88, 84)) def __init__(self, pos, scale, *groups): super().__init__(singletons.LivesGroup.get(), *groups) self.scale = scale self.image = pygame.transform.scale( Life.image_blue, (int(Life.image_blue.get_rect().w * scale), int(Life.image_blue.get_rect().h * scale))) self.rect = self.image.get_rect() self.rect.x, self.rect.y = pos def set_red(self): self.image = pygame.transform.scale( Life.image_red, (int(Life.image_blue.get_rect().w * self.scale), int(Life.image_blue.get_rect().h * self.scale)))
def split_300w_pitch(): # フォルダを生成 # pitchフォルダ train_path = '../dataset/pitch/train/' os.makedirs(train_path, exist_ok=True) valid_path = '../dataset/pitch/valid/' os.makedirs(valid_path, exist_ok=True) # 10度づつに分割 degree = -90 folder_name = '' train_dict = {} valid_dict = {} while degree < 90: folder_name = degree # train folder train_dir = os.path.join(train_path, str(folder_name)) train_dict[degree] = train_dir os.makedirs(train_dir, exist_ok=True) # validation folder valid_dir = os.path.join(valid_path, str(folder_name)) valid_dict[degree] = valid_dir os.makedirs(valid_dir, exist_ok=True) degree += 10 dir_path_ls = ['AFW', 'AFW_Flip', 'HELEN', 'HELEN_Flip', 'IBUG', 'IBUG_Flip', 'LFPW', 'LFPW_Flip'] degree_th = 10 #dir_path_ls = ['AFW'] dataset_path = '../../dataset/300W_LP' for each_dir in dir_path_ls: dir_path = os.path.join(dataset_path, each_dir) jpg_images = glob.glob(dir_path+'/*.jpg') for jpg_imgae in jpg_images: mat_file = utils.get_matpath(jpg_imgae) pitch, yaw, roll = utils.get_degree_from_mat(mat_file) print(each_dir) if abs(pitch) <= 90: # ファイル名を取得 file_name = os.path.basename(jpg_imgae) random_dir = np.random.choice( # 20% [train_dict[int(pitch - pitch % 10)], valid_dict[int(pitch - pitch % 10)]], p=[0.8, 0.2] ) save_path = os.path.join(random_dir, file_name) img = utils.crop_image(mat_file, jpg_imgae) img.save(save_path)
def predict_single_image(model, x): """ Get prediction of model for single image. Pad image if it is not multiplier of 32 and make needed augmentations. """ x_img, pading = pad_image(x) x_img = augment_test(x_img.copy())[0] kek = model.predict(np.expand_dims(x_img, 0)) return crop_image(kek[0], pading)
def save_images(full_path, i, bbox): raw = cv.imread(full_path) resized = cv.resize(raw, (im_size, im_size)) filename = 'images/{}_raw.jpg'.format(i) cv.imwrite(filename, resized) img = crop_image(raw, bbox) img = cv.resize(img, (im_size, im_size)) filename = 'images/{}_img.jpg'.format(i) cv.imwrite(filename, img)
def update(self, frames): """adds people and features to the gallery""" for trig in self._triggers: add, boxes, img = trig.update(frames) if add: for box in boxes: cropimg = crop_image(img, box) vect = self._attribute_extractor(cropimg) self._people.append(cropimg) self._feats.append(vect)
def image_preprocess(db, cfg_file, db_inds, scales, result_dir, debug, no_flip, im_queue): num_images = db_inds.size for ind in range(0, num_images): db_ind = db_inds[ind] image_id = db.image_ids(db_ind) image_file = db.image_file(db_ind) image = cv2.imread(image_file) height, width = image.shape[0:2] for scale in scales: new_height = int(height * scale) new_width = int(width * scale) new_center = np.array([new_height // 2, new_width // 2]) if 'DLA' in cfg_file: inp_height = (new_height | 31)+1 inp_width = (new_width | 31)+1 else: inp_height = new_height | 127 inp_width = new_width | 127 images = np.zeros((1, 3, inp_height, inp_width), dtype=np.float32) ratios = np.zeros((1, 2), dtype=np.float32) borders = np.zeros((1, 4), dtype=np.float32) sizes = np.zeros((1, 2), dtype=np.float32) if 'DLA' in cfg_file: out_height, out_width = inp_height // 4, inp_width // 4 else: out_height, out_width = (inp_height + 1) // 4, (inp_width + 1) // 4 height_ratio = out_height / inp_height width_ratio = out_width / inp_width resized_image = cv2.resize(image, (new_width, new_height)) resized_image, border, offset = crop_image(resized_image, new_center, [inp_height, inp_width]) resized_image = resized_image / 255. normalize_(resized_image, db.mean, db.std) images[0] = resized_image.transpose((2, 0, 1)) borders[0] = border sizes[0] = [int(height * scale), int(width * scale)] ratios[0] = [height_ratio, width_ratio] if not no_flip: images = np.concatenate((images, images[:, :, :, ::-1]), axis=0) images = torch.from_numpy(images) im_queue.put([images, ratios, borders, sizes, out_width, image_id]) time.sleep(num_images*10)
def setDartBoardImage(self,dartBoard): self.boardImage = transform.rescale(dartBoard, 0.8, anti_aliasing=True,multichannel=True) self.boardImage = skimage.img_as_ubyte(self.boardImage) self.boardImage = utils.crop_image(self.boardImage) if(self.boardImage is not None): self.outputBoardImage = self.boardImage.copy() #### Create Pointmap that contain all regions of the dart board self.findRegionMasks() ### get the center of the inner bull of the dart board label_img = label(self.myMask.inner_bull) region = regionprops(label_img) if(len(region)==0): return False,False max_index = utils.get_max_index(region) self.center = region[max_index].centroid ### Edge image for straight line detection grayBackgroundImage = rgb2gray(self.boardImage) temp_image = grayBackgroundImage * self.myMask.board edgeImage = feature.canny(temp_image,high_threshold=0.4,low_threshold=0.2) tested_angles = np.linspace(-np.pi / 2, np.pi / 2, 3600) [H,theta,rho] = transform.hough_line(edgeImage,theta=tested_angles) thresh = np.amax(H) thresh = np.ceil(thresh*0.05) ### Detect Peaks hspace, angle, dists = transform.hough_line_peaks(H,theta,rho,num_peaks=10,threshold=thresh) ##### change angles theta to degrees theta_degree= np.degrees(angle) angles = [] angles_180 =[] for a in theta_degree: angles.append(a-90+360) angles_180.append(a+90+360) ### angles - Zero degrees = up Angles = np.concatenate((angles,angles_180),axis=0) Angles = np.mod(Angles,360) Angles = np.sort(Angles) ### construct the 20 region of the dart board regions_values = [10, 15, 2, 17, 3, 19, 7, 16, 8, 11, 14, 9, 12, 5, 20, 1, 18, 4, 13, 6] self.regions_details = [] for i in range(len(regions_values)): region = Region() region.minAngle = Angles[i] region.maxAngle = Angles[np.mod(i+1,np.size(Angles))] region.value = regions_values[i] self.regions_details.append(region)
def save_images(full_path, i, bbox): img = cv.imread(full_path) img = crop_image(img, bbox) img = cv.resize(img, (im_size, im_size)) img_path1 = 'images/img_norm_{}.jpg'.format(i) cv.imwrite(img_path1, img) img = cv.flip(img, 1) img_path2 = 'images/img_flip_{}.jpg'.format(i) cv.imwrite(img_path2, img) return img_path1, img_path2
def update(self, video_name, frame, bboxes): """adds people and features to the gallery""" for trig in self.triggers: if trig.video_oi != video_name: continue indsToSave = trig.update(bboxes) for index in indsToSave: cropimg = crop_image(frame, np.reshape(bboxes[index, :-1], (2, 2))) vect = self._attribute_extractor(cropimg) self._people.append(cropimg) self._feats.append(vect)
class Particle(object): image = pygame.transform.scale( utils.crop_image(utils.load_image(f'particles.png'), pygame.Rect(49, 49, 32, 32)), (10, 10) ) def __init__(self, particle_system, position, velocity, life, colors): self.particle_system = particle_system self.position = list(position) self.velocity = list(velocity) self.time = 0.0 self.life = life self.colors = list(colors) self._padlib_num_colors = len(self.colors) self._padlib_color_needs_update = True def get_color(self): if self._padlib_color_needs_update: part = self.time / self.life part *= self._padlib_num_colors index = int(part) if index >= self._padlib_num_colors: index = self._padlib_num_colors - 1 color1 = self.colors[index] if index + 1 >= self._padlib_num_colors: color2 = color1 else: color2 = self.colors[index+1] delta = [color2[i]-color1[i] for i in [0,1,2]] part = part - int(part) self.color = [rndint(color1[i]+part*delta[i]) for i in [0,1,2]] self._padlib_color_needs_update = False return self.color def update(self, dt, accel): self.velocity[0] += accel[0]*dt self.velocity[1] += accel[1]*dt self.position[0] += self.velocity[0]*dt self.position[1] += self.velocity[1]*dt self.time += dt self._padlib_color_needs_update = True def draw(self, surface): surface.blit(self.image, (rndint(self.position[0]), rndint(self.position[1])))
def _full_image_crop(image, detections): detections = detections.copy() height, width = image.shape[0:2] max_hw = max(height, width) center = [height // 2, width // 2] size = [max_hw, max_hw] image, border, offset = crop_image(image, center, size) detections[:, 0:4:2] += border[2] detections[:, 1:4:2] += border[0] return image, detections
def crop_from_detected(det): shape = self.predictor(img, det) left_eye = extract_left_eye_center(shape) right_eye = extract_right_eye_center(shape) M = get_rotation_matrix(left_eye, right_eye) rotated = cv2.warpAffine(img, M, (s_width, s_height), flags=cv2.INTER_CUBIC) cropped = crop_image(rotated, det) return cropped
def get(self, photo_id): photo = Photo.get(photo_id) if photo: if self.request.get('type'): force_crop = self.request.get('crop', False) if force_crop: force_crop = True cropped, img = crop_image(photo.file, self.request.get('type'), strict=force_crop) if img: self.response.headers['Content-Type'] = 'image/jpg' self.response.out.write(img) else: self.response.out.write('No image') self.response.headers['Content-Type'] = str('image/%s' % photo.extension) self.response.out.write(photo.file) else: self.response.out.write('No image')
def post(self): user = User.get_by_key_name(self.current_user['id']) # action upload a photo if self.request.get('action') == 'upload': fd = self.request.get('photo') # ext = fd.file.name.split('.')[-1].lower() cropped, img = crop_image(fd, 'post', False) photo_blob = Photo.create_blob(img) extension = 'jpg' # if cropped==True else ext photo = Photo(user=user, file=photo_blob, extension=extension, is_used=False) photo.put() self.response.headers['Content-Type'] = 'application/json' self.response.out.write(json.dumps({'success': True, 'photo': str(photo.key())})) # Action create Photo post if self.request.get('action') == 'boker_photo': ispop = self.request.get('pop') == '1' if ispop: self.template = 'boker_pop.html' explicitly_shared = self.request.get('explicit_share', False) if explicitly_shared == 'on': explicitly_shared = True photokey = self.request.get('photokey') desc = self.request.get('desc') photo = Photo.get(photokey) if photo and desc: # Save boker boker = Boker(user=user, photo=photo, description=desc) boker.put() # Set photo used photo.is_used = True photo.put() # Run task: Posting to page wall boker_url = "%s/boker/%s" % (settings.APP_DOMAIN, boker.key().id()) user_access_token = self.current_user['access_token'] deferred.defer(post_page_photo, boker_url, photokey, desc) deferred.defer(publish_upload_action, user_access_token, boker_url, explicitly_shared) boker_url = self.uri_for('boker_view', boker_id=boker.key().id()) if ispop: self.response.out.write(u'<script type="text/javascript">window.parent.window.location.href="%s";</script>' % boker_url); else: self.redirect(boker_url) else: return self.render_response(self.template, { 'errors': 'Photo dan Ceritanya harus diisi.', 'photokey': photokey, 'desc': desc, }) # Action create Video Post if self.request.get('action') == 'boker_video': ispop = self.request.get('pop') == '1' if ispop: self.template = 'boker_video.html' explicitly_shared = self.request.get('explicit_share', False) if explicitly_shared == 'on': explicitly_shared = True video_url = self.request.get('video_url') video_id = self.request.get('video_id') video_source = self.request.get('video_source') desc = self.request.get('desc') if video_id and video_source and desc: boker = Boker(user=user, video_id=video_id, video_source=video_source, description=desc) boker.put() boker_url = "%s/boker/%s" % (settings.APP_DOMAIN, boker.key().id()) user_access_token = self.current_user['access_token'] # deferred.defer(post_page_video, boker_url, boker.description) deferred.defer(publish_posts_action, user_access_token, boker_url, False) boker_url = self.uri_for('boker_view', boker_id=boker.key().id()) if ispop: self.response.out.write(u'<script type="text/javascript">window.parent.window.location.href="%s";</script>' % boker_url); else: self.redirect(boker_url) else: return self.render_response(self.template, { 'errors': 'Video dan Ceritanya harus diisi.', 'video_url': video_url, 'desc': desc, })