def __init__(self, opt): # root: list ; transform: torch transform self.baseroot_A = opt.baseroot_A self.baseroot_B = opt.baseroot_B self.imglist_A = utils.get_jpgs(opt.baseroot_A) self.imglist_B = utils.get_jpgs(opt.baseroot_B) self.transform = transforms.Compose([ transforms.ToTensor(), transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)) ])
def L1L2_Acuuracy(opt): # Define the list saving the accuracy l1losslist = [] l2losslist = [] l1lossratio = 0 l2lossratio = 0 imglist = utils.get_jpgs(opt.basepath) # Compute the accuracy for i in range(len(imglist)): # Full imgpath imgpath = os.path.join(opt.basepath, imglist[i]) refimgpath = os.path.join(opt.refpath, imglist[i].split('.')[0] + '.png') # Compute the traditional indexes l1loss = L1Loss(refimgpath, imgpath) l2loss = L2Loss(refimgpath, imgpath) l1losslist.append(l1loss) l2losslist.append(l2loss) l1lossratio = l1lossratio + l1loss l2lossratio = l2lossratio + l2loss print('The %dth image: l1loss: %f, l2loss: %f' % (i, l1loss, l2loss)) l1lossratio = l1lossratio / len(imglist) l2lossratio = l2lossratio / len(imglist) print('The overall results: l1lossratio: %f, l2lossratio: %f' % (l1lossratio, l2lossratio)) return l1losslist, l2losslist, l1lossratio, l2lossratio
def CCI_Acuuracy(opt): # Define the list saving the accuracy CNIlist = [] CCIlist = [] CCI_determinelist = [] CNIratio = 0 CCIratio = 0 CCI_determineratio = 0 imglist = utils.get_jpgs(opt.basepath) # Compute the accuracy for i in range(len(imglist)): # Full imgpath imgpath = os.path.join(opt.basepath, imglist[i]) # Compute the traditional indexes CNI = SingleImageCNI(imgpath) CCI, CCI_determine = SingleImageCCI(imgpath) CNIlist.append(CNI) CCIlist.append(CCI) CCI_determinelist.append(CCI_determine) CNIratio = CNIratio + CNI CCIratio = CCIratio + CCI CCI_determineratio = CCI_determineratio + CCI_determine print('The %dth image: CNI: %f, CCI: %f, CCI_determine: %d' % (i, CNI, CCI, CCI_determine)) CNIratio = CNIratio / len(imglist) CCIratio = CCIratio / len(imglist) CCI_determineratio = CCI_determineratio / len(imglist) print( 'The overall results: CNI: %f, CCI: %f, CCI_determine in [16, 20]: %f' % (CNIratio, CCIratio, CCI_determineratio)) return CNIlist, CCIlist, CCI_determinelist, CNIratio, CCIratio, CCI_determineratio
def Traditional_Acuuracy(opt): # Define the list saving the accuracy nrmselist = [] psnrlist = [] ssimlist = [] nrmseratio = 0 psnrratio = 0 ssimratio = 0 imglist = utils.get_jpgs(opt.basepath) # Compute the accuracy for i in range(len(imglist)): # Full imgpath imgpath = os.path.join(opt.basepath, imglist[i]) refimgpath = os.path.join(opt.refpath, imglist[i]) # Compute the traditional indexes nrmse = NRMSE(refimgpath, imgpath) psnr = PSNR(refimgpath, imgpath) ssim = SSIM(refimgpath, imgpath) nrmselist.append(nrmse) psnrlist.append(psnr) ssimlist.append(ssim) nrmseratio = nrmseratio + nrmse psnrratio = psnrratio + psnr ssimratio = ssimratio + ssim print('The %dth image: nrmse: %f, psnr: %f, ssim: %f' % (i, nrmse, psnr, ssim)) nrmseratio = nrmseratio / len(imglist) psnrratio = psnrratio / len(imglist) ssimratio = ssimratio / len(imglist) print('The overall results: NRMSE: %f, PSNR: %f, SSIM: %f' % (nrmseratio, psnrratio, ssimratio)) return nrmselist, psnrlist, ssimlist, nrmseratio, psnrratio, ssimratio
def PrecisionRecall_Acuuracy(opt): # Define the list saving the accuracy pscorelist = [] rscorelist = [] f1scorelist = [] pscoreratio = 0 rscoreratio = 0 f1scoreratio = 0 imglist = utils.get_jpgs(opt.basepath) # Compute the accuracy for i in range(len(imglist)): # Full imgpath imgpath = os.path.join(opt.basepath, imglist[i]) refimgpath = os.path.join(opt.refpath, imglist[i]) # Compute the traditional indexes pscore = PrecisionScore(refimgpath, imgpath) rscore = RecallScore(refimgpath, imgpath) f1score = F1Score(refimgpath, imgpath) pscorelist.append(nrmse) rscorelist.append(rscore) f1scorelist.append(f1score) pscoreratio = pscoreratio + pscore rscoreratio = rscoreratio + rscore f1scoreratio = f1scoreratio + f1score print('The %dth image: pscore: %f, rscore: %f, f1score: %f' % (i, pscore, rscore, f1score)) pscoreratio = pscoreratio / len(imglist) rscoreratio = rscoreratio / len(imglist) f1scoreratio = f1scoreratio / len(imglist) print('The overall results: pscore: %f, rscore: %f, f1score: %f' % (pscoreratio, rscoreratio, f1scoreratio)) return pscorelist, rscorelist, f1scorelist, pscoreratio, rscoreratio, f1scoreratio
def __init__(self, opt): # Note that: # 1. opt: all the options # 2. imglist: all the image names under "baseroot" self.opt = opt imglist = utils.get_jpgs(opt.baseroot_sal) self.imglist = imglist
def __init__(self, opt): # Note that: # 1. opt: all the options # 2. imglist: all the image names under "baseroot" self.opt = opt imglist = utils.get_jpgs(opt.baseroot_sal) if opt.smaller_coeff > 1: imglist = self.create_sub_trainset(imglist, opt.smaller_coeff) self.imglist = imglist
def convertToVideo(dirpath, segment, type): imgs = get_jpgs(dirpath) fourcc = cv2.VideoWriter_fourcc(*'mp4v') vw = cv2.VideoWriter("output_" + type + str(segment) + ".mov", fourcc, 60, (imgs[0].shape[1], imgs[0].shape[0])) print "VideoWriter is opened:", vw.isOpened() print("Writing video ...") i = 1 for img in imgs: print "Writing image", i i+=1 vw.write(img) vw.release()
def convertToVideo(dirpath): imgs = get_jpgs(dirpath) fourcc = cv2.VideoWriter_fourcc(*'mp4v') vw = cv2.VideoWriter( "output.mov", fourcc, 30, (imgs[0].shape[1], imgs[0].shape[0])) #(imgs[0].shape[1]+400, imgs[0].shape[0]+400)) print "VideoWriter is opened:", vw.isOpened() print("Writing video ...") i = 1 for img in imgs: print "Writing image", i i += 1 vw.write(img) vw.release()
def stitch(number): ## Put extracted images into DATA_DIR/<folder> before running this imgs = get_jpgs(config.DATA_DIR + "beachVolleyball" + str(number) + "/") cv2.ocl.setUseOpenCL(False) # A workaround for ORB feature detector error stitcher = TranslationStitcher(imgs) panorama_list = stitcher.generate_panorama(get_netmask) # Create the folder d = os.path.dirname(config.DATA_DIR + "processedImages" + str(number) + "/") if not os.path.exists(d): os.makedirs(d) else: filelist = os.listdir(d) for file in filelist: os.remove(d + "/" + file) write_jpgs(config.DATA_DIR + "processedImages" + str(number) + "/", jpgs=panorama_list) convertToVideo(config.DATA_DIR + "processedImages" + str(number) + "/", number, "akaze") cv2.destroyAllWindows()
def __init__(self, opt): # root: list ; transform: torch transform self.opt = opt # the root of both domains self.baseroot = os.path.join(opt.baseroot) # build image list self.imglist = utils.get_jpgs(self.baseroot)
def color_tracking(frames, color): cv2.namedWindow('original', cv2.WINDOW_NORMAL) cv2.namedWindow('mask', cv2.WINDOW_NORMAL) for f in frames: mask = cv2.inRange(cv2.cvtColor(f, cv2.COLOR_BGR2HSV), color[0], color[1]) cnts = cv2.findContours(mask.copy(), cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)[1] players = [] if len(cnts) >= 1: cnts.sort(key=cv2.contourArea, reverse=True) for cnt in cnts: if len(players) < 2: rect = cv2.minAreaRect(cnt) cv2.drawContours(f, [np.int0(cv2.boxPoints(rect))], -1, (255, 0, 0), 2) players.append(cnt) else: break cv2.imshow('original', f) cv2.imshow('mask', cv2.cvtColor(mask, cv2.COLOR_GRAY2BGR)) k = cv2.waitKey(100) if k == 27: break cv2.destroyAllWindows() if __name__ == '__main__': frames = get_jpgs(config.INDVIDUAL_VIDEOS['7']) median_bg_sub(frames)
help = 'load the pre-trained model with certain epoch, None for pre-training') parser.add_argument('--val_path', type=str, default='./ensemble', help='saving path that is a folder') parser.add_argument('--task_name', type=str, default='track2', help='task name for loading networks, saving, and log') # NTIRE2020_Validation_Clean NTIRE2020_Validation_RealWorld opt = parser.parse_args() sample_folder = os.path.join(opt.val_path, opt.task_name) utils.check_path(sample_folder) imglist = utils.get_jpgs(opt.path1) for imgname in imglist: # Read data_path1 = os.path.join(opt.path1, imgname) data1 = hdf5.loadmat(data_path1)['cube'] data_path2 = os.path.join(opt.path2, imgname) data2 = hdf5.loadmat(data_path2)['cube'] data_path3 = os.path.join(opt.path3, imgname) data3 = hdf5.loadmat(data_path3)['cube'] data_path4 = os.path.join(opt.path4, imgname) data4 = hdf5.loadmat(data_path4)['cube'] data_path5 = os.path.join(opt.path5, imgname) data5 = hdf5.loadmat(data_path5)['cube'] data_path6 = os.path.join(opt.path6, imgname) data6 = hdf5.loadmat(data_path6)['cube'] data_path7 = os.path.join(opt.path7, imgname)
def __init__(self, opt): self.opt = opt self.imglist = utils.get_jpgs(opt.baseroot) self.stringlist = utils.text_readlines(opt.stringlist) self.scalarlist = utils.text_readlines(opt.scalarlist)
def __len__(self): return len(utils.get_jpgs(self.in_root))
parser.add_argument('--color_bias_level', type = bool, default = 0.05, help = 'color_bias_level') parser.add_argument('--noise_aug', type = bool, default = True, help = 'noise_aug') parser.add_argument('--iso', type = int, default = 6400, help = 'noise_level, according to ISO value') parser.add_argument('--random_crop', type = bool, default = True, help = 'random_crop') parser.add_argument('--crop_size', type = int, default = 320, help = 'single patch size') parser.add_argument('--extra_process_train_data', type = bool, default = True, help = 'recover short exposure data') parser.add_argument('--cover_long_exposure', type = bool, default = False, help = 'set long exposure to 0') parser.add_argument('--short_expo_per_pattern', type = int, default = 2, help = 'the number of exposure pixel of 2*2 square') opt = parser.parse_args() # ---------------------------------------- # Test # ---------------------------------------- # Initialize generator = utils.create_generator(opt).cuda() namelist = utils.get_jpgs(opt.in_path_val) test_dataset = dataset.Qbayer2RGB_dataset(opt, 'val', namelist) test_loader = torch.utils.data.DataLoader(test_dataset, batch_size = opt.test_batch_size, shuffle = True, num_workers = opt.num_workers, pin_memory = True) sample_folder = os.path.join(opt.val_path, opt.task_name) utils.check_path(sample_folder) # forward val_PSNR = 0 val_SSIM = 0 for i, (in_img, RGBout_img, path) in enumerate(test_loader): # To device # A is for input image, B is for target image in_img = in_img.cuda() RGBout_img = RGBout_img.cuda() #print(path)
bayer[0::2, 1::2, 1] = img[0::2, 1::2, 1] bayer[1::2, 0::2, 1] = img[1::2, 0::2, 1] bayer[1::2, 1::2, 2] = img[1::2, 1::2, 0] return bayer if __name__ == "__main__": # ---------------------------------------- # Initialize the parameters # ---------------------------------------- parser = argparse.ArgumentParser() parser.add_argument('--src_path', type = str, \ default = '', \ help = 'input baseroot') parser.add_argument('--dst_path', type = str, \ default = '', \ help = 'target baseroot') opt = parser.parse_args() print(opt) src_imglist = utils.get_jpgs(opt.src_path) utils.check_path(opt.dst_path) for i in range(len(src_imglist)): img_name = src_imglist[i] src_name = os.path.join(opt.src_path, img_name) dst_name = os.path.join(opt.dst_path, img_name) img = cv2.imread(src_name) bayer = rgb2bayer(img) cv2.imwrite(dst_name, bayer)
def __init__(self, opt): self.opt = opt self.imglist = utils.get_jpgs(opt.baseroot_test_blur)
def __init__(self, opt): assert opt.mask_type in ALLMASKTYPES self.opt = opt self.imglist = utils.get_jpgs(opt.baseroot)
def __init__(self, opt): self.opt = opt self.namelist = utils.get_jpgs(opt.baseroot)
def Trainer_GAN(opt): # ---------------------------------------- # Initialization # ---------------------------------------- # cudnn benchmark cudnn.benchmark = opt.cudnn_benchmark # configurations save_folder = os.path.join(opt.save_path, opt.task_name) sample_folder = os.path.join(opt.sample_path, opt.task_name) if not os.path.exists(save_folder): os.makedirs(save_folder) if not os.path.exists(sample_folder): os.makedirs(sample_folder) # Initialize networks generator = utils.create_generator(opt) discriminator = utils.create_discriminator(opt) perceptualnet = utils.create_perceptualnet() # To device if opt.multi_gpu: generator = nn.DataParallel(generator) generator = generator.cuda() discriminator = nn.DataParallel(discriminator) discriminator = discriminator.cuda() perceptualnet = nn.DataParallel(perceptualnet) perceptualnet = perceptualnet.cuda() else: generator = generator.cuda() discriminator = discriminator.cuda() perceptualnet = perceptualnet.cuda() # ---------------------------------------- # Network dataset # ---------------------------------------- # Handle multiple GPUs gpu_num = torch.cuda.device_count() print("There are %d GPUs used" % gpu_num) opt.train_batch_size *= gpu_num #opt.val_batch_size *= gpu_num opt.num_workers *= gpu_num # Define the dataset train_imglist = utils.get_jpgs(os.path.join(opt.in_path_train)) val_imglist = utils.get_jpgs(os.path.join(opt.in_path_val)) train_dataset = dataset.Qbayer2RGB_dataset(opt, 'train', train_imglist) val_dataset = dataset.Qbayer2RGB_dataset(opt, 'val', val_imglist) print('The overall number of training images:', len(train_imglist)) print('The overall number of validation images:', len(val_imglist)) # Define the dataloader train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=opt.train_batch_size, shuffle=True, num_workers=opt.num_workers, pin_memory=True) val_loader = torch.utils.data.DataLoader(val_dataset, batch_size=opt.val_batch_size, shuffle=False, num_workers=opt.num_workers, pin_memory=True) # ---------------------------------------- # Network training parameters # ---------------------------------------- # Loss functions criterion_L1 = torch.nn.L1Loss().cuda() class ColorLoss(nn.Module): def __init__(self): super(ColorLoss, self).__init__() self.L1loss = nn.L1Loss() def RGB2YUV(self, RGB): YUV = RGB.clone() YUV[:, 0, :, :] = 0.299 * RGB[:, 0, :, :] + 0.587 * RGB[:, 1, :, :] + 0.114 * RGB[:, 2, :, :] YUV[:, 1, :, :] = -0.14713 * RGB[:, 0, :, :] - 0.28886 * RGB[:, 1, :, :] + 0.436 * RGB[:, 2, :, :] YUV[:, 2, :, :] = 0.615 * RGB[:, 0, :, :] - 0.51499 * RGB[:, 1, :, :] - 0.10001 * RGB[:, 2, :, :] return YUV def forward(self, x, y): yuv_x = self.RGB2YUV(x) yuv_y = self.RGB2YUV(y) return self.L1loss(yuv_x, yuv_y) yuv_loss = ColorLoss() # Optimizers optimizer_G = torch.optim.Adam(generator.parameters(), lr=opt.lr_g, betas=(opt.b1, opt.b2), weight_decay=opt.weight_decay) optimizer_D = torch.optim.Adam(generator.parameters(), lr=opt.lr_d, betas=(opt.b1, opt.b2), weight_decay=opt.weight_decay) # Learning rate decrease def adjust_learning_rate(opt, epoch, iteration, optimizer, lr_gd): # Set the learning rate to the initial LR decayed by "lr_decrease_factor" every "lr_decrease_epoch" epochs if opt.lr_decrease_mode == 'epoch': lr = lr_gd * (opt.lr_decrease_factor **(epoch // opt.lr_decrease_epoch)) for param_group in optimizer.param_groups: param_group['lr'] = lr if opt.lr_decrease_mode == 'iter': lr = lr_gd * (opt.lr_decrease_factor **(iteration // opt.lr_decrease_iter)) for param_group in optimizer.param_groups: param_group['lr'] = lr # Save the model if pre_train == True def save_model(opt, epoch, iteration, len_dataset, generator): # Define the name of trained model if opt.save_mode == 'epoch': model_name = '%s_gan_noise%.3f_epoch%d_bs%d.pth' % ( opt.net_mode, opt.noise_level, epoch, opt.train_batch_size) if opt.save_mode == 'iter': model_name = '%s_gan_noise%.3f_iter%d_bs%d.pth' % ( opt.net_mode, opt.noise_level, iteration, opt.train_batch_size) save_model_path = os.path.join(opt.save_path, opt.task_name, model_name) # Save model if opt.multi_gpu == True: if opt.save_mode == 'epoch': if (epoch % opt.save_by_epoch == 0) and (iteration % len_dataset == 0): torch.save(generator.module.state_dict(), save_model_path) print( 'The trained model is successfully saved at epoch %d' % (epoch)) if opt.save_mode == 'iter': if iteration % opt.save_by_iter == 0: torch.save(generator.module.state_dict(), save_model_path) print( 'The trained model is successfully saved at iteration %d' % (iteration)) else: if opt.save_mode == 'epoch': if (epoch % opt.save_by_epoch == 0) and (iteration % len_dataset == 0): torch.save(generator.state_dict(), save_model_path) print( 'The trained model is successfully saved at epoch %d' % (epoch)) if opt.save_mode == 'iter': if iteration % opt.save_by_iter == 0: torch.save(generator.state_dict(), save_model_path) print( 'The trained model is successfully saved at iteration %d' % (iteration)) # ---------------------------------------- # Training # ---------------------------------------- # Count start time prev_time = time.time() # Tensorboard writer = SummaryWriter() # For loop training for epoch in range(opt.epochs): # Record learning rate for param_group in optimizer_G.param_groups: writer.add_scalar('data/lr', param_group['lr'], epoch) print('learning rate = ', param_group['lr']) if epoch == 0: iters_done = 0 ### Training for i, (in_img, RGBout_img) in enumerate(train_loader): # To device # A is for input image, B is for target image in_img = in_img.cuda() RGBout_img = RGBout_img.cuda() ## Train Discriminator # Forward propagation out = generator(in_img) optimizer_D.zero_grad() # Fake samples fake_scalar_d = discriminator(in_img, out.detach()) true_scalar_d = discriminator(in_img, RGBout_img) # Overall Loss and optimize loss_D = -torch.mean(true_scalar_d) + torch.mean(fake_scalar_d) loss_D.backward() #torch.nn.utils.clip_grad_norm(discriminator.parameters(), opt.grad_clip_norm) optimizer_D.step() ## Train Generator # Forward propagation out = generator(in_img) # GAN loss fake_scalar = discriminator(in_img, out) L_gan = -torch.mean(fake_scalar) * opt.lambda_gan # Perceptual loss features fake_B_fea = perceptualnet(utils.normalize_ImageNet_stats(out)) true_B_fea = perceptualnet( utils.normalize_ImageNet_stats(RGBout_img)) L_percep = opt.lambda_percep * criterion_L1(fake_B_fea, true_B_fea) # Pixel loss L_pixel = opt.lambda_pixel * criterion_L1(out, RGBout_img) # Color loss L_color = opt.lambda_color * yuv_loss(out, RGBout_img) # Sum up to total loss loss = L_pixel + L_percep + L_gan + L_color # Record losses writer.add_scalar('data/L_pixel', L_pixel.item(), iters_done) writer.add_scalar('data/L_percep', L_percep.item(), iters_done) writer.add_scalar('data/L_color', L_color.item(), iters_done) writer.add_scalar('data/L_gan', L_gan.item(), iters_done) writer.add_scalar('data/L_total', loss.item(), iters_done) writer.add_scalar('data/loss_D', loss_D.item(), iters_done) # Backpropagate gradients optimizer_G.zero_grad() loss.backward() #torch.nn.utils.clip_grad_norm(generator.parameters(), opt.grad_clip_norm) optimizer_G.step() # Determine approximate time left iters_done = epoch * len(train_loader) + i + 1 iters_left = opt.epochs * len(train_loader) - iters_done time_left = datetime.timedelta(seconds=iters_left * (time.time() - prev_time)) prev_time = time.time() # Print log print( "\r[Epoch %d/%d] [Batch %d/%d] [Total Loss: %.4f] [L_pixel: %.4f]" % ((epoch + 1), opt.epochs, i, len(train_loader), loss.item(), L_pixel.item())) print( "\r[L_percep: %.4f] [L_color: %.4f] [L_gan: %.4f] [loss_D: %.4f] Time_left: %s" % (L_percep.item(), L_color.item(), L_gan.item(), loss_D.item(), time_left)) # Save model at certain epochs or iterations save_model(opt, (epoch + 1), iters_done, len(train_loader), generator) # Learning rate decrease at certain epochs adjust_learning_rate(opt, (epoch + 1), iters_done, optimizer_G, opt.lr_g) adjust_learning_rate(opt, (epoch + 1), iters_done, optimizer_D, opt.lr_d) ### Sample data every epoch if (epoch + 1) % 1 == 0: img_list = [out, RGBout_img] name_list = ['pred', 'gt'] utils.save_sample_png(sample_folder=sample_folder, sample_name='train_epoch%d' % (epoch + 1), img_list=img_list, name_list=name_list, pixel_max_cnt=255) ### Validation val_PSNR = 0 num_of_val_image = 0 for j, (in_img, RGBout_img) in enumerate(val_loader): # To device # A is for input image, B is for target image in_img = in_img.cuda() RGBout_img = RGBout_img.cuda() # Forward propagation with torch.no_grad(): out = generator(in_img) # Accumulate num of image and val_PSNR num_of_val_image += in_img.shape[0] val_PSNR += utils.psnr(out, RGBout_img, 1) * in_img.shape[0] val_PSNR = val_PSNR / num_of_val_image ### Sample data every epoch if (epoch + 1) % 1 == 0: img_list = [out, RGBout_img] name_list = ['pred', 'gt'] utils.save_sample_png(sample_folder=sample_folder, sample_name='val_epoch%d' % (epoch + 1), img_list=img_list, name_list=name_list, pixel_max_cnt=255) # Record average PSNR writer.add_scalar('data/val_PSNR', val_PSNR, epoch) print('PSNR at epoch %d: %.4f' % ((epoch + 1), val_PSNR)) writer.close()
import cv2 import utils imglist = utils.get_files('./samples/dcgan') namelist = utils.get_jpgs('./samples/dcgan') for i in range(0, len(imglist)): img = cv2.imread(imglist[i]) img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB) cv2.imwrite(namelist[i], img)
self.transition = transition_model self.resampling_handler = resampling_handler self.predict = prediction_model def process(self, img): # Displacement self.transition(self.particles, self.img_boundary) # Prediction # self.predict(self.particles, img, np.mean(cv2.cvtColor(self.ref_img, cv2.COLOR_BGR2HSV)[..., 0])) self.predict(self.particles, img, hsv_histogram(self.ref_img)) for p in self.particles: # draw_str(img, (p.x, p.y), "{0:.2f}".format(p.w)) p.draw(img) # Resampling sum_w = sum([p.w for p in self.particles]) ps = self.resampling_handler(self.particles, [p.w/sum_w for p in self.particles], self.img_boundary) self.particles = [PlayerParticle(*p) for p in ps] if __name__ == '__main__': imgs = get_jpgs(config.INDVIDUAL_VIDEOS['1']) imgs = get_jpgs(config.INPUT_IMGS) pf = ParticleFilter(PlayerParticle.generate, img_boundary=(imgs[0].shape[1], imgs[0].shape[0])) for img in imgs: pf.process(img) cv2.imshow('particle filter', img) k = cv2.waitKey(1) if k == 27: break
imgs[0].shape[0])) #(imgs[0].shape[1]+400, imgs[0].shape[0]+400)) print "VideoWriter is opened:", vw.isOpened() print("Writing video ...") i = 1 for img in imgs: print "Writing image", i i += 1 vw.write(img) vw.release() if __name__ == '__main__': number = 3 # Change this number to perform the stitch on different segments ## Put extracted images into DATA_DIR/<folder> before running this imgs = get_jpgs(config.DATA_DIR + "beachVolleyball" + str(number) + "/") cv2.ocl.setUseOpenCL(False) # A workaround for ORB feature detector error stitcher = TranslationStitcher(imgs[::5]) panorama_list = stitcher.generate_panorama(get_netmask) # Create the folder d = os.path.dirname(config.DATA_DIR + "processedImages" + str(number) + "/") if not os.path.exists(d): os.makedirs(d) else: filelist = os.listdir(d) for file in filelist: os.remove(d + "/" + file) write_jpgs(config.DATA_DIR + "processedImages" + str(number) + "/",