From 721d5e410e5a2b47ec2de722cc02fd6b9ed6b2fd Mon Sep 17 00:00:00 2001
From: Edmond Yoo <hj3yoo@uwaterloo.ca>
Date: Sun, 16 Sep 2018 03:19:06 +0000
Subject: [PATCH] reverting merge
---
/dev/null | 567 --------------------------------------------------------
1 files changed, 0 insertions(+), 567 deletions(-)
diff --git a/card_detector.py b/card_detector.py
deleted file mode 100644
index aa8bd6a..0000000
--- a/card_detector.py
+++ /dev/null
@@ -1,124 +0,0 @@
-import cv2
-import numpy as np
-import pandas as pd
-import math
-from screeninfo import get_monitors
-
-
-def detect_a_card(img, thresh_val=80, blur_radius=None, dilate_radius=None, min_hyst=80, max_hyst=200,
- min_line_length=None, max_line_gap=None, debug=False):
- dim_img = (len(img[0]), len(img)) # (width, height)
- # Intermediate variables
-
- # Default values
- if blur_radius is None:
- blur_radius = math.floor(min(dim_img) / 100 + 0.5) // 2 * 2 + 1 # Rounded to the nearest odd
- if dilate_radius is None:
- dilate_radius = math.floor(min(dim_img) / 67 + 0.5)
- if min_line_length is None:
- min_line_length = min(dim_img) / 10
- if max_line_gap is None:
- max_line_gap = min(dim_img) / 10
-
- thresh_radius = math.floor(min(dim_img) / 20 + 0.5) // 2 * 2 + 1 # Rounded to the nearest odd
-
- img_gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
- # Median blur better removes background textures than Gaussian blur
- img_blur = cv2.medianBlur(img_gray, blur_radius)
- # Truncate the bright area while detecting the border
- img_thresh = cv2.adaptiveThreshold(img_blur, 255, cv2.ADAPTIVE_THRESH_MEAN_C,
- cv2.THRESH_BINARY_INV, thresh_radius, 20)
- #_, img_thresh = cv2.threshold(img_blur, thresh_val, 255, cv2.THRESH_TRUNC)
-
- # Dilate the image to emphasize thick borders around the card
- kernel_dilate = np.ones((dilate_radius, dilate_radius), np.uint8)
- #img_dilate = cv2.dilate(img_thresh, kernel_dilate, iterations=1)
- img_dilate = cv2.erode(img_thresh, kernel_dilate, iterations=1)
-
- img_contour = img_dilate.copy()
- _, contours, _ = cv2.findContours(img_contour, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)
- img_contour = cv2.cvtColor(img_contour, cv2.COLOR_GRAY2BGR)
- img_contour = cv2.drawContours(img_contour, contours, -1, (128, 128, 128), 1)
- card_found = contours is not None
- print(len(contours))
- print([len(contour) for contour in contours])
-
- # find the biggest area
- c = max(contours, key=cv2.contourArea)
-
- x, y, w, h = cv2.boundingRect(c)
- # draw the book contour (in green)
- img_contour = cv2.drawContours(img_contour, [c], -1, (0, 255, 0), 1)
-
- # Canny edge - low minimum hysteresis to detect glowed area,
- # and high maximum hysteresis to compensate for high false positives.
- img_canny = cv2.Canny(img_dilate, min_hyst, max_hyst)
- #img_canny = img_dilate
- # Apply Hough transformation to detect the edges
- detected_lines = cv2.HoughLinesP(img_dilate, 1, np.pi / 180, threshold=60,
- minLineLength=min_line_length,
- maxLineGap=max_line_gap)
- card_found = detected_lines is not None
- print(len(detected_lines))
-
- if card_found:
- if debug:
- img_hough = cv2.cvtColor(img_dilate.copy(), cv2.COLOR_GRAY2BGR)
- for line in detected_lines:
- x1, y1, x2, y2 = line[0]
- cv2.line(img_hough, (x1, y1), (x2, y2), (0, 0, 255), 1)
- elif not debug:
- print('Hough couldn\'t find any lines')
-
- # Debug: display intermediate results from various steps
- if debug:
- img_blank = np.zeros((len(img), len(img[0]), 3), np.uint8)
- img_thresh = cv2.cvtColor(img_thresh, cv2.COLOR_GRAY2BGR)
- img_dilate = cv2.cvtColor(img_dilate, cv2.COLOR_GRAY2BGR)
- #img_canny = cv2.cvtColor(img_canny, cv2.COLOR_GRAY2BGR)
- if not card_found:
- img_hough = img_blank
-
- # Append all images together
- img_row_1 = np.concatenate((img, img_thresh), axis=1)
- img_row_2 = np.concatenate((img_contour, img_hough), axis=1)
- img_result = np.concatenate((img_row_1, img_row_2), axis=0)
-
- # Resize the final image to fit into the main monitor's resolution
- screen_size = get_monitors()[0]
- resize_ratio = max(len(img_result[0]) / screen_size.width, len(img_result) / screen_size.height, 1)
- img_result = cv2.resize(img_result, (int(len(img_result[0]) // resize_ratio),
- int(len(img_result) // resize_ratio)))
- cv2.imshow('Result', img_result)
- cv2.waitKey(0)
-
- # TODO: output meaningful data
- return card_found
-
-def main():
- img_test = cv2.imread('data/li38_handOfCards.jpg')
- card_found = detect_a_card(img_test,
- #dilate_radius=5,
- #thresh_val=100,
- #min_hyst=40,
- #max_hyst=160,
- #min_line_length=50,
- #max_line_gap=100,
- debug=True)
- if card_found:
- return
- return
- for dilate_radius in range(1, 6):
- for min_hyst in range(50, 91, 10):
- for max_hyst in range(180, 119, -20):
- print('dilate_radius=%d, min_hyst=%d, max_hyst=%d: ' % (dilate_radius, min_hyst, max_hyst),
- end='', flush=True)
- card_found = detect_a_card(img_test, dilate_radius=dilate_radius,
- min_hyst=min_hyst, max_hyst=max_hyst, debug=True)
- if card_found:
- print('Card found')
- else:
- print('Not found')
-
-if __name__ == '__main__':
- main()
diff --git a/fetch_data.py b/fetch_data.py
deleted file mode 100644
index 221e16c..0000000
--- a/fetch_data.py
+++ /dev/null
@@ -1,107 +0,0 @@
-from urllib import request
-import ast
-import json
-import pandas as pd
-import re
-import os
-import transform_data
-import time
-
-all_set_list = ['cmd', 'bfz', 'all', 'ulg',
- 'mrd', 'dst', '5dn', 'chk', 'bok', 'sok', 'rav', 'gpt', 'dis', 'csp', 'tsp', 'plc', 'fut',
- '10e', 'lrw', 'mor', 'shm', 'eve', 'ala', 'con', 'arb', 'm10', 'zen', 'wwk', 'roe', 'm11', 'som', 'mbs',
- 'nph', 'm12', 'isd', 'dka', 'avr', 'm13', 'rtr', 'gtc', 'dgm', 'm14', 'ths', 'bng', 'jou']
-
-
-def fetch_all_cards_text(url='https://api.scryfall.com/cards/search?q=layout:normal+format:modern+lang:en+frame:2003',
- csv_name=''):
- has_more = True
- cards = []
- # get cards dataset as a json from the query
- while has_more:
- res_file_dir, http_message = request.urlretrieve(url)
- with open(res_file_dir, 'r') as res_file:
- res_json = json.loads(res_file.read())
- cards += res_json['data']
- has_more = res_json['has_more']
- if has_more:
- url = res_json['next_page']
- print(len(cards))
-
- # Convert them into a dataframe, and truncate unnecessary columns
- df = pd.DataFrame.from_dict(cards)
-
- if csv_name != '':
- df = df[['artist', 'border_color', 'collector_number', 'color_identity', 'colors', 'flavor_text', 'image_uris',
- 'mana_cost', 'legalities', 'name', 'oracle_text', 'rarity', 'type_line', 'set', 'set_name', 'power',
- 'toughness']]
- #df.to_json(csv_name)
- df.to_csv(csv_name, sep=';') # Comma doesn't work, since some columns are saved as a dict
-
- return df
-
-
-def load_all_cards_text(csv_name):
- #with open(csv_name, 'r') as json_file:
- # cards = json.loads(json_file.read())
- #df = pd.DataFrame.from_dict(cards)
- df = pd.read_csv(csv_name, sep=';')
- return df
-
-
-# Pulled from Django framework (https://github.com/django/django/blob/master/django/utils/text.py)
-def get_valid_filename(s):
- """
- Return the given string converted to a string that can be used for a clean
- filename. Remove leading and trailing spaces; convert other spaces to
- underscores; and remove anything that is not an alphanumeric, dash,
- underscore, or dot.
- >>> get_valid_filename("john's portrait in 2004.jpg")
- 'johns_portrait_in_2004.jpg'
- """
- s = str(s).strip().replace(' ', '_')
- return re.sub(r'(?u)[^-\w.]', '', s)
-
-
-def fetch_all_cards_image(df, out_dir='', size='png'):
- if isinstance(df, pd.Series):
- fetch_card_image(df, out_dir, size)
- else:
- for ind, row in df.iterrows():
- fetch_card_image(row, out_dir, size)
-
-
-def fetch_card_image(row, out_dir='', size='png'):
- if isinstance(row['image_uris'], str): # For some reason, dict isn't being parsed in the previous step
- png_url = ast.literal_eval(row['image_uris'])[size]
- else:
- png_url = row['image_uris'][size]
- if out_dir == '':
- out_dir = 'data/%s/%s' % (size, row['set'])
- if not os.path.exists(out_dir):
- os.makedirs(out_dir)
- img_name = '%s/%s_%s.png' % (out_dir, row['collector_number'], get_valid_filename(row['name']))
- if not os.path.isfile(img_name):
- request.urlretrieve(png_url, filename=img_name)
- print(img_name)
-
-
-def main():
- for set_name in all_set_list:
- csv_name = '%s/csv/%s.csv' % (transform_data.data_dir, set_name)
- print(csv_name)
- if not os.path.isfile(csv_name):
- df = fetch_all_cards_text(url='https://api.scryfall.com/cards/search?q=set:%s+lang:en'
- % set_name, csv_name=csv_name)
- else:
- df = load_all_cards_text(csv_name)
- time.sleep(1)
- #fetch_all_cards_image(df, out_dir='../usb/data/png/%s' % set_name)
- #df = fetch_all_cards_text(url='https://api.scryfall.com/cards/search?q=layout:normal+lang:en+frame:2003',
- # csv_name='data/csv/all.csv')
- pass
-
-
-if __name__ == '__main__':
- main()
- pass
diff --git a/generate_data.py b/generate_data.py
deleted file mode 100644
index 7a2ce87..0000000
--- a/generate_data.py
+++ /dev/null
@@ -1,229 +0,0 @@
-from glob import glob
-import matplotlib.pyplot as plt
-import matplotlib.image as mpimage
-import pickle
-import math
-import random
-import os
-import re
-import cv2
-import fetch_data
-import sys
-import numpy as np
-import pandas as pd
-import transform_data
-
-# Referenced from geaxgx's playing-card-detection: https://github.com/geaxgx/playing-card-detection
-class Backgrounds:
- def __init__(self, images=None, dumps_dir='data/dtd/images'):
- if images is not None:
- self._images = images
- else: # load from pickle
- if not os.path.exists(dumps_dir):
- print('Warning: directory for dump %s doesn\'t exist' % dumps_dir)
- return
- self._images = []
- for dump_name in glob(dumps_dir + '/*.pck'):
- with open(dump_name, 'rb') as dump:
- print('Loading ' + dump_name)
- images = pickle.load(dump)
- self._images += images
- if len(self._images) == 0:
- self._images = load_dtd()
- print('# of images loaded: %d' % len(self._images))
-
- def get_random(self, display=False):
- bg = self._images[random.randint(0, len(self._images) - 1)]
- if display:
- plt.show(bg)
- return bg
-
-
-def load_dtd(dtd_dir='data/dtd/images', dump_it=True, dump_batch_size=1000):
- if not os.path.exists(dtd_dir):
- print('Warning: directory for DTD 5s doesn\'t exist.' % dtd_dir)
- print('You can download the dataset using this command:'
- '!wget https://www.robots.ox.ac.uk/~vgg/data/dtd/download/dtd-r1.0.1.tar.gz')
- return []
- bg_images = []
- # Search the directory for all images, and append them
- for subdir in glob(dtd_dir + "/*"):
- for f in glob(subdir + "/*.jpg"):
- bg_images.append(mpimage.imread(f))
- print("# of images loaded :", len(bg_images))
-
- # Save them as a pickle if necessary
- if dump_it:
- for i in range(math.ceil(len(bg_images) / dump_batch_size)):
- dump_name = '%s/dtd_dump_%d.pck' % (dtd_dir, i)
- with open(dump_name, 'wb') as dump:
- print('Dumping ' + dump_name)
- pickle.dump(bg_images[i * dump_batch_size:(i + 1) * dump_batch_size], dump)
-
- return bg_images
-
-
-def apply_bounding_box(img, card_info, display=False):
- # List of detected objects to be fed into the neural net
- # The first object is the entire card
- detected_object_list = [transform_data.ExtractedObject('card', [(0, 0), (len(img[0]), 0), (len(img[0]), len(img)), (0, len(img))])]
- '''
- # Mana symbol - They are located on the top right side of the card, next to the name
- # Their position is stationary, and is right-aligned.
- has_mana_cost = isinstance(card_info['mana_cost'], str) # Cards with no mana cost will have nan
- if has_mana_cost:
- mana_cost = re.findall('\{(.*?)\}', card_info['mana_cost'])
- x_anchor = 683
- y_anchor = 65
-
- # Cards with specific type or from old sets have their symbol at a different position
- if card_info['set'] in ['8ed', 'mrd', 'dst', '5dn']:
- y_anchor -= 2
-
- for i in reversed(range(len(mana_cost))):
- # Hybrid mana symbol are larger than a normal symbol
- is_hybrid = '/' in mana_cost[i]
- if is_hybrid:
- x1 = x_anchor - 47
- x2 = x_anchor + 2
- y1 = y_anchor - 8
- y2 = y_anchor + 43
- x_anchor -= 45
- else:
- x1 = x_anchor - 39
- x2 = x_anchor
- y1 = y_anchor
- y2 = y_anchor + 43
- x_anchor -= 37
- # Append them to the list of bounding box with the appropriate label
- symbol_name = 'mana_symbol:' + mana_cost[i]
- key_pts = [(x1, y1), (x2, y1), (x2, y2), (x1, y2)]
- detected_object_list.append(transform_data.ExtractedObject(symbol_name, key_pts))
-
- if display:
- img_symbol = img[y1:y2, x1:x2]
- cv2.imshow('symbol', img_symbol)
- cv2.waitKey(0)
-
- # Set symbol - located on the right side of the type box in the centre of the card, next to the card type
- # Only one symbol exists, and its colour varies by rarity.
- if card_info['set'] in ['8ed']:
- x1 = 622
- x2 = 670
- elif card_info['set'] in ['mrd', 'm10', 'm11', 'm12', 'm13', 'm14']:
- x1 = 602
- x2 = 684
- elif card_info['set'] in ['dst']:
- x1 = 636
- x2 = 673
- elif card_info['set'] in ['5dn']:
- x1 = 630
- x2 = 675
- elif card_info['set'] in ['bok', 'rtr']:
- x1 = 633
- x2 = 683
- elif card_info['set'] in ['sok', 'mbs']:
- x1 = 638
- x2 = 683
- elif card_info['set'] in ['rav']:
- x1 = 640
- x2 = 678
- elif card_info['set'] in ['csp']:
- x1 = 650
- x2 = 683
- elif card_info['set'] in ['tsp', 'lrw', 'zen', 'wwk', 'ths']:
- x1 = 640
- x2 = 683
- elif card_info['set'] in ['plc', 'fut', 'shm', 'eve']:
- x1 = 625
- x2 = 685
- elif card_info['set'] in ['10e']:
- x1 = 623
- x2 = 680
- elif card_info['set'] in ['mor', 'roe', 'bng']:
- x1 = 637
- x2 = 687
- elif card_info['set'] in ['ala', 'arb']:
- x1 = 635
- x2 = 680
- elif card_info['set'] in ['nph']:
- x1 = 642
- x2 = 678
- elif card_info['set'] in ['gtc']:
- x1 = 610
- x2 = 683
- elif card_info['set'] in ['dgm']:
- x1 = 618
- x2 = 678
- else:
- x1 = 630
- x2 = 683
- y1 = 589
- y2 = 636
- # Append them to the list of bounding box with the appropriate label
- symbol_name = 'set_symbol:' + card_info['set']
- key_pts = [(x1, y1), (x2, y1), (x2, y2), (x1, y2)]
- detected_object_list.append(transform_data.ExtractedObject(symbol_name, key_pts))
-
- if display:
- img_symbol = img[y1:y2, x1:x2]
- cv2.imshow('symbol', img_symbol)
- cv2.waitKey(0)
-
- # Name box - The long bar on the top with card name and mana symbols
- # TODO
-
- # Type box - The long bar on the middle with card type and set symbols
- # TODO
-
- # Image box - the large image on the top half of the card
- # TODO
- '''
- return detected_object_list
-
-
-def main():
- random.seed()
- #bg_images = load_dtd()
- #bg = Backgrounds()
- #bg.get_random(display=True)
-
- card_pool = pd.DataFrame()
- for set_name in fetch_data.all_set_list:
- df = fetch_data.load_all_cards_text('data/csv/%s.csv' % set_name)
- #for _ in range(3):
- # card_info = df.iloc[random.randint(0, df.shape[0] - 1)]
- # # Currently ignoring planeswalker cards due to their different card layout
- # is_planeswalker = 'Planeswalker' in card_info['type_line']
- # if not is_planeswalker:
- # card_pool = card_pool.append(card_info)
- card_pool = card_pool.append(df)
- '''
- print(card_pool)
- mana_symbol_set = set()
- for _, card_info in card_pool.iterrows():
- has_mana_cost = isinstance(card_info['mana_cost'], str)
- if has_mana_cost:
- mana_cost = re.findall('\{(.*?)\}', card_info['mana_cost'])
- for symbol in mana_cost:
- mana_symbol_set.add(symbol)
-
- print(mana_symbol_set)
- '''
-
- for _, card_info in card_pool.iterrows():
- img_name = '../usb/data/png/%s/%s_%s.png' % (card_info['set'], card_info['collector_number'],
- fetch_data.get_valid_filename(card_info['name']))
- print(img_name)
- card_img = cv2.imread(img_name)
- if card_img is None:
- fetch_data.fetch_card_image(card_info, out_dir='../usb/data/png/%s' % card_info['set'])
- card_img = cv2.imread(img_name)
- detected_object_list = apply_bounding_box(card_img, card_info, display=True)
- print(detected_object_list)
-
- return
-
-
-if __name__ == '__main__':
- main()
diff --git a/setup_train.py b/setup_train.py
deleted file mode 100644
index 362be19..0000000
--- a/setup_train.py
+++ /dev/null
@@ -1,28 +0,0 @@
-import os
-from glob import glob
-import random
-import transform_data
-
-
-def main():
- random.seed()
- data_list = []
- for subdir in glob('%s/train/*_10' % transform_data.data_dir):
- for data in glob(subdir + "/*.jpg"):
- data_list.append(os.path.abspath(data))
- random.shuffle(data_list)
-
- test_ratio = 0.1
- test_list = data_list[:int(test_ratio * len(data_list))]
- train_list = data_list[int(test_ratio * len(data_list)):]
- with open('%s/train_10.txt' % transform_data.darknet_dir, 'w') as train_txt:
- for data in train_list:
- train_txt.write(data + '\n')
- with open('%s/test_10.txt' % transform_data.darknet_dir, 'w') as test_txt:
- for data in test_list:
- test_txt.write(data + '\n')
- return
-
-
-if __name__ == '__main__':
- main()
diff --git a/test_files/C-12-26-2016-MTG-Klomparens-Article-Images-Hand-2.png b/test_files/C-12-26-2016-MTG-Klomparens-Article-Images-Hand-2.png
deleted file mode 100644
index 09cc0b3..0000000
--- a/test_files/C-12-26-2016-MTG-Klomparens-Article-Images-Hand-2.png
+++ /dev/null
Binary files differ
diff --git a/test_files/c16-143-burgeoning.png b/test_files/c16-143-burgeoning.png
deleted file mode 100644
index 0a5baba..0000000
--- a/test_files/c16-143-burgeoning.png
+++ /dev/null
Binary files differ
diff --git a/test_files/card_in_plastic_case.jpg b/test_files/card_in_plastic_case.jpg
deleted file mode 100644
index e771a5c..0000000
--- a/test_files/card_in_plastic_case.jpg
+++ /dev/null
Binary files differ
diff --git a/test_files/cn2-78-queen-marchesa.png b/test_files/cn2-78-queen-marchesa.png
deleted file mode 100644
index aa2b3f7..0000000
--- a/test_files/cn2-78-queen-marchesa.png
+++ /dev/null
Binary files differ
diff --git a/test_files/frilly_0007.jpg b/test_files/frilly_0007.jpg
deleted file mode 100644
index 5ab39fd..0000000
--- a/test_files/frilly_0007.jpg
+++ /dev/null
Binary files differ
diff --git a/test_files/handOfCards.jpg b/test_files/handOfCards.jpg
deleted file mode 100644
index 8f8f53e..0000000
--- a/test_files/handOfCards.jpg
+++ /dev/null
Binary files differ
diff --git a/test_files/hand_of_card_1.png b/test_files/hand_of_card_1.png
deleted file mode 100644
index 8323d5c..0000000
--- a/test_files/hand_of_card_1.png
+++ /dev/null
Binary files differ
diff --git a/test_files/hand_of_card_easy.jpg b/test_files/hand_of_card_easy.jpg
deleted file mode 100644
index 2b069f5..0000000
--- a/test_files/hand_of_card_easy.jpg
+++ /dev/null
Binary files differ
diff --git a/test_files/hand_of_card_green_1.jpg b/test_files/hand_of_card_green_1.jpg
deleted file mode 100644
index 13f5b75..0000000
--- a/test_files/hand_of_card_green_1.jpg
+++ /dev/null
Binary files differ
diff --git a/test_files/hand_of_card_green_2.jpeg b/test_files/hand_of_card_green_2.jpeg
deleted file mode 100644
index 86109fa..0000000
--- a/test_files/hand_of_card_green_2.jpeg
+++ /dev/null
Binary files differ
diff --git a/test_files/hand_of_card_ktk.png b/test_files/hand_of_card_ktk.png
deleted file mode 100644
index 456ab69..0000000
--- a/test_files/hand_of_card_ktk.png
+++ /dev/null
Binary files differ
diff --git a/test_files/hand_of_card_new_frame_1.webp b/test_files/hand_of_card_new_frame_1.webp
deleted file mode 100644
index 1eb5b04..0000000
--- a/test_files/hand_of_card_new_frame_1.webp
+++ /dev/null
Binary files differ
diff --git a/test_files/hand_of_card_one_hand.jpg b/test_files/hand_of_card_one_hand.jpg
deleted file mode 100644
index bae5d8d..0000000
--- a/test_files/hand_of_card_one_hand.jpg
+++ /dev/null
Binary files differ
diff --git a/test_files/hand_of_card_red.jpeg b/test_files/hand_of_card_red.jpeg
deleted file mode 100644
index 4469e9f..0000000
--- a/test_files/hand_of_card_red.jpeg
+++ /dev/null
Binary files differ
diff --git a/test_files/hand_of_card_tron.png b/test_files/hand_of_card_tron.png
deleted file mode 100644
index b2f569c..0000000
--- a/test_files/hand_of_card_tron.png
+++ /dev/null
Binary files differ
diff --git a/test_files/image_orig.jpg b/test_files/image_orig.jpg
deleted file mode 100644
index 440ad18..0000000
--- a/test_files/image_orig.jpg
+++ /dev/null
Binary files differ
diff --git a/test_files/li38_handOfCards.jpg b/test_files/li38_handOfCards.jpg
deleted file mode 100644
index e7e91be..0000000
--- a/test_files/li38_handOfCards.jpg
+++ /dev/null
Binary files differ
diff --git a/test_files/mask.png b/test_files/mask.png
deleted file mode 100644
index 1cbae13..0000000
--- a/test_files/mask.png
+++ /dev/null
Binary files differ
diff --git a/test_files/pro_tour_side.png b/test_files/pro_tour_side.png
deleted file mode 100644
index 759ddf3..0000000
--- a/test_files/pro_tour_side.png
+++ /dev/null
Binary files differ
diff --git a/test_files/pro_tour_table.png b/test_files/pro_tour_table.png
deleted file mode 100644
index e02960b..0000000
--- a/test_files/pro_tour_table.png
+++ /dev/null
Binary files differ
diff --git a/test_files/rtr-174-jarad-golgari-lich-lord.jpg b/test_files/rtr-174-jarad-golgari-lich-lord.jpg
deleted file mode 100644
index ee26e77..0000000
--- a/test_files/rtr-174-jarad-golgari-lich-lord.jpg
+++ /dev/null
Binary files differ
diff --git a/test_files/s-l300.jpg b/test_files/s-l300.jpg
deleted file mode 100644
index 819daca..0000000
--- a/test_files/s-l300.jpg
+++ /dev/null
Binary files differ
diff --git a/test_files/test.jpg b/test_files/test.jpg
deleted file mode 100644
index 233ffa8..0000000
--- a/test_files/test.jpg
+++ /dev/null
Binary files differ
diff --git a/test_files/test1.jpg b/test_files/test1.jpg
deleted file mode 100644
index a75278e..0000000
--- a/test_files/test1.jpg
+++ /dev/null
Binary files differ
diff --git a/test_files/test1.mp4 b/test_files/test1.mp4
deleted file mode 100644
index 114a43c..0000000
--- a/test_files/test1.mp4
+++ /dev/null
Binary files differ
diff --git a/test_files/test10.jpg b/test_files/test10.jpg
deleted file mode 100644
index 8e9062b..0000000
--- a/test_files/test10.jpg
+++ /dev/null
Binary files differ
diff --git a/test_files/test11.jpg b/test_files/test11.jpg
deleted file mode 100644
index b0795f4..0000000
--- a/test_files/test11.jpg
+++ /dev/null
Binary files differ
diff --git a/test_files/test12.jpg b/test_files/test12.jpg
deleted file mode 100644
index c2f5de6..0000000
--- a/test_files/test12.jpg
+++ /dev/null
Binary files differ
diff --git a/test_files/test13.jpg b/test_files/test13.jpg
deleted file mode 100644
index 878cbad..0000000
--- a/test_files/test13.jpg
+++ /dev/null
Binary files differ
diff --git a/test_files/test14.jpg b/test_files/test14.jpg
deleted file mode 100644
index bf5094a..0000000
--- a/test_files/test14.jpg
+++ /dev/null
Binary files differ
diff --git a/test_files/test15.jpg b/test_files/test15.jpg
deleted file mode 100644
index 39f1dd4..0000000
--- a/test_files/test15.jpg
+++ /dev/null
Binary files differ
diff --git a/test_files/test16.jpg b/test_files/test16.jpg
deleted file mode 100644
index c514771..0000000
--- a/test_files/test16.jpg
+++ /dev/null
Binary files differ
diff --git a/test_files/test17.jpg b/test_files/test17.jpg
deleted file mode 100644
index 4ad12f7..0000000
--- a/test_files/test17.jpg
+++ /dev/null
Binary files differ
diff --git a/test_files/test18.jpg b/test_files/test18.jpg
deleted file mode 100644
index a0f9390..0000000
--- a/test_files/test18.jpg
+++ /dev/null
Binary files differ
diff --git a/test_files/test19.jpg b/test_files/test19.jpg
deleted file mode 100644
index 8f3c5a6..0000000
--- a/test_files/test19.jpg
+++ /dev/null
Binary files differ
diff --git a/test_files/test1_yolo_out_py.jpg b/test_files/test1_yolo_out_py.jpg
deleted file mode 100644
index e844c9a..0000000
--- a/test_files/test1_yolo_out_py.jpg
+++ /dev/null
Binary files differ
diff --git a/test_files/test2.jpg b/test_files/test2.jpg
deleted file mode 100644
index 1fceb1f..0000000
--- a/test_files/test2.jpg
+++ /dev/null
Binary files differ
diff --git a/test_files/test2.mp4 b/test_files/test2.mp4
deleted file mode 100644
index aa08b4b..0000000
--- a/test_files/test2.mp4
+++ /dev/null
Binary files differ
diff --git a/test_files/test20.jpg b/test_files/test20.jpg
deleted file mode 100644
index 8717d5f..0000000
--- a/test_files/test20.jpg
+++ /dev/null
Binary files differ
diff --git a/test_files/test21.jpg b/test_files/test21.jpg
deleted file mode 100644
index 342577c..0000000
--- a/test_files/test21.jpg
+++ /dev/null
Binary files differ
diff --git a/test_files/test22.png b/test_files/test22.png
deleted file mode 100644
index 179f188..0000000
--- a/test_files/test22.png
+++ /dev/null
Binary files differ
diff --git a/test_files/test23.jpg b/test_files/test23.jpg
deleted file mode 100644
index af79a6f..0000000
--- a/test_files/test23.jpg
+++ /dev/null
Binary files differ
diff --git a/test_files/test24.jpg b/test_files/test24.jpg
deleted file mode 100644
index 937354c..0000000
--- a/test_files/test24.jpg
+++ /dev/null
Binary files differ
diff --git a/test_files/test25.jpg b/test_files/test25.jpg
deleted file mode 100644
index 6e39077..0000000
--- a/test_files/test25.jpg
+++ /dev/null
Binary files differ
diff --git a/test_files/test26.jpg b/test_files/test26.jpg
deleted file mode 100644
index ee83759..0000000
--- a/test_files/test26.jpg
+++ /dev/null
Binary files differ
diff --git a/test_files/test27.jpg b/test_files/test27.jpg
deleted file mode 100644
index 0ee79be..0000000
--- a/test_files/test27.jpg
+++ /dev/null
Binary files differ
diff --git a/test_files/test3.jpg b/test_files/test3.jpg
deleted file mode 100644
index fd1f2cb..0000000
--- a/test_files/test3.jpg
+++ /dev/null
Binary files differ
diff --git a/test_files/test4.jpg b/test_files/test4.jpg
deleted file mode 100644
index 1f2ffc6..0000000
--- a/test_files/test4.jpg
+++ /dev/null
Binary files differ
diff --git a/test_files/test5.jpg b/test_files/test5.jpg
deleted file mode 100644
index f9e8a1f..0000000
--- a/test_files/test5.jpg
+++ /dev/null
Binary files differ
diff --git a/test_files/test6.jpg b/test_files/test6.jpg
deleted file mode 100644
index 1454673..0000000
--- a/test_files/test6.jpg
+++ /dev/null
Binary files differ
diff --git a/test_files/test7.jpg b/test_files/test7.jpg
deleted file mode 100644
index 82dfb3c..0000000
--- a/test_files/test7.jpg
+++ /dev/null
Binary files differ
diff --git a/test_files/test8.jpg b/test_files/test8.jpg
deleted file mode 100644
index 2d480ce..0000000
--- a/test_files/test8.jpg
+++ /dev/null
Binary files differ
diff --git a/test_files/test9.jpg b/test_files/test9.jpg
deleted file mode 100644
index c8b0f53..0000000
--- a/test_files/test9.jpg
+++ /dev/null
Binary files differ
diff --git a/test_files/tilted_card_1.jpg b/test_files/tilted_card_1.jpg
deleted file mode 100644
index e973651..0000000
--- a/test_files/tilted_card_1.jpg
+++ /dev/null
Binary files differ
diff --git a/test_files/tilted_card_2.jpg b/test_files/tilted_card_2.jpg
deleted file mode 100644
index d1edf41..0000000
--- a/test_files/tilted_card_2.jpg
+++ /dev/null
Binary files differ
diff --git a/transform_data.py b/transform_data.py
deleted file mode 100644
index 9952a99..0000000
--- a/transform_data.py
+++ /dev/null
@@ -1,567 +0,0 @@
-import os
-import random
-import math
-import cv2
-import numpy as np
-import imutils
-import pandas as pd
-import fetch_data
-import generate_data
-from shapely import geometry
-import pytesseract
-import imgaug as ia
-from imgaug import augmenters as iaa
-from imgaug import parameters as iap
-
-card_mask = cv2.imread('data/mask.png')
-data_dir = os.path.abspath('/media/win10/data')
-darknet_dir = os.path.abspath('darknet')
-
-
-def key_pts_to_yolo(key_pts, w_img, h_img):
- """
- Convert a list of keypoints into a yolo training format
- :param key_pts: list of keypoints
- :param w_img: width of the entire image
- :param h_img: height of the entire image
- :return: <x> <y> <width> <height>
- """
- x1 = max(0, min([pt[0] for pt in key_pts]))
- x2 = min(w_img, max([pt[0] for pt in key_pts]))
- y1 = max(0, min([pt[1] for pt in key_pts]))
- y2 = min(h_img, max([pt[1] for pt in key_pts]))
- x = (x2 + x1) / 2 / w_img
- y = (y2 + y1) / 2 / h_img
- width = (x2 - x1) / w_img
- height = (y2 - y1) / h_img
- return x, y, width, height
-
-
-class ImageGenerator:
- """
- A template for generating a training image.
- """
- def __init__(self, img_bg, class_ids, width, height, skew=None, cards=None):
- """
- :param img_bg: background (textile) image
- :param width: width of the training image
- :param height: height of the training image
- :param skew: 4 coordinates that indicates the corners (in normalized form) for perspective transform
- :param cards: list of Card objects
- """
- self.img_bg = img_bg
- self.class_ids = class_ids
- self.img_result = None
- self.width = width
- self.height = height
- if cards is None:
- self.cards = []
- else:
- self.cards = cards
-
- # Compute transform matrix for perspective transform
- if skew is not None:
- orig_corner = np.array([[0, 0], [0, height], [width, height], [width, 0]], dtype=np.float32)
- new_corner = np.array([[width * s[0], height * s[1]] for s in skew], dtype=np.float32)
- self.M = cv2.getPerspectiveTransform(orig_corner, new_corner)
- pass
- else:
- self.M = None
- pass
-
- def add_card(self, card, x=None, y=None, theta=0.0, scale=1.0):
- """
- Add a card to this generator scenario.
- :param card: card to be added
- :param x: new X-coordinate for the centre of the card
- :param y: new Y-coordinate for the centre of the card
- :param theta: new angle for the card
- :param scale: new scale for the card
- :return: none
- """
- if x is None:
- x = -len(card.img[0]) / 2
- if y is None:
- y = -len(card.img) / 2
- self.cards.append(card)
- card.x = x
- card.y = y
- card.theta = theta
- card.scale = scale
- pass
-
- def render(self, visibility=0.5, display=False, debug=False, aug=None):
- """
- Display the current state of the generator
- :return: none
- """
- self.check_visibility(visibility=visibility)
- #img_result = cv2.resize(self.img_bg, (self.width, self.height))
- img_result = np.zeros((self.height, self.width, 3), dtype=np.uint8)
-
- for card in self.cards:
- if card.x == 0.0 and card.y == 0.0 and card.theta == 0.0 and card.scale == 1.0:
- continue
- card_x = int(card.x + 0.5)
- card_y = int(card.y + 0.5)
- #print(card_x, card_y, card.theta, card.scale)
-
- # Scale & rotate card image
- img_card = cv2.resize(card.img, (int(len(card.img[0]) * card.scale), int(len(card.img) * card.scale)))
- if aug is not None:
- seq = iaa.Sequential([
- iaa.SimplexNoiseAlpha(first=iaa.Add(random.randrange(128)), size_px_max=[1, 3],
- upscale_method="cubic"), # Lighting
- ])
- img_card = seq.augment_image(img_card)
- mask_scale = cv2.resize(card_mask, (int(len(card_mask[0]) * card.scale), int(len(card_mask) * card.scale)))
- img_mask = cv2.bitwise_and(img_card, mask_scale)
- img_rotate = imutils.rotate_bound(img_mask, card.theta / math.pi * 180)
-
- # Calculate the position of the card image in relation to the background
- # Crop the card image if it's out of boundary
- card_w = len(img_rotate[0])
- card_h = len(img_rotate)
- card_crop_x1 = max(0, card_w // 2 - card_x)
- card_crop_x2 = min(card_w, card_w // 2 + len(img_result[0]) - card_x)
- card_crop_y1 = max(0, card_h // 2 - card_y)
- card_crop_y2 = min(card_h, card_h // 2 + len(img_result) - card_y)
- img_card_crop = img_rotate[card_crop_y1:card_crop_y2, card_crop_x1:card_crop_x2]
-
- # Calculate the position of the corresponding area in the background
- bg_crop_x1 = max(0, card_x - (card_w // 2))
- bg_crop_x2 = min(len(img_result[0]), int(card_x + (card_w / 2) + 0.5))
- bg_crop_y1 = max(0, card_y - (card_h // 2))
- bg_crop_y2 = min(len(img_result), int(card_y + (card_h / 2) + 0.5))
- img_result_crop = img_result[bg_crop_y1:bg_crop_y2, bg_crop_x1:bg_crop_x2]
-
- # Override the background with the current card
- img_result_crop = np.where(img_card_crop, img_card_crop, img_result_crop)
- img_result[bg_crop_y1:bg_crop_y2, bg_crop_x1:bg_crop_x2] = img_result_crop
-
- if debug:
- for ext_obj in card.objects:
- if ext_obj.visible:
- for pt in ext_obj.key_pts:
- cv2.circle(img_result, card.coordinate_in_generator(pt[0], pt[1]), 2, (1, 1, 255), 10)
- bounding_box = card.bb_in_generator(ext_obj.key_pts)
- cv2.rectangle(img_result, bounding_box[0], bounding_box[2], (1, 255, 1), 5)
-
- '''
- try:
- text = pytesseract.image_to_string(img_result, output_type=pytesseract.Output.DICT)
- print(text)
- except pytesseract.pytesseract.TesseractError:
- pass
- '''
- img_result = cv2.GaussianBlur(img_result, (5, 5), 0)
-
- if self.M is not None:
- img_result = cv2.warpPerspective(img_result, self.M, (self.width, self.height))
- if debug:
- for card in self.cards:
- for ext_obj in card.objects:
- if ext_obj.visible:
- new_pts = np.array([[list(card.coordinate_in_generator(pt[0], pt[1]))]
- for pt in ext_obj.key_pts], dtype=np.float32)
- new_pts = cv2.perspectiveTransform(new_pts, self.M)
- for pt in new_pts:
- cv2.circle(img_result, (pt[0][0], pt[0][1]), 2, (255, 1, 1), 10)
-
- img_bg = cv2.resize(self.img_bg, (self.width, self.height))
- img_result = np.where(img_result, img_result, img_bg)
-
- if aug is not None:
- img_result = aug.augment_image(img_result)
-
- if display:
- cv2.imshow('Result', img_result)
- cv2.waitKey(0)
-
- self.img_result = img_result
- pass
-
- def generate_horizontal_span(self, gap=None, scale=None, theta=0, shift=None, jitter=None):
- """
- Generating the first scenario where the cards are laid out in a straight horizontal line
- :return: True if successfully generated, otherwise False
- """
- # Set scale of the cards, variance of shift & jitter to be applied if they're not given
- card_size = (len(self.cards[0].img[0]), len(self.cards[0].img))
- if scale is None:
- # Scale the cards so that card takes about 50% of the image's height
- coverage_ratio = 0.5
- scale = self.height * coverage_ratio / card_size[1]
- if shift is None:
- # Plus minus 5% of the card's height
- shift = [-card_size[1] * scale * 0.05, card_size[1] * scale * 0.05]
- pass
- if jitter is None:
- jitter = [-math.pi / 18, math.pi / 18] # Plus minus 10 degrees
- if gap is None:
- # 25% of the card's width - set symbol and 1-2 mana symbols will be visible on each card
- gap = card_size[0] * scale * 0.4
-
- # Determine the location of the first card
- # The cards will cover (width of a card + (# of cards - 1) * gap) pixels wide and (height of a card) pixels high
- x_anchor = int(self.width / 2 + (len(self.cards) - 1) * gap / 2)
- y_anchor = self.height // 2
- for card in self.cards:
- card.scale = scale
- card.x = x_anchor
- card.y = y_anchor
- card.theta = 0
- card.shift(shift, shift)
- card.rotate(jitter)
- card.rotate(theta, centre=(self.width // 2 - x_anchor, self.height // 2 - y_anchor))
- x_anchor -= gap
-
- return True
-
- def generate_vertical_span(self, gap=None, scale=None, theta=0, shift=None, jitter=None):
- """
- Generating the second scenario where the cards are laid out in a straight vertical line
- :return: True if successfully generated, otherwise False
- """
- # Set scale of the cards, variance of shift & jitter to be applied if they're not given
- card_size = (len(self.cards[0].img[0]), len(self.cards[0].img))
- if scale is None:
- # Scale the cards so that card takes about 50% of the image's height
- coverage_ratio = 0.5
- scale = self.height * coverage_ratio / card_size[1]
- if shift is None:
- # Plus minus 5% of the card's height
- shift = [-card_size[1] * scale * 0.05, card_size[1] * scale * 0.05]
- pass
- if jitter is None:
- # Plus minus 5 degrees
- jitter = [-math.pi / 36, math.pi / 36]
- if gap is None:
- # 15% of the card's height - the title bar (with mana symbols) will be visible
- gap = card_size[1] * scale * 0.25
-
- # Determine the location of the first card
- # The cards will cover (width of a card) pixels wide and (height of a card + (# of cards - 1) * gap) pixels high
- x_anchor = self.width // 2
- y_anchor = int(self.height / 2 - (len(self.cards) - 1) * gap / 2)
- for card in self.cards:
- card.scale = scale
- card.x = x_anchor
- card.y = y_anchor
- card.theta = 0
- card.shift(shift, shift)
- card.rotate(jitter)
- card.rotate(theta, centre=(self.width // 2 - x_anchor, self.height // 2 - y_anchor))
- y_anchor += gap
- return True
-
- def generate_fan_out(self, centre, theta_between_cards=None, scale=None, shift=None, jitter=None):
- """
- Generating the third scenario where the cards are laid out in a fan shape
- :return: True if successfully generated, otherwise False
- """
- return False
-
- def generate_non_obstructive(self, tolerance=0.90, scale=None):
- """
- Generating the fourth scenario where the cards are laid in arbitrary position that doesn't obstruct other cards
- :param tolerance: minimum level of visibility for each cards
- :return: True if successfully generated, otherwise False
- """
- card_size = (len(self.cards[0].img[0]), len(self.cards[0].img))
- if scale is None:
- # Total area of the cards should cover about 25-40% of the entire image, depending on the number of cards
- scale = math.sqrt(self.width * self.height * min(0.25 + 0.02 * len(self.cards), 0.4)
- / (card_size[0] * card_size[1] * len(self.cards)))
- # Position each card at random location that doesn't obstruct other cards
- i = 0
- while i < len(self.cards):
- #for i in range(len(self.cards)):
- card = self.cards[i]
- card.scale = scale
- rep = 0
- while True:
- card.x = random.uniform(card_size[1] * scale / 2, self.width - card_size[1] * scale)
- card.y = random.uniform(card_size[1] * scale / 2, self.height - card_size[1] * scale)
- card.theta = random.uniform(-math.pi, math.pi)
- self.check_visibility(self.cards[:i + 1], visibility=tolerance)
- # This position is not obstructive if all of the cards are visible
- is_visible = [other_card.objects[0].visible for other_card in self.cards[:i + 1]]
- non_obstructive = all(is_visible)
- if non_obstructive:
- i += 1
- break
- rep += 1
- if rep >= 1000:
- # Reassign previous card's position
- i -= 1
- break
- return True
-
- def check_visibility(self, cards=None, i_check=None, visibility=0.5):
- """
- Check whether if extracted objects in each card are visible in the current scenario, and update their status
- :param cards: list of cards (in a correct order)
- :param i_check: indices of cards that needs to be checked. Cards that aren't in this list will only be used
- to check visibility of other cards. All cards are checked by default.
- :param visibility: minimum ratio of the object's area that aren't covered by another card to be visible
- :return: none
- """
- if cards is None:
- cards = self.cards
- if i_check is None:
- i_check = range(len(cards))
- card_poly_list = [geometry.Polygon([card.coordinate_in_generator(0, 0),
- card.coordinate_in_generator(0, len(card.img)),
- card.coordinate_in_generator(len(card.img[0]), len(card.img)),
- card.coordinate_in_generator(len(card.img[0]), 0)]) for card in self.cards]
- template_poly = geometry.Polygon([(0, 0), (self.width, 0), (self.width, self.height), (0, self.height)])
-
- # First card in the list is overlaid on the bottom of the card pile
- for i in i_check:
- card = cards[i]
- for ext_obj in card.objects:
- obj_poly = geometry.Polygon([card.coordinate_in_generator(pt[0], pt[1]) for pt in ext_obj.key_pts])
- obj_area = obj_poly.area
- # Check if the other cards are blocking this object or if it's out of the template
- for card_poly in card_poly_list[i + 1:]:
- obj_poly = obj_poly.difference(card_poly)
- obj_poly = obj_poly.intersection(template_poly)
- visible_area = obj_poly.area
- #print(visible_area, obj_area, len(card.img[0]) * len(card.img) * card.scale * card.scale)
- #print("%s: %.1f visible" % (ext_obj.label, visible_area / obj_area * 100))
- ext_obj.visible = obj_area * visibility <= visible_area
-
- def export_training_data(self, out_name, visibility=0.5, aug=None):
- """
- Export the generated training image along with the txt file for all bounding boxes
- :return: none
- """
- self.render(visibility, aug=aug)
- cv2.imwrite(out_name + '.jpg', self.img_result)
- out_txt = open(out_name+ '.txt', 'w')
- for card in self.cards:
- for ext_obj in card.objects:
- if not ext_obj.visible:
- continue
- coords_in_gen = [card.coordinate_in_generator(key_pt[0], key_pt[1]) for key_pt in ext_obj.key_pts]
- obj_yolo_info = key_pts_to_yolo(coords_in_gen, self.width, self.height)
- if ext_obj.label == 'card':
- class_id = self.class_ids[card.info['name']]
- out_txt.write(str(class_id) + ' %.6f %.6f %.6f %.6f\n' % obj_yolo_info)
- pass
- elif ext_obj.label[:ext_obj.label.find[':']] == 'mana_symbol':
- # TODO
- pass
- elif ext_obj.label[:ext_obj.label.find[':']] == 'set_symbol':
- # TODO
- pass
- out_txt.close()
- pass
-
-
-class Card:
- """
- A class for storing required information about a card in relation to the ImageGenerator
- """
- def __init__(self, img, card_info, objects, x=None, y=None, theta=None, scale=None):
- """
- :param img: image of the card
- :param card_info: details like name, mana cost, type, set, etc
- :param objects: list of ExtractedObjects like mana & set symbol, etc
- :param generator: ImageGenerator object that the card is bound to
- :param x: X-coordinate of the card's centre in relation to the generator
- :param y: Y-coordinate of the card's centre in relation to the generator
- :param theta: angle of rotation of the card in relation to the generator
- :param scale: scale of the card in the generator in relation to the original image
- """
- self.img = img
- self.info = card_info
- self.objects = objects
- self.x = x
- self.y = y
- self.theta = theta
- self.scale = scale
- pass
-
- def shift(self, x, y):
- """
- Apply a X/Y translation on this image
- :param x: amount of X-translation. If range is given, translate by a random amount within that range
- :param y: amount of Y-translation. Refer to x when a range is given.
- :return: none
- """
- if isinstance(x, tuple) or (isinstance(x, list) and len(x) == 2):
- self.x += random.uniform(x[0], x[1])
- else:
- self.x += x
- if isinstance(y, tuple) or (isinstance(y, list) and len(y) == 2):
- self.y += random.uniform(y[0], y[1])
- else:
- self.y += y
- pass
-
- def rotate(self, theta, centre=(0, 0)):
- """
- Apply a rotation on this image with a centre
- :param theta: amount of rotation in radian (clockwise). If a range is given, rotate by a random amount within
- :param centre: coordinate of the centre of the rotation in relation to the centre of this card
- that range
- :return: none
- """
- if isinstance(theta, tuple) or (isinstance(theta, list) and len(theta) == 2):
- theta = random.uniform(theta[0], theta[1])
-
- # If the centre given is the centre of this card, the whole math simplifies a bit
- # (This still works without the if statement, but let's not do useless trigs if we know the answer already)
- if centre is not (0, 0):
- # Rotation math
- self.x -= -centre[1] * math.sin(theta) + centre[0] * math.cos(theta)
- self.y -= centre[1] * math.cos(theta) + centre[0] * math.sin(theta)
-
- # Offset for the coordinate translation
- self.x += centre[0]
- self.y += centre[1]
-
- self.theta += theta
- pass
-
- def coordinate_in_generator(self, x, y):
- """
- Converting coordinate within the card into the coordinate in the generator it is associated with
- :param x: x coordinate within the card
- :param y: y coordinate within the card
- :return: (x, y) coordinate in the generator
- """
- # Relative distance in X & Y axis, if the centre of the card is at the origin (0, 0)
- rel_x = x - len(self.img[0]) // 2
- rel_y = y - len(self.img) // 2
-
- # Scaling
- rel_x *= self.scale
- rel_y *= self.scale
-
- # Rotation
- rot_x = rel_x - rel_y * math.sin(self.theta) + rel_x * math.cos(self.theta)
- rot_y = rel_y + rel_y * math.cos(self.theta) + rel_x * math.sin(self.theta)
-
- # Negate offset
- rot_x -= rel_x
- rot_y -= rel_y
-
- # Shift
- gen_x = rot_x + self.x
- gen_y = rot_y + self.y
-
- return int(gen_x), int(gen_y)
-
- def bb_in_generator(self, key_pts):
- """
- Convert a keypoints of bounding box in card into the coordinate in the generator
- :param key_pts: keypoints of the bounding box
- :return: bounding box represented by 4 points in the generator
- """
- coords_in_gen = [self.coordinate_in_generator(key_pt[0], key_pt[1]) for key_pt in key_pts]
- x1 = min([pt[0] for pt in coords_in_gen])
- x2 = max([pt[0] for pt in coords_in_gen])
- y1 = min([pt[1] for pt in coords_in_gen])
- y2 = max([pt[1] for pt in coords_in_gen])
- '''
- x1 = -math.inf
- x2 = math.inf
- y1 = -math.inf
- y2 = math.inf
- for key_pt in key_pts:
- coord_in_gen = self.coordinate_in_generator(key_pt[0], key_pt[1])
- x1 = max(x1, coord_in_gen[0])
- x2 = min(x2, coord_in_gen[0])
- y1 = max(y1, coord_in_gen[1])
- y2 = min(y2, coord_in_gen[1])
- '''
- return [(x1, y1), (x2, y1), (x2, y2), (x1, y2)]
-
-
-class ExtractedObject:
- """
- Simple struct to hold information about an extracted object
- """
- def __init__(self, label, key_pts):
- self.label = label
- self.key_pts = key_pts
- self.visible = False
-
-
-def main():
- random.seed()
- ia.seed(random.randrange(10000))
-
- bg_images = generate_data.load_dtd(dtd_dir='%s/dtd/images' % data_dir, dump_it=False)
- #bg_images = [cv2.imread('data/frilly_0007.jpg')]
- background = generate_data.Backgrounds(images=bg_images)
-
- #card_pool = pd.DataFrame()
- #for set_name in fetch_data.all_set_list:
- # df = fetch_data.load_all_cards_text('%s/csv/%s.csv' % (data_dir, set_name))
- # card_pool = card_pool.append(df)
- card_pool = fetch_data.load_all_cards_text('%s/csv/custom.csv' % data_dir)
- class_ids = {}
- with open('%s/obj.names' % data_dir) as names_file:
- class_name_list = names_file.read().splitlines()
- for i in range(len(class_name_list)):
- class_ids[class_name_list[i]] = i
- print(class_ids)
-
- num_gen = 60000
- num_iter = 1
-
- for i in range(num_gen):
- # Arbitrarily select top left and right corners for perspective transformation
- # Since the training image are generated with random rotation, don't need to skew all four sides
- skew = [[random.uniform(0, 0.25), 0], [0, 1], [1, 1],
- [random.uniform(0.75, 1), 0]]
- generator = ImageGenerator(background.get_random(), class_ids, 1440, 960, skew=skew)
- out_name = ''
- for _, card_info in card_pool.sample(random.randint(2, 5)).iterrows():
- img_name = '%s/card_img/png/%s/%s_%s.png' % (data_dir, card_info['set'], card_info['collector_number'],
- fetch_data.get_valid_filename(card_info['name']))
- out_name += '%s%s_' % (card_info['set'], card_info['collector_number'])
- card_img = cv2.imread(img_name)
- if card_img is None:
- fetch_data.fetch_card_image(card_info, out_dir='%s/card_img/png/%s' % (data_dir, card_info['set']))
- card_img = cv2.imread(img_name)
- if card_img is None:
- print('WARNING: card %s is not found!' % img_name)
- detected_object_list = generate_data.apply_bounding_box(card_img, card_info)
- card = Card(card_img, card_info, detected_object_list)
- generator.add_card(card)
- for j in range(num_iter):
- seq = iaa.Sequential([
- iaa.Multiply((0.8, 1.2)), # darken / brighten the whole image
- iaa.SimplexNoiseAlpha(first=iaa.Add(random.randrange(64)), per_channel=0.1, size_px_max=[3, 6],
- upscale_method="cubic"), # Lighting
- iaa.AdditiveGaussianNoise(scale=random.uniform(0, 0.05) * 255, per_channel=0.1), # Noises
- iaa.Dropout(p=[0, 0.05], per_channel=0.1)
- ])
-
- if i % 3 == 0:
- generator.generate_non_obstructive()
- generator.export_training_data(visibility=0.0, out_name='%s/train/non_obstructive_10/%s%d'
- % (data_dir, out_name, j), aug=seq)
- elif i % 3 == 1:
- generator.generate_horizontal_span(theta=random.uniform(-math.pi, math.pi))
- generator.export_training_data(visibility=0.0, out_name='%s/train/horizontal_span_10/%s%d'
- % (data_dir, out_name, j), aug=seq)
- else:
- generator.generate_vertical_span(theta=random.uniform(-math.pi, math.pi))
- generator.export_training_data(visibility=0.0, out_name='%s/train/vertical_span_10/%s%d'
- % (data_dir, out_name, j), aug=seq)
-
- #generator.generate_horizontal_span(theta=random.uniform(-math.pi, math.pi))
- #generator.render(display=True, aug=seq, debug=True)
- print('Generated %s%d' % (out_name, j))
- generator.img_bg = background.get_random()
- pass
-
-
-if __name__ == '__main__':
- main()
--
Gitblit v1.10.0