From ada8e8118643e57f2180351ab359369d06f8f70e Mon Sep 17 00:00:00 2001
From: Edmond Yoo <hj3yoo@uwaterloo.ca>
Date: Thu, 30 Aug 2018 21:45:23 +0000
Subject: [PATCH] Coordinate conversion, etc
---
transform_data.py | 199 ++++++++++++++++++++++++++-----------------------
1 files changed, 104 insertions(+), 95 deletions(-)
diff --git a/transform_data.py b/transform_data.py
index 88d693e..719b11f 100644
--- a/transform_data.py
+++ b/transform_data.py
@@ -5,6 +5,7 @@
import imutils
import pandas as pd
import fetch_data
+import generate_data
card_mask = cv2.imread('data/mask.png')
@@ -27,6 +28,23 @@
self.height = height
pass
+ def add_card(self, card, x=0, y=0, 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
+ """
+ self.cards.append(card)
+ card.x = x
+ card.y = y
+ card.theta = theta
+ card.scale = scale
+ pass
+
def display(self):
"""
Display the current state of the generator
@@ -35,57 +53,43 @@
img_bg = cv2.resize(self.img_bg, (self.width, self.height))
for card in self.cards:
- print(card.x, card.y, card.theta, card.scale)
+ 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)))
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)
- print(len(img_rotate[0]), len(img_rotate))
-
+
# 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 = min(0, card_w // 2 - card.x)
- #card_crop_x2 = min(card_w, card_w // 2 + len(img_bg[0]) - card.x)
- #card_crop_y1 = min(0, card_h // 2 - card.y)
- #card_crop_y2 = min(card_h, card_h // 2 + len(img_bg) - card.y)
- card_crop_x1 = card_w // 2 - card.x
- card_crop_x2 = card_w // 2 + len(img_bg[0]) - card.x
- card_crop_y1 = card_h // 2 - card.y
- card_crop_y2 = card_h // 2 + len(img_bg) - card.y
-
- img_card_crop = img_rotate[max(0, card_crop_y1):min(card_h, card_crop_y2),
- max(0, card_crop_x1):min(card_w, card_crop_x2)]
- #print(card_crop_x1, card_crop_x2, card_crop_y1, card_crop_y2)
- print(len(img_card_crop[0]), len(img_card_crop))
+ card_crop_x1 = max(0, card_w // 2 - card_x)
+ card_crop_x2 = min(card_w, card_w // 2 + len(img_bg[0]) - card_x)
+ card_crop_y1 = max(0, card_h // 2 - card_y)
+ card_crop_y2 = min(card_h, card_h // 2 + len(img_bg) - 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_bg[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_bg), int(card.y + (card_h / 2) + 0.5))
+ bg_crop_x1 = max(0, card_x - (card_w // 2))
+ bg_crop_x2 = min(len(img_bg[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_bg), int(card_y + (card_h / 2) + 0.5))
img_bg_crop = img_bg[bg_crop_y1:bg_crop_y2, bg_crop_x1:bg_crop_x2]
- #bg_crop_x1 = card.x - (card_w // 2)
- #bg_crop_x2 = int(card.x + card_w / 2 + 0.5)
- #bg_crop_y1 = card.y - (card_h // 2)
- #bg_crop_y2 = int(card.y + card_h / 2 + 0.5)
- #img_bg_crop = img_bg[max(0, bg_crop_y1):min(len(img_bg), bg_crop_y2),
- # max(0, bg_crop_x1):min(len(img_bg[0]), bg_crop_x2)]
- #print(bg_crop_x1, bg_crop_x2, bg_crop_y1, bg_crop_y2)
- print(len(img_bg_crop[0]), len(img_bg_crop))
- #cv2.circle(img_bg, (card.x, card.y), 2, (0, 0, 255), 3)
- #cv2.rectangle(img_bg, (0, 0), (len(img_rotate[0]), len(img_rotate)), (0, 255, 0), 3)
- #cv2.rectangle(img_bg, (bg_crop_x1, bg_crop_y1), (bg_crop_x2, bg_crop_y2), (255, 0, 0), 3)
- #cv2.imshow('test', img_bg)
- #cv2.waitKey(0)
-
- mask1 = img_card_crop[:, :, 1]
- a_mask1 = np.stack([mask1] * 3, -1)
- img_bg_crop = np.where(a_mask1, img_card_crop[:, :, 0:3], img_bg_crop)
+ # Override the background with the current card
+ img_bg_crop = np.where(img_card_crop, img_card_crop, img_bg_crop)
img_bg[bg_crop_y1:bg_crop_y2, bg_crop_x1:bg_crop_x2] = img_bg_crop
+
+ #for extracted_object in card.objects:
+ # for pt in extracted_object.key_pts:
+ # cv2.circle(img_bg, card.coordinate_in_generator(pt[0], pt[1]), 2, (0, 0, 255), 2)
+ # bounding_box = card.bb_in_generator(extracted_object.key_pts)
+ # cv2.rectangle(img_bg, bounding_box[0], bounding_box[2], (0, 255, 0), 2)
+
cv2.imshow('Result', img_bg)
cv2.waitKey(0)
pass
@@ -123,7 +127,7 @@
"""
A class for storing required information about a card in relation to the ImageGenerator
"""
- def __init__(self, img, card_info, objects, generator=None, x=None, y=None, theta=None, scale=None):
+ 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
@@ -137,31 +141,12 @@
self.img = img
self.info = card_info
self.objects = objects
- self.generator = generator
self.x = x
self.y = y
self.theta = theta
self.scale = scale
pass
- def bind_to_generator(self, generator, x=0, y=0, theta=0.0, scale=1.0):
- """
- Bind this card to an ImageGenerator object.
- :param generator: generator to be bound with
- :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
- """
- self.generator = generator
- self.x = x
- self.y = y
- self.theta = theta
- self.scale = scale
- generator.cards.append(self)
- pass
-
def shift(self, x, y):
"""
Apply a X/Y translation on this image
@@ -189,23 +174,65 @@
"""
if isinstance(theta, tuple) or (isinstance(theta, list) and len(theta) == 2):
theta = random.uniform(theta[0], theta[1])
- x = self.x.copy()
- y = self.y.copy()
- # Translate the coordinate to make the centre of rotation be at (0, 0)
- x -= centre[0]
- y -= centre[1]
+ # 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)
- # Do the rotation math
- x_rotate = y * math.sin(theta) + x * math.cos(theta)
- y_rotate = y * math.cos(theta) - x * math.sin(theta)
+ # Offset for the coordinate translation
+ self.x += centre[0]
+ self.y += centre[1]
- # Negate the initial offset
- self.x = x_rotate + centre[0]
- self.y = y_rotate + 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
+ """
+ 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:
"""
@@ -218,10 +245,7 @@
def main():
random.seed()
-
img_bg = cv2.imread('data/frilly_0007.jpg')
- #img = cv2.imread('data/c16-143-burgeoning.png')
-
generator = ImageGenerator(img_bg, [], 1440, 960)
card_pool = pd.DataFrame()
for set_name in fetch_data.all_set_list:
@@ -231,8 +255,8 @@
is_planeswalker = 'Planeswalker' in card_info['type_line']
if not is_planeswalker:
card_pool = card_pool.append(card_info)
-
- for i in [random.randrange(0, card_pool.shape[0] - 1, 1) for _ in range(10)]:
+ a = 1
+ for i in [random.randrange(0, card_pool.shape[0] - 1, 1) for _ in range(24)]:
card_info = card_pool.iloc[i]
img_name = '../usb/data/png/%s/%s_%s.png' % (card_info['set'], card_info['collector_number'],
fetch_data.get_valid_filename(card_info['name']))
@@ -241,30 +265,15 @@
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)
- card = Card(card_img, card_info, None)
+ detected_object_list = generate_data.apply_bounding_box(card_img, card_info)
+ card = Card(card_img, card_info, detected_object_list)
- card.bind_to_generator(generator, x=random.randint(0, generator.width), y=random.randint(0, generator.height),
- theta=random.uniform(0, math.pi / 2), scale=0.5)
+ generator.add_card(card, x=random.uniform(200, generator.width - 200),
+ y=random.uniform(200, generator.height - 200), theta=random.uniform(-math.pi, math.pi), scale=0.5)
+ #card.shift([-100, 100], [-100, 100])
+ #card.rotate((0, 0), [-math.pi / 4, math.pi / 4])
+ a += 1
generator.display()
-
- '''
- img_mask = cv2.bitwise_and(img, mask)
- img_rotate = imutils.rotate_bound(img_mask, 45)
-
- #cv2.imshow('rotated', img_rotate)
- #cv2.waitKey(0)
-
- mask1 = img_rotate[:, :, 1]
- cv2.imshow('mask', mask1)
- a_mask1 = np.stack([mask1] * 3, -1)
- cv2.imshow('a_mask', a_mask1)
-
- img_bg = cv2.resize(img_bg, (len(img_rotate[0]), len(img_rotate)))
- final = np.where(a_mask1, img_rotate[:, :, 0:3], img_bg)
- final = cv2.resize(final, (len(final[0]) // 2, len(final) // 2))
- cv2.imshow('final', final)
- cv2.waitKey(0)
- '''
pass
--
Gitblit v1.10.0