def main():
if os.path.isdir(opt.media_path):
files = util.Traversal(opt.media_path)
else:
files = [opt.media_path]
if opt.mode == 'add':
netS = loadmodel.bisenet(opt, 'roi')
for file in files:
opt.media_path = file
if util.is_img(file):
core.addmosaic_img(opt, netS)
elif util.is_video(file):
core.addmosaic_video(opt, netS)
util.clean_tempfiles(opt, tmp_init=False)
else:
print('This type of file is not supported')
util.clean_tempfiles(opt, tmp_init=False)
elif opt.mode == 'clean':
netM = loadmodel.bisenet(opt, 'mosaic')
if opt.traditional:
netG = None
elif opt.netG == 'video':
netG = loadmodel.video(opt)
else:
netG = loadmodel.pix2pix(opt)
for file in files:
opt.media_path = file
if util.is_img(file):
core.cleanmosaic_img(opt, netG, netM)
elif util.is_video(file):
if opt.netG == 'video' and not opt.traditional:
core.cleanmosaic_video_fusion(opt, netG, netM)
else:
core.cleanmosaic_video_byframe(opt, netG, netM)
util.clean_tempfiles(opt, tmp_init=False)
else:
print('This type of file is not supported')
elif opt.mode == 'style':
netG = loadmodel.style(opt)
for file in files:
opt.media_path = file
if util.is_img(file):
core.styletransfer_img(opt, netG)
elif util.is_video(file):
core.styletransfer_video(opt, netG)
util.clean_tempfiles(opt, tmp_init=False)
else:
print('This type of file is not supported')
util.clean_tempfiles(opt, tmp_init=False)
def main():
if os.path.isdir(opt.media_path):
files = util.Traversal(opt.media_path)
else:
files = [opt.media_path]
if opt.mode == 'clean':
netM = loadmodel.bisenet(opt, 'mosaic')
if opt.traditional:
netG = None
else:
netG = model.netG
for file in files:
opt.media_path = file
if z_util.is_img(file):
core.cleanmosaic_img(opt, netG, netM)
elif z_util.is_video(file):
core.cleanmosaic_video_byframe(opt, netG, netM)
else:
print('This type of file is not supported')
z_util.clean_tempfiles(tmp_init=False)
import os
import numpy as np
import cv2
import random
import csv
import sys
sys.path.append("..")
from util import util,ffmpeg
from util import image_processing as impro
files = util.Traversal('/media/hypo/Media/download')
videos = util.is_videos(files)
video_times = []
useable_videos = []
video_dict = {}
reader = csv.reader(open('./csv/video_used_time.csv'))
for line in reader:
useable_videos.append(line[0])
video_times.append(line[1:])
video_dict[line[0]]=line[1:]
in_cnt = 0
out_cnt = 502
for video in videos:
if os.path.basename(video) in useable_videos:
# print(video)
for i in range(len(video_times[in_cnt])):
ffmpeg.cut_video(video, video_dict[os.path.basename(video)][i], '00:00:05', './video/'+'%04d'%out_cnt+'.mp4')
help='minimal quality')
opt.parser.add_argument('--outsize', type=int, default=286, help='')
opt.parser.add_argument('--startcnt', type=int, default=0, help='')
opt.parser.add_argument('--minsize',
type=int,
default=96,
help='minimal roi size')
opt.parser.add_argument('--no_sclectscene', action='store_true', help='')
opt = opt.getparse()
util.makedirs(opt.savedir)
util.writelog(
os.path.join(opt.savedir, 'opt.txt'),
str(time.asctime(time.localtime(time.time()))) + '\n' + util.opt2str(opt))
videopaths = util.Traversal(opt.datadir)
videopaths = util.is_videos(videopaths)
random.shuffle(videopaths)
# def network
net = loadmodel.bisenet(opt, 'roi')
result_cnt = opt.startcnt
video_cnt = 1
starttime = datetime.datetime.now()
for videopath in videopaths:
try:
if opt.no_sclectscene:
timestamps = ['00:00:00']
else:
timestamps = []
opt.parser.add_argument('--datadir',
type=str,
default=' ',
help='your images dir')
opt.parser.add_argument('--savedir',
type=str,
default='../datasets/draw/face',
help='')
opt = opt.getparse()
mask_savedir = os.path.join(opt.savedir, 'mask')
img_savedir = os.path.join(opt.savedir, 'origin_image')
util.makedirs(mask_savedir)
util.makedirs(img_savedir)
filepaths = util.Traversal(opt.datadir)
filepaths = util.is_imgs(filepaths)
random.shuffle(filepaths)
print('find image:', len(filepaths))
# mouse callback function
drawing = False # true if mouse is pressed
ix, iy = -1, -1
brushsize = 20
def draw_circle(event, x, y, flags, param):
global ix, iy, drawing, brushsize
if event == cv2.EVENT_LBUTTONDOWN:
drawing = True
default=45,
help='minimal quality')
opt.parser.add_argument('--outsize', type=int, default=286, help='')
opt.parser.add_argument('--startcnt', type=int, default=0, help='')
opt.parser.add_argument('--minsize',
type=int,
default=96,
help='minimal roi size')
opt = opt.getparse()
util.makedirs(opt.savedir)
util.writelog(
os.path.join(opt.savedir, 'opt.txt'),
str(time.asctime(time.localtime(time.time()))) + '\n' + util.opt2str(opt))
videopaths = util.Traversal(opt.datadir)
videopaths = util.is_videos(videopaths)
random.shuffle(videopaths)
# def network
net = loadmodel.bisenet(opt, 'roi')
result_cnt = opt.startcnt
video_cnt = 1
starttime = datetime.datetime.now()
for videopath in videopaths:
try:
timestamps = []
fps, endtime, height, width = ffmpeg.get_video_infos(videopath)
for cut_point in range(1, int((endtime - opt.time) / opt.interval)):
util.clean_tempfiles()
img_tmp = np.zeros(img_origin.shape)
img_tmp[y - size:y + size, x - size:x + size] = img_fake
img_result = img_origin.copy()
img_result = (img_origin * (1 - mask) + img_tmp * mask).astype('uint8')
return img_result
netG = loadmodel.pix2pix(os.path.join(opt.model_dir, opt.model_name),
opt.model_type_netG,
use_gpu=opt.use_gpu)
net_mosaic_pos = loadmodel.unet(os.path.join(opt.model_dir,
opt.mosaic_position_model_name),
use_gpu=opt.use_gpu)
filepaths = util.Traversal(opt.input_dir)
for path in filepaths:
if util.is_img(path):
print('Clean Mosaic:', path)
img_origin = cv2.imread(path)
x, y, size = get_mosaic_position(img_origin)
img_result = img_origin.copy()
if size != 0:
img_mosaic = img_origin[y - size:y + size, x - size:x + size]
img_fake = runmodel.run_pix2pix(img_mosaic,
netG,
use_gpu=opt.use_gpu)
img_result = replace_mosaic(img_origin, img_fake, x, y, size)
cv2.imwrite(os.path.join(opt.result_dir, os.path.basename(path)),
img_result)
import os
import numpy as np
import cv2
import random
import csv
import sys
sys.path.append("..")
from util import util, ffmpeg
from util import image_processing as impro
files = util.Traversal('./videos')
videos = util.is_videos(files)
output_dir = './datasets_img/v2im'
util.makedirs(output_dir)
FPS = 1
util.makedirs(output_dir)
for video in videos:
ffmpeg.continuous_screenshot(video, output_dir, FPS)
img = impro.resize(impro.imread(imagepaths[i]),opt.loadsize)
mask = impro.resize(impro.imread(maskpaths[i],mod = 'gray'),opt.loadsize)
img,mask = data.random_transform_image(img, mask, opt.finesize, test_flag)
images[i] = (img.transpose((2, 0, 1))/255.0)
masks[i] = (mask.reshape(1,1,opt.finesize,opt.finesize)/255.0)
images = Totensor(images,opt.use_gpu)
masks = Totensor(masks,opt.use_gpu)
return images,masks
'''
--------------------------checking dataset--------------------------
'''
print('checking dataset...')
imagepaths = sorted(util.Traversal(dir_img))[:opt.maxload]
maskpaths = sorted(util.Traversal(dir_mask))[:opt.maxload]
data.shuffledata(imagepaths, maskpaths)
if len(imagepaths) != len(maskpaths) :
print('dataset error!')
exit(0)
img_num = len(imagepaths)
print('find images:',img_num)
imagepaths_train = (imagepaths[0:int(img_num*0.8)]).copy()
maskpaths_train = (maskpaths[0:int(img_num*0.8)]).copy()
imagepaths_eval = (imagepaths[int(img_num*0.8):]).copy()
maskpaths_eval = (maskpaths[int(img_num*0.8):]).copy()
'''
--------------------------def network--------------------------
'''
#save dir
if opt.hd:
train_A_path = os.path.join(opt.savedir, 'train_A')
train_B_path = os.path.join(opt.savedir, 'train_B')
util.makedirs(train_A_path)
util.makedirs(train_B_path)
else:
train_path = os.path.join(opt.savedir, 'train')
util.makedirs(train_path)
if opt.savemask:
mask_save_path = os.path.join(opt.savedir, 'mask')
util.makedirs(mask_save_path)
#read dir
if 'drawn' in opt.mod:
imgpaths = util.Traversal(os.path.join(opt.datadir, 'origin_image'))
imgpaths.sort()
maskpaths = util.Traversal(os.path.join(opt.datadir, 'mask'))
maskpaths.sort()
if 'network' in opt.mod or 'irregular' in opt.mod:
imgpaths = util.Traversal(opt.datadir)
imgpaths = util.is_imgs(imgpaths)
random.shuffle(imgpaths)
if 'irregular' in opt.mod:
irrpaths = util.Traversal(opt.irrholedir)
#def network
if 'network' in opt.mod:
net = loadmodel.bisenet(opt, 'roi')
print('Find images:', len(imgpaths))
util.makedirs(mask_path)
if MASK:
mask_path = os.path.join(output_dir, 'mask')
util.makedirs(mask_path)
transform_mask = transforms.Compose([
transforms.RandomResizedCrop(size=512, scale=(0.5, 1)),
transforms.RandomHorizontalFlip(),
])
transform_img = transforms.Compose(
[transforms.Resize(512),
transforms.RandomCrop(512)])
mask_names = os.listdir(ir_mask_path)
img_paths = util.Traversal(img_dir)
img_paths = util.is_imgs(img_paths)
print('Find images:', len(img_paths))
for i, img_path in enumerate(img_paths, 1):
try:
img = Image.open(img_path)
img = transform_img(img)
img = np.array(img)
img = img[..., ::-1]
if BOUNDING:
mosaic_area = 0
while mosaic_area < 16384:
mask = Image.open(
os.path.join(ir_mask_path,
import os
import sys
sys.path.append("..")
from cores import Options
from util import util, ffmpeg
opt = Options()
opt.parser.add_argument('--datadir',
type=str,
default='',
help='your video dir')
opt.parser.add_argument('--savedir',
type=str,
default='../datasets/video2image',
help='')
opt = opt.getparse()
files = util.Traversal(opt.datadir)
videos = util.is_videos(files)
util.makedirs(opt.savedir)
for video in videos:
ffmpeg.continuous_screenshot(video, opt.savedir, opt.fps)