add cropping scripts

Author: JudasDie

lib/dataset/crop/DAVIS/readme.md

@@ -1,12 +1,6 @@
-# Preprocessing MSRA10K
-
-### Download raw images and annotations
-
-
-### Crop & Generate data info (~20 min)
+# Preprocessing DAVIS
 
 ````shell
-#python par_crop.py -h
 python par_crop.py --enable_mask --num_threads 24
 python gen_json.py
 ````

lib/dataset/crop/DAVIS/visual.py

@@ -0,0 +1,56 @@
+# -*- coding:utf-8 -*-
+# ! ./usr/bin/env python
+# __author__ = 'zzp'
+
+import json
+import numpy as np
+from os import listdir
+from os.path import join
+
+basepath = '/data/share/RGBT210/'
+save = dict()
+
+
+def genjson():
+    videos = listdir(basepath)
+
+    for v in videos:
+        save[v] = dict()
+        save[v]['name'] = v  # video name
+
+        # save img names
+        v_in_path = join(basepath, v, 'infrared')
+        v_rgb_path = join(basepath, v, 'visible')
+        temp1 = listdir(v_in_path)
+        temp2 = listdir(v_rgb_path)
+        temp1.sort()
+        temp2.sort()
+        save[v]['infrared_imgs'] = temp1   # infrared file names
+        save[v]['visible_imgs'] = temp2    # infrared file names
+
+        # read gt
+        v_in_gt_path = join(basepath, v, 'init.txt')
+        v_rgb_gt_path = join(basepath, v, 'init.txt')
+        v_in_gts = np.loadtxt(v_in_gt_path, delimiter=',')
+        v_rgb_gts = np.loadtxt(v_rgb_gt_path, delimiter=',')
+
+        v_in_gts[:, 0:2] = v_in_gts[:, 0:2] - 1    # to python 0 index
+        v_rgb_gts[:, 0:2] = v_rgb_gts[:, 0:2] - 1  # to python 0 index
+
+        v_in_init = v_in_gts[0]
+        v_rgb_init = v_rgb_gts[0]
+
+        # save int and gt
+        save[v]['infrared_init'] = v_in_init.tolist()
+        save[v]['visible_init'] = v_rgb_init.tolist()
+        save[v]['infrared_gt'] = v_in_gts.tolist()
+        save[v]['visible_gt'] = v_rgb_gts.tolist()
+
+    json.dump(save, open('/data/zpzhang/datasets/dataset/RGBT210.json', 'w'), indent=4, sort_keys=True)
+
+
+if __name__ == '__main__':
+    genjson()
+
+
+

lib/dataset/crop/RGBT210/RGBT210_genjson.py

@@ -0,0 +1,64 @@
+from os.path import join
+from os import listdir
+import json
+import cv2
+import numpy as np
+from pprint import pprint
+
+print('loading json (raw RGBT234 info), please wait 20 seconds~')
+RGBT210 = json.load(open('/data/zpzhang/datasets/dataset/RGBT210.json', 'r'))
+RGBT210_base_path = '/data/share/RGBT210'
+
+def check_size(frame_sz, bbox):
+    min_ratio = 0.1
+    max_ratio = 0.75
+    # only accept objects >10% and <75% of the total frame
+    area_ratio = np.sqrt((bbox[2]-bbox[0])*(bbox[3]-bbox[1])/float(np.prod(frame_sz)))
+    ok = (area_ratio > min_ratio) and (area_ratio < max_ratio)
+    return ok
+
+
+def check_borders(frame_sz, bbox):
+    dist_from_border = 0.05 * (bbox[2] - bbox[0] + bbox[3] - bbox[1])/2
+    ok = (bbox[0] > dist_from_border) and (bbox[1] > dist_from_border) and \
+         ((frame_sz[0] - bbox[2]) > dist_from_border) and \
+         ((frame_sz[1] - bbox[3]) > dist_from_border)
+    return ok
+
+
+snippets = dict()
+
+n_videos = 0
+
+
+for v_name in list(RGBT210.keys()):
+    video = RGBT210[v_name]
+    n_videos += 1
+    in_frames = video['infrared_imgs']
+    rgb_frames = video['visible_imgs']
+    snippet = dict()
+    snippets[video['name']] = dict()
+
+    # read a image to get im size
+    im_temp_path = join(RGBT210_base_path, video['name'], 'visible', rgb_frames[0])
+    im_temp = cv2.imread(im_temp_path)
+    frame_sz = [im_temp.shape[1], im_temp.shape[0]]
+
+    in_gts = video['infrared_gt']
+    rgb_gts = video['visible_gt']
+
+    for f, in_frame in enumerate(in_frames):
+        in_bbox = in_gts[f]  # (x,y,w,h)
+        rgb_bbox = rgb_gts[f]  # (x,y,w,h)
+
+        bboxs = [[in_bbox[0], in_bbox[1], in_bbox[0]+in_bbox[2], in_bbox[1]+in_bbox[3]],
+                 [rgb_bbox[0], rgb_bbox[1], rgb_bbox[0]+rgb_bbox[2], rgb_bbox[1]+rgb_bbox[3]]]  #(xmin, ymin, xmax, ymax)
+
+        imgs = [in_frames[f], rgb_frames[f]] # image name may be different in visible and rgb imgs
+
+        snippet['{:06d}'.format(f)] = [imgs, bboxs]
+
+    snippets[video['name']]['{:02d}'.format(0)] = snippet.copy()
+
+json.dump(snippets, open('/data/share/SMALLSIAM/RGBT210/all.json', 'w'), indent=4, sort_keys=True)
+print('done!')

lib/dataset/crop/RGBT210/gen_json.py

@@ -0,0 +1,140 @@
+from os.path import join, isdir, exists
+from os import listdir, mkdir, makedirs
+import cv2
+import numpy as np
+import glob
+from concurrent import futures
+import sys
+import time
+
+
+RGBT234_base_path = '/data/share/RGBT210'
+
+# Print iterations progress (thanks StackOverflow)
+def printProgress(iteration, total, prefix='', suffix='', decimals=1, barLength=100):
+    """
+    Call in a loop to create terminal progress bar
+    @params:
+        iteration   - Required  : current iteration (Int)
+        total       - Required  : total iterations (Int)
+        prefix      - Optional  : prefix string (Str)
+        suffix      - Optional  : suffix string (Str)
+        decimals    - Optional  : positive number of decimals in percent complete (Int)
+        barLength   - Optional  : character length of bar (Int)
+    """
+    formatStr       = "{0:." + str(decimals) + "f}"
+    percents        = formatStr.format(100 * (iteration / float(total)))
+    filledLength    = int(round(barLength * iteration / float(total)))
+    bar             = '' * filledLength + '-' * (barLength - filledLength)
+    sys.stdout.write('\r%s |%s| %s%s %s' % (prefix, bar, percents, '%', suffix)),
+    if iteration == total:
+        sys.stdout.write('\x1b[2K\r')
+    sys.stdout.flush()
+
+
+def crop_hwc(image, bbox, out_sz, padding=(0, 0, 0)):
+    a = (out_sz-1) / (bbox[2]-bbox[0])
+    b = (out_sz-1) / (bbox[3]-bbox[1])
+    c = -a * bbox[0]
+    d = -b * bbox[1]
+    mapping = np.array([[a, 0, c],
+                        [0, b, d]]).astype(np.float)
+    crop = cv2.warpAffine(image, mapping, (out_sz, out_sz), borderMode=cv2.BORDER_CONSTANT, borderValue=padding)
+    return crop
+
+
+def pos_s_2_bbox(pos, s):
+    return [pos[0]-s/2, pos[1]-s/2, pos[0]+s/2, pos[1]+s/2]
+
+
+def crop_like_SiamFC(image, bbox, context_amount=0.5, exemplar_size=127, instanc_size=255, padding=(0, 0, 0)):
+    target_pos = [(bbox[2]+bbox[0])/2., (bbox[3]+bbox[1])/2.]
+    target_size = [bbox[2]-bbox[0], bbox[3]-bbox[1]]   # width, height
+    wc_z = target_size[1] + context_amount * sum(target_size)
+    hc_z = target_size[0] + context_amount * sum(target_size)
+    s_z = np.sqrt(wc_z * hc_z)
+    scale_z = exemplar_size / s_z
+    d_search = (instanc_size - exemplar_size) / 2
+    pad = d_search / scale_z
+    s_x = s_z + 2 * pad
+
+    z = crop_hwc(image, pos_s_2_bbox(target_pos, s_z), exemplar_size, padding)
+    x = crop_hwc(image, pos_s_2_bbox(target_pos, s_x), instanc_size, padding)
+    return z, x
+
+
+def crop_img(im, bbox, instanc_size):
+    avg_chans = np.mean(im, axis=(0, 1))
+    z, x = crop_like_SiamFC(im, bbox, instanc_size=instanc_size, padding=avg_chans)
+    return z, x
+
+
+eps = 1e-5
+def crop_video(video, crop_path, instanc_size):
+    video_crop_base_path = join(crop_path, video)
+    if not exists(video_crop_base_path): makedirs(video_crop_base_path)
+
+    video_base_path = join(RGBT234_base_path, video)
+
+    # infrared gt
+    in_gts_path = join(video_base_path, 'init.txt')
+    try:
+        in_gts = np.loadtxt(open(in_gts_path, "rb"), delimiter=',')
+    except:
+        in_gts = np.loadtxt(open(in_gts_path, "rb"), delimiter=' ')
+
+    # rgb gt
+    rgb_gts_path = join(video_base_path, 'init.txt')
+    try:
+        rgb_gts = np.loadtxt(open(rgb_gts_path, "rb"), delimiter=',')
+    except:
+        rgb_gts = np.loadtxt(open(rgb_gts_path, "rb"), delimiter=' ')
+
+    in_jpgs = sorted(glob.glob(join(video_base_path, 'infrared', '*.jpg')))
+    rgb_jpgs = sorted(glob.glob(join(video_base_path, 'visible', '*.jpg')))
+
+
+    for idx, img_path in enumerate(in_jpgs):
+        in_im = cv2.imread(img_path)
+        rgb_im = cv2.imread(rgb_jpgs[idx])
+        in_gt = in_gts[idx]
+        rgb_gt = rgb_gts[idx]
+        in_bbox = [int(g) for g in in_gt]  # (x,y,w,h)
+
+        if abs(in_bbox[2]) < eps or abs(in_bbox[3]) < eps:
+            continue
+
+        in_bbox = [in_bbox[0], in_bbox[1], in_bbox[0]+in_bbox[2], in_bbox[1]+in_bbox[3]]   # (xmin, ymin, xmax, ymax)
+        rgb_bbox = [int(g) for g in rgb_gt]  # (x,y,w,h)
+        rgb_bbox = [rgb_bbox[0], rgb_bbox[1], rgb_bbox[0] + rgb_bbox[2], rgb_bbox[1] + rgb_bbox[3]]  # (xmin, ymin, xmax, ymax)
+
+        in_z, in_x = crop_img(in_im, in_bbox, instanc_size)
+        rgb_z, rgb_x = crop_img(rgb_im, rgb_bbox, instanc_size)
+
+        cv2.imwrite(join(video_crop_base_path, '{:06d}.{:02d}.in.z.jpg'.format(int(idx), 0)), in_z)
+        cv2.imwrite(join(video_crop_base_path, '{:06d}.{:02d}.in.x.jpg'.format(int(idx), 0)), in_x)
+
+        cv2.imwrite(join(video_crop_base_path, '{:06d}.{:02d}.rgb.z.jpg'.format(int(idx), 0)), rgb_z)
+        cv2.imwrite(join(video_crop_base_path, '{:06d}.{:02d}.rgb.x.jpg'.format(int(idx), 0)), rgb_x)
+
+
+def main(instanc_size=271, num_threads=24):
+    crop_path = '/data/share/SMALLSIAM/RGBT210/crop{:d}'.format(instanc_size)
+    if not exists(crop_path): makedirs(crop_path)
+
+    videos = sorted(listdir(RGBT234_base_path))
+    n_videos = len(videos)
+
+    with futures.ProcessPoolExecutor(max_workers=num_threads) as executor:
+        fs = [executor.submit(crop_video, video, crop_path, instanc_size) for video in videos]
+        for i, f in enumerate(futures.as_completed(fs)):
+            # Write progress to error so that it can be seen
+            printProgress(i, n_videos, prefix='RGBT210', suffix='Done ', barLength=40)
+
+
+if __name__ == '__main__':
+    since = time.time()
+    main(int(sys.argv[1]), int(sys.argv[2]))
+    time_elapsed = time.time() - since
+    print('Total complete in {:.0f}m {:.0f}s'.format(
+        time_elapsed // 60, time_elapsed % 60))

lib/dataset/crop/RGBT210/par_crop.py

@@ -0,0 +1,10 @@
+# Preprocessing RGBT234 (train and val)
+
+
+### Crop & Generate data info (20 min)
+
+````sh
+python RGBT234_genjson.py
+python par_crop.py 511 24
+python gen_json.py
+````

lib/dataset/crop/RGBT210/readme.md

@@ -0,0 +1,56 @@
+# -*- coding:utf-8 -*-
+# ! ./usr/bin/env python
+# __author__ = 'zzp'
+
+import json
+import numpy as np
+from os import listdir
+from os.path import join
+
+basepath = '/data/zpzhang/datasets/dataset/RGBT234/'
+save = dict()
+
+
+def genjson():
+    videos = listdir(basepath)
+
+    for v in videos:
+        save[v] = dict()
+        save[v]['name'] = v  # video name
+
+        # save img names
+        v_in_path = join(basepath, v, 'infrared')
+        v_rgb_path = join(basepath, v, 'visible')
+        temp1 = listdir(v_in_path)
+        temp2 = listdir(v_rgb_path)
+        temp1.sort()
+        temp2.sort()
+        save[v]['infrared_imgs'] = temp1   # infrared file names
+        save[v]['visible_imgs'] = temp2    # infrared file names
+
+        # read gt
+        v_in_gt_path = join(basepath, v, 'infrared.txt')
+        v_rgb_gt_path = join(basepath, v, 'visible.txt')
+        v_in_gts = np.loadtxt(v_in_gt_path, delimiter=',')
+        v_rgb_gts = np.loadtxt(v_rgb_gt_path, delimiter=',')
+
+        v_in_gts[:, 0:2] = v_in_gts[:, 0:2] - 1    # to python 0 index
+        v_rgb_gts[:, 0:2] = v_rgb_gts[:, 0:2] - 1  # to python 0 index
+
+        v_in_init = v_in_gts[0]
+        v_rgb_init = v_rgb_gts[0]
+
+        # save int and gt
+        save[v]['infrared_init'] = v_in_init.tolist()
+        save[v]['visible_init'] = v_rgb_init.tolist()
+        save[v]['infrared_gt'] = v_in_gts.tolist()
+        save[v]['visible_gt'] = v_rgb_gts.tolist()
+
+    json.dump(save, open('/data/zpzhang/datasets/dataset/RGBT234.json', 'w'), indent=4, sort_keys=True)
+
+
+if __name__ == '__main__':
+    genjson()
+
+
+