card coordinate translation & rotation

Edmond Yoo

2018-08-30 bdedb31063d94cb637805adeb9a302acba9465dd

card coordinate translation & rotation

 transform_data.py

@@ -35,56 +35,34 @@
        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
        cv2.imshow('Result', img_bg)
        cv2.waitKey(0)
@@ -189,20 +167,15 @@
        """
        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

@@ -243,28 +216,11 @@
            card_img = cv2.imread(img_name)
        card = Card(card_img, card_info, None)

        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)
        card.bind_to_generator(generator, x=random.uniform(0, generator.width), y=random.uniform(0, generator.height),
                               theta=0, scale=0.5)
        card.shift([-100, 100], [-100, 100])
        card.rotate((0, 0), [-math.pi, math.pi])
    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