diff options
| -rw-r--r-- | LICENSE | 1 | ||||
| -rw-r--r-- | canny-cv.py | 26 | ||||
| -rwxr-xr-x | dataset.sh | 5 | ||||
| -rw-r--r-- | options/base_options.py | 1 | ||||
| -rw-r--r-- | options/dataset_options.py | 164 | ||||
| -rw-r--r-- | scripts/builders/flow-dir.py | 2 | ||||
| -rwxr-xr-x | scripts/builders/mogrify-dir.py | 119 | ||||
| -rw-r--r-- | scripts/flow/diff.py | 39 | ||||
| -rw-r--r-- | scripts/flow/flow-diff.py | 82 | ||||
| -rw-r--r-- | scripts/flow/flow-dir.py | 81 | ||||
| -rw-r--r-- | scripts/flow/flow-warp-recflow-recursive-fwd.py | 138 | ||||
| -rw-r--r-- | scripts/flow/flow-warp-recflow.py | 139 | ||||
| -rw-r--r-- | scripts/flow/flow-warp-recursive.py | 82 | ||||
| -rw-r--r-- | scripts/flow/flow-warp.py | 82 | ||||
| -rw-r--r-- | test.py | 4 |
15 files changed, 947 insertions, 18 deletions
@@ -1,3 +1,4 @@ +--------------------------- LICENSE FOR pytorch-pix2pix ------------------------ Copyright (c) 2017, Jun-Yan Zhu and Taesung Park All rights reserved. diff --git a/canny-cv.py b/canny-cv.py index f8b5dc3..c9ece6b 100644 --- a/canny-cv.py +++ b/canny-cv.py @@ -69,6 +69,10 @@ if __name__ == '__main__': edges_path = render_dir + "frame_{:05d}.png".format(i+1) render_path = render_dir + "ren_{:05d}.png".format(i+1) + image_pil = Image.fromarray(im, mode='RGB') + image_pil.save(tmp_path) + os.rename(tmp_path, render_path) + if dataset.name() == 'RecursiveDatasetDataLoader': # print(visuals.keys()) # s = 256 @@ -90,19 +94,15 @@ if __name__ == '__main__': tmp_im = im.copy().astype('uint8') #print(im.shape, im.dtype) - image_pil = Image.fromarray(tmp_im, mode='RGB') - image_pil.save(tmp_path) - os.rename(tmp_path, render_path) - - image_pil = Image.fromarray(im, mode='RGB') - image_pil = crop_image(image_pil, (0.50, 0.50), 0.5) - im = np.asarray(image_pil).astype('uint8') - #print(im.shape, im.dtype) - opencv_image = im[:, :, ::-1].copy() - opencv_image = cv2.GaussianBlur(opencv_image, (blur,blur), sigma) - opencv_image = cv2.Canny(opencv_image, canny_lo, canny_hi) - cv2.imwrite(tmp_path, opencv_image) - os.rename(tmp_path, edges_path) + image_pil = Image.fromarray(im, mode='RGB') + image_pil = crop_image(image_pil, (0.50, 0.50), 0.5) + im = np.asarray(image_pil).astype('uint8') + #print(im.shape, im.dtype) + opencv_image = im[:, :, ::-1].copy() + opencv_image = cv2.GaussianBlur(opencv_image, (blur,blur), sigma) + opencv_image = cv2.Canny(opencv_image, canny_lo, canny_hi) + cv2.imwrite(tmp_path, opencv_image) + os.rename(tmp_path, edges_path) webpage.save() @@ -1,2 +1,5 @@ -python datasets/combine_A_and_B.py --fold_A /home/lens/Desktop/thumbs/woodscaled_4/A --fold_B /home/lens/Desktop/thumbs/woodscaled_4/B --fold_AB datasets/woodscaled_4/ +python datasets/combine_A_and_B.py \ + --fold_A /home/lens/Desktop/thumbs/woodscaled_4/A \ + --fold_B /home/lens/Desktop/thumbs/woodscaled_4/B \ + --fold_AB datasets/woodscaled_4/ diff --git a/options/base_options.py b/options/base_options.py index 5bdd85e..150174b 100644 --- a/options/base_options.py +++ b/options/base_options.py @@ -49,6 +49,7 @@ class BaseOptions(): self.initialize() self.opt = self.parser.parse_args() self.opt.isTrain = self.isTrain # train or test + return self.opt str_ids = self.opt.gpu_ids.split(',') self.opt.gpu_ids = [] diff --git a/options/dataset_options.py b/options/dataset_options.py new file mode 100644 index 0000000..2547d11 --- /dev/null +++ b/options/dataset_options.py @@ -0,0 +1,164 @@ +from .base_options import BaseOptions + +class DatasetOptions(BaseOptions): + def initialize(self): + # BaseOptions.initialize(self) + # type = int, float, str OR action='store_true' + + # self.parser.add_argument( + # '--', + # type=int, + # default=0, + # help='' + # ) + + self.parser.add_argument( + '--in_dir', + type=str, + required=True, + help='input directory' + ) + + self.parser.add_argument( + '--out_dir', + type=str, + required=True, + help='output directory' + ) + + self.parser.add_argument( + '--split', + action='store_true', + help='construct train/test/split for this output, as A' + ) + + self.parser.add_argument( + '--ab', + action='store_true', + help='construct test split into directory A and B, where B = in_dir' + ) + + self.parser.add_argument( + '--mov', + action='store_true', + help='generate video from output directory' + ) + + self.parser.add_argument( + '--scp', + action='store_true', + help='scp this file somewhere' + ) + + self.parser.add_argument( + '--scp-to', + type=str, + default="jules@asdf.us:asdf/neural/", + help='scp destination' + ) + + ## IMAGE FILTERS + + ### GRAYSCALE + + self.parser.add_argument( + '--grayscale', + action='store_true', + help='convert image to grayscale first' + ) + + ### CLAHE + + self.parser.add_argument( + '--clahe', + action='store_true', + help='apply clahe contrast correction' + ) + + self.parser.add_argument( + '--clip-limit', + default=2.0, + type=float, + help='clip limit for clahe algorithm (1.0 is subtle, 4.0 is aggressive)' + ) + + ### POSTERIZE + + self.parser.add_argument( + '--posterize', + action='store_true', + help='posterize image' + ) + + self.parser.add_argument( + '--spatial-window', + default=16, + type=int, + help='spatial window for quantize' + ) + + self.parser.add_argument( + '--color-window', + default=64, + type=int, + help='color window for quantize' + ) + + ### BRIGHTNESS GRADIENT + + self.parser.add_argument( + '--brightness-gradient', + action='store_true', + help='gradiate from first frame to last (done in Lab colorspace)' + ) + + self.parser.add_argument( + '--brightness-sigma', + default=64, + type=int, + help='width of brightness gradient along L axis' + ) + + ### BLUR + + self.parser.add_argument( + '--blur', + default=0, + type=int, + help='blur image by N' + ) + + self.parser.add_argument( + '--blur-sigma', + default=0.0, + type=float, + help='blur sigma' + ) + + ### CANNY EDGE DETECTION + + self.parser.add_argument( + '--canny', + action='store_true', + help='do canny edge detection on image' + ) + + self.parser.add_argument( + '--canny_lo', + default=100, + type=int, + help='canny low threshold' + ) + + self.parser.add_argument( + '--canny_high', + default=200, + type=int, + help='canny high threshold' + ) + + def parse(self): + if not self.initialized: + self.initialize() + self.opt = self.parser.parse_args() + return self.opt
\ No newline at end of file diff --git a/scripts/builders/flow-dir.py b/scripts/builders/flow-dir.py index 620ba32..b59a0ac 100644 --- a/scripts/builders/flow-dir.py +++ b/scripts/builders/flow-dir.py @@ -62,7 +62,6 @@ for i,fn in enumerate(sorted(os.listdir(work_dir))): wd = "train/" if i == 1: - prev_hsv = np.copy(hsv) prev_bgr = np.copy(bgr) continue @@ -70,6 +69,5 @@ for i,fn in enumerate(sorted(os.listdir(work_dir))): cv2.imwrite(render_dir + "B/" + wd + ren, bgr) # copyfile(work_dir + fn, render_dir + "B/" + wd + ren) prev = im - prev_hsv = np.copy(hsv) prev_bgr = np.copy(bgr) diff --git a/scripts/builders/mogrify-dir.py b/scripts/builders/mogrify-dir.py new file mode 100755 index 0000000..b7370f5 --- /dev/null +++ b/scripts/builders/mogrify-dir.py @@ -0,0 +1,119 @@ +#!/Users/user/anaconda/envs/cv/bin/python + +import os + +import sys +sys.path.insert(0, '/Users/user/neural/pix2pix') +from options.dataset_options import DatasetOptions + +from shutil import move, copyfile +from PIL import Image, ImageOps +from shutil import copyfile, rmtree +import glob +import numpy as np +import subprocess +import cv2 + +opt = DatasetOptions().parse() + +in_dir = opt.in_dir +out_dir = opt.out_dir +out_base = os.path.basename(out_dir) + +if os.path.exists(out_dir): + rmtree(out_dir) + +os.makedirs(out_dir) +if opt.split is True: + os.makedirs(out_dir + "A/") + os.makedirs(out_dir + "A/train/") + os.makedirs(out_dir + "A/test/") + os.makedirs(out_dir + "A/val/") + if opt.ab is True: + os.makedirs(out_dir + "B/") + os.makedirs(out_dir + "B/train/") + os.makedirs(out_dir + "B/test/") + os.makedirs(out_dir + "B/val/") + +file = open(os.path.join(out_dir, "opt.txt"), "w") +for arg in vars(opt): + file.write("{}: {}\n".format(arg, getattr(opt, arg))) +file.close() + +images = sorted(glob.glob(os.path.join(in_dir, '*.*g'))) +image_count = len(images) +print("{}, {} images => {}".format(in_dir, image_count, out_base)) +for i, fn in enumerate(images): + pil_image = Image.open(fn).convert('RGB') + img = np.array(pil_image) + img = img[:, :, ::-1].copy() + + out_file = "frame_{:05d}.png".format(i) + + if i > 0 and (i % 100) == 0: + print("{}...".format(i)) + + lab = cv2.cvtColor(img, cv2.COLOR_BGR2LAB) + l, a, b = cv2.split(lab) + + if opt.clahe is True: + clahe = cv2.createCLAHE(clipLimit=opt.clip_limit, tileGridSize=(8,8)) + l = clahe.apply(l) + + if opt.brightness_gradient is True: + l = np.add(l.astype('float64'), ((i / image_count) - 0.5) * opt.brightness_sigma) + np.clip(l, 0, 255, out=l) + l = l.astype('uint8') + + if opt.brightness_gradient is True or opt.clahe is True: + limg = cv2.merge((l,a,b)) + img = cv2.cvtColor(limg, cv2.COLOR_LAB2BGR) + + if opt.posterize is True: + img = cv2.pyrMeanShiftFiltering(img, opt.spatial_window, opt.color_window) + if opt.grayscale is True: + img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) + if opt.blur != 0: + img = cv2.GaussianBlur(img, (opt.blur, opt.blur), opt.blur_sigma) + if opt.canny is True: + img = cv2.Canny(img, opt.canny_lo, opt.canny_hi) + + if opt.split is True: + if (i % 10) == 3: + wd = "test/" + elif (i % 10) == 6: + wd = "val/" + else: + wd = "train/" + + cv2.imwrite(out_dir + "A/" + wd + out_file, img) + if opt.ab is True: + copyfile(fn, out_dir + "B/" + wd + out_file) + + else: + cv2.imwrite(os.path.join(out_dir, out_file), img) + +print("{}...".format(image_count)) + +if opt.mov: + print("ffmpeg...") + mov_file = "{}.mp4".format(out_base) + cmd = ("ffmpeg", + "-loglevel", "quiet", + "-i", os.path.join(out_dir, "frame_%05d.png"), + "-y", "-c:v", "libx264", "-vf", "fps=30", "-pix_fmt", "yuv420p", + mov_file) + process = subprocess.Popen(cmd, stdout=subprocess.PIPE) + output, error = process.communicate() + + if opt.scp: + print("scp...") + cmd = ("scp", mov_file, opt.scp) + process = subprocess.Popen(cmd, stdout=subprocess.PIPE) + output, error = process.communicate() + + print("https://asdf.us/neural/" + mov_file) + + # cmd = ("mplayer", mov_file) + # process = subprocess.Popen(cmd, stdout=subprocess.PIPE) + # output, error = process.communicate() diff --git a/scripts/flow/diff.py b/scripts/flow/diff.py new file mode 100644 index 0000000..555f2f7 --- /dev/null +++ b/scripts/flow/diff.py @@ -0,0 +1,39 @@ +#!python3 + +from PIL import Image +import numpy as np +import os +import cv2 + +dir = 'IMG_1734/' +diff_dir = dir + 'diff/' + +if not os.path.exists(diff_dir): + os.mkdir(diff_dir) + +files = sorted([i.name for i in os.scandir(dir) if os.path.isfile(dir + i.name) and not i.name.startswith('.')]) + +last_im = None +k = 0 +for i, fn in enumerate(files): + pil_image = Image.open(dir + fn).convert('RGB') + im = np.array(pil_image) + + tmp_im = im.copy().astype('float64') + print("{} {}".format(i, fn)) + if last_im is not None: + im = (last_im - tmp_im) + im = cv2.normalize(im, None, 0, 255, cv2.NORM_MINMAX) + image_pil = Image.fromarray(im.astype('uint8'), mode='RGB') + image_pil.save(diff_dir + "frame_{:05}.png".format(i)) + + last_im = tmp_im.astype('float64') + +def fade_images(a, b, n): + for j in range(60): + r = j / 60 + im = a * (r) + b * (1-r) + image_pil = Image.fromarray(im.astype('uint8'), mode='RGB') + image_pil.save(diff_dir + "frame_{:05}.png".format(j+k)) + k += 60 + diff --git a/scripts/flow/flow-diff.py b/scripts/flow/flow-diff.py new file mode 100644 index 0000000..4bd4465 --- /dev/null +++ b/scripts/flow/flow-diff.py @@ -0,0 +1,82 @@ +import os +import sys +from shutil import move, copyfile +from PIL import Image, ImageOps +from shutil import copyfile, rmtree +import numpy as np +import cv2 + +work_dir = "IMG_1734/" +render_dir = "IMG_1734/flowdiff/" + +if os.path.exists(render_dir): + rmtree(render_dir) + +os.makedirs(render_dir) +os.makedirs(render_dir + 'prev/') +os.makedirs(render_dir + 'next/') + +def warp_flow(img, flow): + h, w = flow.shape[:2] + flow = -flow + flow[:,:,0] += np.arange(w) + flow[:,:,1] += np.arange(h)[:,np.newaxis] + res = cv2.remap(img, flow, None, cv2.INTER_LINEAR) + return res + +hsv = [] +prev = None +prev_bgr = None +gray = None +prev_gray = None + +for i,fn in enumerate(sorted(os.listdir(work_dir))): + if os.path.basename(fn).startswith('.') or not os.path.isfile(work_dir + fn): + continue + + # load image and convert to grayscale + pil_image = Image.open(work_dir + fn).convert('RGB') + im = np.array(pil_image) + im = im[:, :, ::-1].copy() + gray = cv2.cvtColor(im, cv2.COLOR_BGR2GRAY) + + # store first frame + if prev_gray is None: + prev = im + prev_gray = gray + #hsv = np.zeros((256,512,3)) + #hsv[...,1] = 255 + continue + + # compute optical flow + flow = cv2.calcOpticalFlowFarneback(prev_gray, gray, None, 0.5, 3, 15, 3, 5, 1.2, 0) + + #mag, ang = cv2.cartToPolar(flow[...,0], flow[...,1]) + #hsv[...,0] = ang * 180 / np.pi / 2 + #hsv[...,2] = cv2.normalize(mag, None, 0, 255, cv2.NORM_L2) + #bgr = cv2.cvtColor(hsv.astype('uint8'), cv2.COLOR_HSV2BGR) + + #if prev_bgr is None: + # prev_bgr = np.copy(bgr) + # continue + + #if (i % 10) == 3: + # wd = "test/" + #elif (i % 10) == 6: + # wd = "val/" + #else: + # wd = "train/" + + out_prev = warp_flow(prev, flow) + out_next = warp_flow(im, flow) + ren = "frame_{:05d}.png".format(i) + + #cv2.imwrite(render_dir + "A/" + wd + ren, prev_bgr) + #cv2.imwrite(render_dir + "B/" + wd + ren, bgr) + cv2.imwrite(render_dir + "prev/" + ren, out_prev) + cv2.imwrite(render_dir + "next/" + ren, out_next) + # copyfile(work_dir + fn, render_dir + "B/" + wd + ren) + prev = im + prev_gray = gray + #prev_bgr = np.copy(bgr) + diff --git a/scripts/flow/flow-dir.py b/scripts/flow/flow-dir.py new file mode 100644 index 0000000..60c1dd9 --- /dev/null +++ b/scripts/flow/flow-dir.py @@ -0,0 +1,81 @@ +import os +import sys +from shutil import move, copyfile +from PIL import Image, ImageOps +from shutil import copyfile, rmtree +import numpy as np +import cv2 + +work_dir = "IMG_1734/" +render_dir = "IMG_1734/diff/" + +if os.path.exists(render_dir): + rmtree(render_dir) + +os.makedirs(render_dir) +os.makedirs(render_dir + "A/") +os.makedirs(render_dir + "A/train/") +os.makedirs(render_dir + "A/test/") +os.makedirs(render_dir + "A/val/") +os.makedirs(render_dir + "B/") +os.makedirs(render_dir + "B/train/") +os.makedirs(render_dir + "B/test/") +os.makedirs(render_dir + "B/val/") +os.makedirs(render_dir + "out/") + +hsv = [] +prev = None +prev_bgr = None + +for i,fn in enumerate(sorted(os.listdir(work_dir))): + if os.path.basename(fn).startswith('.') or not os.path.isfile(work_dir + fn): + continue + + # load image and convert to grayscale + pil_image = Image.open(work_dir + fn).convert('RGB') + im = np.array(pil_image) + im = im[:, :, ::-1].copy() + im = cv2.cvtColor(im, cv2.COLOR_BGR2GRAY) + + # store first frame + if prev is None: + prev = im + hsv = np.zeros((256,512,3)) + hsv[...,1] = 255 + continue + + # compute optical flow + flow = cv2.calcOpticalFlowFarneback(prev, im, None, 0.5, 3, 15, 3, 5, 1.2, 0) + + # turn into magnitude/angle + mag, ang = cv2.cartToPolar(flow[...,0], flow[...,1]) + + # store angle as hue + hsv[...,0] = ang * 180 / np.pi / 2 + + # store magnitude as lum + hsv[...,2] = cv2.normalize(mag, None, 0, 255, cv2.NORM_L2) + + # convert this HSL to BGR + bgr = cv2.cvtColor(hsv.astype('uint8'), cv2.COLOR_HSV2BGR) + + if prev_bgr is None: + prev_bgr = np.copy(bgr) + continue + + if (i % 10) == 3: + wd = "test/" + elif (i % 10) == 6: + wd = "val/" + else: + wd = "train/" + + ren = "frame_{:05d}.png".format(i) + + #cv2.imwrite(render_dir + "A/" + wd + ren, prev_bgr) + #cv2.imwrite(render_dir + "B/" + wd + ren, bgr) + cv2.imwrite(render_dir + "out/" + ren, bgr) + # copyfile(work_dir + fn, render_dir + "B/" + wd + ren) + prev = im + prev_bgr = np.copy(bgr) + diff --git a/scripts/flow/flow-warp-recflow-recursive-fwd.py b/scripts/flow/flow-warp-recflow-recursive-fwd.py new file mode 100644 index 0000000..4d15cc2 --- /dev/null +++ b/scripts/flow/flow-warp-recflow-recursive-fwd.py @@ -0,0 +1,138 @@ +import os +import sys +from shutil import move, copyfile +from PIL import Image, ImageOps +from shutil import copyfile, rmtree +import numpy as np +import cv2 + +from_dir = "IMG_1734/" +to_dir = "IMG_1738/" +render_dir = "flowwarp_transfer_cross/" + +if os.path.exists(render_dir): + rmtree(render_dir) + +os.makedirs(render_dir) +os.makedirs(render_dir + 'out_fwd_from/') +os.makedirs(render_dir + 'out_rvr_from/') +os.makedirs(render_dir + 'out_fwd_from_rec/') +os.makedirs(render_dir + 'out_rvr_from_rec/') +os.makedirs(render_dir + 'out_fwd_to/') +os.makedirs(render_dir + 'out_rvr_to/') +os.makedirs(render_dir + 'out_fwd_to_rec/') +os.makedirs(render_dir + 'out_rvr_to_rec/') + +def warp_flow(img, flow): + h, w = flow.shape[:2] + flow = -flow + flow[:,:,0] += np.arange(w) + flow[:,:,1] += np.arange(h)[:,np.newaxis] + res = cv2.remap(img, flow, None, cv2.INTER_LINEAR) + return res +def load(path): + pil_image = Image.open(path).convert('RGB') + im = np.array(pil_image) + im = im[:, :, ::-1].copy() + gray = cv2.cvtColor(im, cv2.COLOR_BGR2GRAY) + return im, gray + +def get_files(d): + return sorted([i.name for i in os.scandir(d) if os.path.isfile(d + i.name) and not i.name.startswith('.') and i.name.endswith('png')]) + +hsv = [] +prev = None +prev_bgr = None +gray = None +prev_gray = None +prev_from = None +prev_fwd_from = None +prev_rvr_from = None +prev_from_gray = None +prev_to = None +prev_fwd_to = None +prev_rvr_to = None +prev_to_gray = None + +from_files = get_files(from_dir) +to_files = get_files(to_dir) + +for i,from_fn in enumerate(from_files): + print(from_fn) + to_fn = to_files[i] + + # load image and convert to grayscale + from_im, from_gray = load(from_dir + from_fn) + to_im, to_gray = load(to_dir + to_fn) + + # store first frame + if prev_from_gray is None: + prev_fwd_from = from_im + prev_rvr_from = from_im + prev_from_gray = from_gray + prev_fwd_to = to_im + prev_rvr_to = to_im + prev_to_gray = to_gray + #hsv = np.zeros((256,512,3)) + #hsv[...,1] = 255 + continue + + # compute optical flow + from_fwd_flow = cv2.calcOpticalFlowFarneback(prev_from_gray, from_gray, None, 0.5, 3, 15, 3, 5, 1.2, 0) + #from_rvr_flow = cv2.calcOpticalFlowFarneback(from_gray, prev_from_gray, None, 0.5, 3, 15, 3, 5, 1.2, 0) + #to_fwd_flow = cv2.calcOpticalFlowFarneback(prev_to_gray, to_gray, None, 0.5, 3, 15, 3, 5, 1.2, 0) + #to_rvr_flow = cv2.calcOpticalFlowFarneback(to_gray, prev_to_gray, None, 0.5, 3, 15, 3, 5, 1.2, 0) + #cross_fwd_flow = cv2.calcOpticalFlowFarneback(from_gray, to_gray, None, 0.5, 3, 15, 3, 5, 1.2, 0) + #cross_rvr_flow = cv2.calcOpticalFlowFarneback(to_gray, from_gray, None, 0.5, 3, 15, 3, 5, 1.2, 0) + + #mag, ang = cv2.cartToPolar(flow[...,0], flow[...,1]) + #hsv[...,0] = ang * 180 / np.pi / 2 + #hsv[...,2] = cv2.normalize(mag, None, 0, 255, cv2.NORM_L2) + #bgr = cv2.cvtColor(hsv.astype('uint8'), cv2.COLOR_HSV2BGR) + + #if prev_bgr is None: + # prev_bgr = np.copy(bgr) + # continue + + #if (i % 10) == 3: + # wd = "test/" + #elif (i % 10) == 6: + # wd = "val/" + #else: + # wd = "train/" + + fwd_flow = from_fwd_flow + #rvr_flow = from_rvr_flow + out_fwd_from = warp_flow(from_im, fwd_flow) + out_fwd_from_rec = warp_flow(prev_fwd_from, fwd_flow) + out_fwd_to = warp_flow(to_im, fwd_flow) + out_fwd_to_rec = warp_flow(prev_fwd_to, fwd_flow) + + #out_rvr_from = warp_flow(from_im, rvr_flow) + #out_rvr_from_rec = warp_flow(prev_rvr_from, rvr_flow) + #out_rvr_to = warp_flow(to_im, rvr_flow) + #out_rvr_to_rec = warp_flow(prev_rvr_to, rvr_flow) + + ren = "frame_{:05d}.png".format(i) + #cv2.imwrite(render_dir + "A/" + wd + ren, prev_bgr) + #cv2.imwrite(render_dir + "B/" + wd + ren, bgr) + cv2.imwrite(render_dir + "out_fwd_from/" + ren, out_fwd_from) + cv2.imwrite(render_dir + "out_fwd_from_rec/" + ren, out_fwd_from_rec) + cv2.imwrite(render_dir + "out_fwd_to/" + ren, out_fwd_to) + cv2.imwrite(render_dir + "out_fwd_to_rec/" + ren, out_fwd_to_rec) + #cv2.imwrite(render_dir + "out_rvr_from/" + ren, out_rvr_from) + #cv2.imwrite(render_dir + "out_rvr_from_rec/" + ren, out_rvr_from_rec) + #cv2.imwrite(render_dir + "out_rvr_to/" + ren, out_rvr_to) + #cv2.imwrite(render_dir + "out_rvr_to_rec/" + ren, out_rvr_to_rec) + #cv2.imwrite(render_dir + "next/" + ren, out_next) + # copyfile(work_dir + fn, render_dir + "B/" + wd + ren) + + prev_from_gray = from_gray + prev_to_gray = to_gray + if i > 3: + prev_fwd_from = out_fwd_from_rec + prev_fwd_to = out_fwd_to_rec + #prev_rvr_from = out_rvr_from_rec + #prev_rvr_to = out_rvr_to_rec + #prev_bgr = np.copy(bgr) + diff --git a/scripts/flow/flow-warp-recflow.py b/scripts/flow/flow-warp-recflow.py new file mode 100644 index 0000000..5e0d7ac --- /dev/null +++ b/scripts/flow/flow-warp-recflow.py @@ -0,0 +1,139 @@ +import os +import sys +from shutil import move, copyfile +from PIL import Image, ImageOps +from shutil import copyfile, rmtree +import numpy as np +import cv2 + +from_dir = "IMG_1734/" +to_dir = "IMG_1738/" +render_dir = "flowwarp_transfer_cross/" + +if os.path.exists(render_dir): + rmtree(render_dir) + +os.makedirs(render_dir) +os.makedirs(render_dir + 'out_fwd_from/') +os.makedirs(render_dir + 'out_rvr_from/') +os.makedirs(render_dir + 'out_fwd_from_rec/') +os.makedirs(render_dir + 'out_rvr_from_rec/') +os.makedirs(render_dir + 'out_fwd_to/') +os.makedirs(render_dir + 'out_rvr_to/') +os.makedirs(render_dir + 'out_fwd_to_rec/') +os.makedirs(render_dir + 'out_rvr_to_rec/') + +def warp_flow(img, flow): + h, w = flow.shape[:2] + flow = -flow + flow[:,:,0] += np.arange(w) + flow[:,:,1] += np.arange(h)[:,np.newaxis] + res = cv2.remap(img, flow, None, cv2.INTER_LINEAR) + return res +def load(path): + pil_image = Image.open(path).convert('RGB') + im = np.array(pil_image) + im = im[:, :, ::-1].copy() + gray = cv2.cvtColor(im, cv2.COLOR_BGR2GRAY) + return im, gray + +def get_files(d): + return sorted([i.name for i in os.scandir(d) if os.path.isfile(d + i.name) and not i.name.startswith('.') and i.name.endswith('png')]) + +hsv = [] +prev = None +prev_bgr = None +gray = None +prev_gray = None +prev_from = None +prev_fwd_from = None +prev_rvr_from = None +prev_from_gray = None +prev_to = None +prev_fwd_to = None +prev_rvr_to = None +prev_to_gray = None + +from_files = get_files(from_dir) +to_files = get_files(to_dir) + +for i,from_fn in enumerate(from_files): + print(from_fn) + to_fn = to_files[i] + + # load image and convert to grayscale + from_im, from_gray = load(from_dir + from_fn) + to_im, to_gray = load(to_dir + to_fn) + + # store first frame + if prev_from_gray is None: + prev_fwd_from = from_im + prev_rvr_from = from_im + prev_from_gray = from_gray + prev_fwd_to = to_im + prev_rvr_to = to_im + prev_to_gray = to_gray + #hsv = np.zeros((256,512,3)) + #hsv[...,1] = 255 + continue + + # compute optical flow + from_fwd_flow = cv2.calcOpticalFlowFarneback(prev_from_gray, from_gray, None, 0.5, 3, 15, 3, 5, 1.2, 0) + #from_rvr_flow = cv2.calcOpticalFlowFarneback(from_gray, prev_from_gray, None, 0.5, 3, 15, 3, 5, 1.2, 0) + #to_fwd_flow = cv2.calcOpticalFlowFarneback(prev_to_gray, to_gray, None, 0.5, 3, 15, 3, 5, 1.2, 0) + #to_rvr_flow = cv2.calcOpticalFlowFarneback(to_gray, prev_to_gray, None, 0.5, 3, 15, 3, 5, 1.2, 0) + #cross_fwd_flow = cv2.calcOpticalFlowFarneback(from_gray, to_gray, None, 0.5, 3, 15, 3, 5, 1.2, 0) + #cross_rvr_flow = cv2.calcOpticalFlowFarneback(to_gray, from_gray, None, 0.5, 3, 15, 3, 5, 1.2, 0) + + #mag, ang = cv2.cartToPolar(flow[...,0], flow[...,1]) + #hsv[...,0] = ang * 180 / np.pi / 2 + #hsv[...,2] = cv2.normalize(mag, None, 0, 255, cv2.NORM_L2) + #bgr = cv2.cvtColor(hsv.astype('uint8'), cv2.COLOR_HSV2BGR) + + #if prev_bgr is None: + # prev_bgr = np.copy(bgr) + # continue + + #if (i % 10) == 3: + # wd = "test/" + #elif (i % 10) == 6: + # wd = "val/" + #else: + # wd = "train/" + + fwd_flow = from_fwd_flow + #rvr_flow = from_rvr_flow + out_fwd_from = warp_flow(from_im, fwd_flow) + out_fwd_from_rec = warp_flow(prev_fwd_from, fwd_flow) + out_fwd_to = warp_flow(to_im, fwd_flow) + out_fwd_to_rec = warp_flow(prev_fwd_to, fwd_flow) + + #out_rvr_from = warp_flow(from_im, rvr_flow) + #out_rvr_from_rec = warp_flow(prev_rvr_from, rvr_flow) + #out_rvr_to = warp_flow(to_im, rvr_flow) + #out_rvr_to_rec = warp_flow(prev_rvr_to, rvr_flow) + + ren = "frame_{:05d}.png".format(i) + #cv2.imwrite(render_dir + "A/" + wd + ren, prev_bgr) + #cv2.imwrite(render_dir + "B/" + wd + ren, bgr) + cv2.imwrite(render_dir + "out_fwd_from/" + ren, out_fwd_from) + cv2.imwrite(render_dir + "out_fwd_from_rec/" + ren, out_fwd_from_rec) + cv2.imwrite(render_dir + "out_fwd_to/" + ren, out_fwd_to) + cv2.imwrite(render_dir + "out_fwd_to_rec/" + ren, out_fwd_to_rec) + #cv2.imwrite(render_dir + "out_rvr_from/" + ren, out_rvr_from) + #cv2.imwrite(render_dir + "out_rvr_from_rec/" + ren, out_rvr_from_rec) + #cv2.imwrite(render_dir + "out_rvr_to/" + ren, out_rvr_to) + #cv2.imwrite(render_dir + "out_rvr_to_rec/" + ren, out_rvr_to_rec) + #cv2.imwrite(render_dir + "next/" + ren, out_next) + # copyfile(work_dir + fn, render_dir + "B/" + wd + ren) + + prev_from_gray = from_gray + prev_to_gray = to_gray + if i > 3: + prev_from_gray = cv2.cvtColor(out_fwd_from_rec, cv2.COLOR_BGR2GRAY) + prev_fwd_from = out_fwd_from_rec + prev_fwd_to = out_fwd_to_rec + #prev_rvr_from = out_rvr_from_rec + #prev_rvr_to = out_rvr_to_rec + #prev_bgr = np.copy(bgr) + diff --git a/scripts/flow/flow-warp-recursive.py b/scripts/flow/flow-warp-recursive.py new file mode 100644 index 0000000..7b08941 --- /dev/null +++ b/scripts/flow/flow-warp-recursive.py @@ -0,0 +1,82 @@ +import os +import sys +from shutil import move, copyfile +from PIL import Image, ImageOps +from shutil import copyfile, rmtree +import numpy as np +import cv2 + +work_dir = "IMG_1734/" +render_dir = "IMG_1734/flowwarprecursive/" + +if os.path.exists(render_dir): + rmtree(render_dir) + +os.makedirs(render_dir) +os.makedirs(render_dir + 'prev/') +os.makedirs(render_dir + 'next/') + +def warp_flow(img, flow): + h, w = flow.shape[:2] + flow = -flow + flow[:,:,0] += np.arange(w) + flow[:,:,1] += np.arange(h)[:,np.newaxis] + res = cv2.remap(img, flow, None, cv2.INTER_LINEAR) + return res + +hsv = [] +prev = None +prev_bgr = None +gray = None +prev_gray = None + +for i,fn in enumerate(sorted(os.listdir(work_dir))): + if os.path.basename(fn).startswith('.') or not os.path.isfile(work_dir + fn): + continue + + # load image and convert to grayscale + pil_image = Image.open(work_dir + fn).convert('RGB') + im = np.array(pil_image) + im = im[:, :, ::-1].copy() + gray = cv2.cvtColor(im, cv2.COLOR_BGR2GRAY) + + # store first frame + if prev_gray is None: + prev = im + prev_gray = gray + #hsv = np.zeros((256,512,3)) + #hsv[...,1] = 255 + continue + + # compute optical flow + flow = cv2.calcOpticalFlowFarneback(prev_gray, gray, None, 0.5, 3, 15, 3, 5, 1.2, 0) + + #mag, ang = cv2.cartToPolar(flow[...,0], flow[...,1]) + #hsv[...,0] = ang * 180 / np.pi / 2 + #hsv[...,2] = cv2.normalize(mag, None, 0, 255, cv2.NORM_L2) + #bgr = cv2.cvtColor(hsv.astype('uint8'), cv2.COLOR_HSV2BGR) + + #if prev_bgr is None: + # prev_bgr = np.copy(bgr) + # continue + + #if (i % 10) == 3: + # wd = "test/" + #elif (i % 10) == 6: + # wd = "val/" + #else: + # wd = "train/" + + out_prev = warp_flow(prev, flow) + #out_next = warp_flow(im, flow) + ren = "frame_{:05d}.png".format(i) + + #cv2.imwrite(render_dir + "A/" + wd + ren, prev_bgr) + #cv2.imwrite(render_dir + "B/" + wd + ren, bgr) + cv2.imwrite(render_dir + "prev/" + ren, out_prev) + #cv2.imwrite(render_dir + "next/" + ren, out_next) + # copyfile(work_dir + fn, render_dir + "B/" + wd + ren) + prev = out_prev + #prev_gray = gray + #prev_bgr = np.copy(bgr) + diff --git a/scripts/flow/flow-warp.py b/scripts/flow/flow-warp.py new file mode 100644 index 0000000..3c7735a --- /dev/null +++ b/scripts/flow/flow-warp.py @@ -0,0 +1,82 @@ +import os +import sys +from shutil import move, copyfile +from PIL import Image, ImageOps +from shutil import copyfile, rmtree +import numpy as np +import cv2 + +work_dir = "IMG_1734/" +render_dir = "IMG_1734/flowwarp/" + +if os.path.exists(render_dir): + rmtree(render_dir) + +os.makedirs(render_dir) +os.makedirs(render_dir + 'prev/') +os.makedirs(render_dir + 'next/') + +def warp_flow(img, flow): + h, w = flow.shape[:2] + flow = -flow + flow[:,:,0] += np.arange(w) + flow[:,:,1] += np.arange(h)[:,np.newaxis] + res = cv2.remap(img, flow, None, cv2.INTER_LINEAR) + return res + +hsv = [] +prev = None +prev_bgr = None +gray = None +prev_gray = None + +for i,fn in enumerate(sorted(os.listdir(work_dir))): + if os.path.basename(fn).startswith('.') or not os.path.isfile(work_dir + fn): + continue + + # load image and convert to grayscale + pil_image = Image.open(work_dir + fn).convert('RGB') + im = np.array(pil_image) + im = im[:, :, ::-1].copy() + gray = cv2.cvtColor(im, cv2.COLOR_BGR2GRAY) + + # store first frame + if prev_gray is None: + prev = im + prev_gray = gray + #hsv = np.zeros((256,512,3)) + #hsv[...,1] = 255 + continue + + # compute optical flow + flow = cv2.calcOpticalFlowFarneback(prev_gray, gray, None, 0.5, 3, 15, 3, 5, 1.2, 0) + + #mag, ang = cv2.cartToPolar(flow[...,0], flow[...,1]) + #hsv[...,0] = ang * 180 / np.pi / 2 + #hsv[...,2] = cv2.normalize(mag, None, 0, 255, cv2.NORM_L2) + #bgr = cv2.cvtColor(hsv.astype('uint8'), cv2.COLOR_HSV2BGR) + + #if prev_bgr is None: + # prev_bgr = np.copy(bgr) + # continue + + #if (i % 10) == 3: + # wd = "test/" + #elif (i % 10) == 6: + # wd = "val/" + #else: + # wd = "train/" + + out_prev = warp_flow(prev, flow) + #out_next = warp_flow(im, flow) + ren = "frame_{:05d}.png".format(i) + + #cv2.imwrite(render_dir + "A/" + wd + ren, prev_bgr) + #cv2.imwrite(render_dir + "B/" + wd + ren, bgr) + cv2.imwrite(render_dir + "prev/" + ren, out_prev) + #cv2.imwrite(render_dir + "next/" + ren, out_next) + # copyfile(work_dir + fn, render_dir + "B/" + wd + ren) + #prev = im + #prev_gray = gray + #prev_bgr = np.copy(bgr) + @@ -62,8 +62,8 @@ if __name__ == '__main__': # image_pil.save(save_path) # copyfile(save_path, final_path) if last_im is not None: - frac_a = 999/1000 - frac_b = 1/1000 + frac_a = 0.5 + frac_b = 1.0 - frac_a tmp_im = im.copy() array_a = np.multiply(im, frac_a) array_b = np.multiply(last_im, frac_b) |