eval/LayoutVLM/utils/plot_utils.py

import math
import matplotlib
from shapely.geometry import Polygon
import cv2
import datetime
import matplotlib.pyplot as plt
import numpy as np
import os
import random
from PIL import Image, ImageFile
ImageFile.LOAD_TRUNCATED_IMAGES = True
from PIL import ImageDraw, ImageFont
from io import BytesIO


def annotate_image_with_coordinates(image_path, visual_marks, output_path, format="coordinate", default_font_size=18):
    script_path = os.path.dirname(os.path.realpath(__file__))
    # Open the image
    img = Image.open(image_path)
    img_width, img_height = img.size
    draw = ImageDraw.Draw(img)

    wall_font_size = 18 * img_width / 1000
    wall_font = ImageFont.truetype(os.path.join(script_path, "Arial.ttf"), wall_font_size)

    to_draw_list = []
    if format == "coordinate":
        assert type(visual_marks) == dict
        for (x, y), (pixel_x, pixel_y) in visual_marks.items():
            to_draw_list.append({"pixel": (pixel_x, pixel_y), "text": f"({x},{y})"})

        # Define font (you may need to adjust the path to a font file)
        # adjust the font size based on the image size
        default_font_size = 18 * img_width / 1000
        font = ImageFont.truetype(os.path.join(script_path, "Arial.ttf"), default_font_size)

    elif format == "text":
        assert type(visual_marks) == list
        for visual_mark in visual_marks:
            assert type(visual_mark) == dict
            assert "pixel" in visual_mark and "text" in visual_mark
        to_draw_list = visual_marks

        default_font_size = default_font_size * img_width / 1000
        font = ImageFont.truetype(os.path.join(script_path, "Arial.ttf"), default_font_size)

    else:
        raise ValueError("Invalid format. Choose 'coordinate' or 'text'.")

    # Draw marks and coordinates
    for to_draw_dict in to_draw_list:

        pixel_x, pixel_y = to_draw_dict["pixel"]
        text = to_draw_dict["text"]

        pixel_x = pixel_x * img_width
        pixel_y = pixel_y * img_height

        # Draw an arrow from pixel_x, pixel_y to end_pixel_x, end_pixel_y
        if "end_arrow_pixel" in to_draw_dict:
            end_pixel_x, end_pixel_y = to_draw_dict["end_arrow_pixel"]
            end_pixel_x = end_pixel_x * img_width
            end_pixel_y = end_pixel_y * img_height
            # Calculate arrow properties
            arrow_length = ((end_pixel_x - pixel_x)**2 + (end_pixel_y - pixel_y)**2)**0.5
            angle = math.atan2(end_pixel_y - pixel_y, end_pixel_x - pixel_x)
            # Draw the arrow shaft
            draw.line([pixel_x, pixel_y, end_pixel_x, end_pixel_y], fill="black", width=5)
            # Draw the arrow head
            arrow_head_length = min(15, arrow_length / 3)  # Adjust size as needed
            arrow_head_width = arrow_head_length
            x1 = end_pixel_x - arrow_head_length * math.cos(angle) + arrow_head_width * math.sin(angle)
            y1 = end_pixel_y - arrow_head_length * math.sin(angle) - arrow_head_width * math.cos(angle)
            x2 = end_pixel_x - arrow_head_length * math.cos(angle) - arrow_head_width * math.sin(angle)
            y2 = end_pixel_y - arrow_head_length * math.sin(angle) + arrow_head_width * math.cos(angle)
            draw.polygon([end_pixel_x, end_pixel_y, x1, y1, x2, y2], fill="black")

        # Draw a small red dot
        dot_radius = 3
        draw.ellipse([pixel_x - dot_radius, pixel_y - dot_radius, 
                      pixel_x + dot_radius, pixel_y + dot_radius], 
                     fill="red", outline="red")
        # Draw coordinate text
        text_bbox = draw.textbbox((pixel_x, pixel_y), text, font=font)
        text_w = text_bbox[2] - text_bbox[0]
        text_h = text_bbox[3] - text_bbox[1]

        # coordinate?
        if text.startswith("("):
            draw.text((pixel_x - text_w/2, pixel_y + dot_radius - 2), text, font=font, fill="red")
        else:
            # draw wall variable names
            #if text.startswith("walls["):
            #    draw.text((pixel_x - text_w/2, pixel_y + dot_radius + 2), 
            #            text, font=wall_font, fill="red" if text.startswith("(") else "white")
            # draw asset variable names
            font_color = "black"
            if "end_arrow_pixel" in to_draw_dict:
                if end_pixel_y >= pixel_y:
                    if default_font_size > 80:
                        # that means the arrow is pointing downwards, adjust the text position to be above the dot
                        draw.text((pixel_x - text_w/2, pixel_y + dot_radius - 2 - text_h*1.3), text, font=font, fill=font_color)
                    else:
                        draw.text((pixel_x - text_w/2, pixel_y + dot_radius - 2 - text_h*1.1), text, font=font, fill=font_color)
                else:
                    draw.text((pixel_x - text_w/2, pixel_y + dot_radius - 2), text, font=font, fill=font_color)
            else:
                draw.text((pixel_x - text_w/2, pixel_y + dot_radius - 2), text, font=font, fill=font_color)
    # Save the annotated image
    img.save(output_path)
    print(f"Annotated image saved to {output_path}")


def load_image(image_path):
    # Load the image
    image = cv2.imread(image_path, cv2.IMREAD_UNCHANGED)
    if image is None:
        raise ValueError("Image not loaded correctly.")
    return image
    #except Exception as e:
    #    print(f"Error loading image: {e}")
    #    return None


def overlay_bounding_box(image_path, output_path, visual_mark_path="./data/visual_mark_num.png"):
    image1 = cv2.imread(image_path, cv2.IMREAD_UNCHANGED)
    image2 = cv2.imread(visual_mark_path, cv2.IMREAD_UNCHANGED)
    #print(image1.shape, image2.shape)
    #assert image1.shape[-1] == 4 and image2.shape[-1] == 4

    # Extract the alpha channel from the second image
    # make this semi-transparent
    #image1[..., -1] = image1[..., -1] * 0.1
    # cover image2 over image2
    #mask2 = image2[..., -1]
    #image1[mask2 > 0] = image2[mask2 > 0]

    # Extract the alpha channel from the second image
    mask1 = image1[..., -1] / 255.0
    mask2 = image2[..., -1] / 255.0
    # 
    #image1[..., :3] = image1[..., :3] = 0.5 * image1[..., :3]
    image1[mask1 > 0, -1] = image1[mask1 > 0, -1] * 0.5
    for c in range(0, 3): image1[..., c] = (1-mask2) * image1[..., c] + mask2 * image2[..., c]
    #image1[..., -1] = np.clip(image1[..., -1] + image2[..., -1], 0, 255).astype(np.uint8)
    # Save or display the result
    has_content = (mask1 + mask2) > 0
    image1[..., -1] = has_content * 255 + (1 - has_content) * 0
    cv2.imwrite(output_path, image1)

    #import pdb;pdb.set_trace()
    #cv2.imshow('Composite Image', composite)
    #cv2.waitKey(0)
    #cv2.destroyAllWindows()

    ### Carrie's version
    #try:
    #    # Check if the image has an alpha channel (transparency)
    #    if image.shape[2] == 4:
    #        alpha_channel = image[:, :, 3]
    #        _, binary_mask = cv2.threshold(alpha_channel, 0, 255, cv2.THRESH_BINARY)
    #    else:
    #        print("The image does not have an alpha channel.")
    #        binary_mask = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
    #        _, binary_mask = cv2.threshold(binary_mask, 1, 255, cv2.THRESH_BINARY)

    #    # Find contours in the binary mask
    #    contours, _ = cv2.findContours(binary_mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)

    #    # Get the bounding box of the largest contour
    #    if contours:
    #        largest_contour = max(contours, key=cv2.contourArea)
    #        x, y, w, h = cv2.boundingRect(largest_contour)

    #        # Draw the bounding box on the original image
    #        cv2.rectangle(image, (x, y), (x + w, y + h), (0, 0, 255, 255), 2)  # Blue color with full opacity

    #        # Define corner points and their labels
    #        corners = [(x, y), (x + w, y), (x + w, y + h), (x, y + h)]
    #        labels = [ '0', '1', '2', '3']
    #        offsets = [(-10, -10), (10, -10), (10, 20), (-10, 20)]  # Offsets to place text outside bounding box

    #        # Overlay the numbers at the four corners
    #        for (corner, label, offset) in zip(corners, labels, offsets):
    #            text_position = (corner[0] + offset[0], corner[1] + offset[1])
    #            cv2.putText(image, label, text_position, cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 255, 255), 2)  # Larger font size

    #        cv2.imwrite(output_path, image)
    #        # Convert BGR to RGB for displaying with matplotlib
    #    #     image_rgb = cv2.cvtColor(image, cv2.COLOR_BGRA2RGBA if image.shape[2] == 4 else cv2.COLOR_BGR2RGB)
    #        
    #    #     # Display the result
    #    #     plt.imshow(image_rgb)
    #    #     plt.title('Image with Bounding Box and Corner Labels')
    #    #     plt.axis('off')
    #    #     plt.show()
    #    else:
    #        print("No contours found in the image.")
    #except Exception as e:
    #    print(f"Error processing image: {e}")


def overlay_text(image_paths, texts=None, output_path=None, text_color=(255, 255, 255)):
    if texts is not None:
        if len(image_paths) != len(texts):
            texts = None
    # Open an image file
    images = [Image.open(image_path) for image_path in image_paths]
    img_width, img_height = images[0].size
    positions = [(0, 0), (img_width, 0), (0, img_height), (img_width, img_height)]

    if len(image_paths) == 4:
        grid_image = Image.new('RGB', (img_width * 2, img_height * 2), (255, 255, 255))
    else:
        grid_image = Image.new('RGB', (img_width * 2, img_height), (255, 255, 255))
    # Paste each image into the grid, with check for alpha channel
    for index, image in enumerate(images):
        # If the image has an alpha channel, create a white background and composite the image onto it
        if image.mode == 'RGBA':
            white_bg = Image.new('RGBA', image.size, (255, 255, 255, 255))
            white_bg.paste(image, (0, 0), image)
            image = white_bg.convert('RGB')
        
        # Calculate the position for pasting in the grid
        x = (index % 2) * img_width
        y = (index // 2) * img_height
        if texts is not None:
            # Paste the image
            # grid_image.paste(image, (x, y))
            # Prepare the draw object
            draw = ImageDraw.Draw(image)
            # Define the position for the text (upper-left corner)
            position = (10, 10)
            # Define the text color
            text_color = (0,0,0)  # White
            # Define the font (default font with size 40)
            font = ImageFont.truetype("utils/Arial.ttf", 50)
            # Text to be overlaid
            # Overlay the text on the image
            draw.text(position, texts[index], fill=text_color, font=font)
            # Paste the image
        grid_image.paste(image, (x, y))

    # Draw black lines to create grid boundaries
    draw = ImageDraw.Draw(grid_image)
    line_width = 3
    for i in range(1, 2):
        # Vertical lines
        draw.line((img_width * i + line_width * i, 0, img_width * i + line_width * i, grid_image.height), fill='black', width=line_width)
        # Horizontal lines
        draw.line((0, img_height * i + line_width * i, grid_image.width, img_height * i + line_width * i), fill='black', width=line_width)

    grid_image.save(output_path)
    return output_path


def visualize_grid(room_poly, assets: dict, output_path: str, grid_points=None, randomize_color=False, output_size=(1200,1200), dpi=300):
    ### assets: list of Assets
    room_poly = Polygon(room_poly)
    #plt.rcParams["font.family"] = "Times New Roman"
    plt.rcParams["font.size"] = 12
    # Pre-determined color palette
    color_palette = [
        'red', 'blue', 'green', 'purple', 'orange', 'brown', 'pink', 'gray', 'olive', 'cyan'
    ]

    # Calculate figure size in inches
    fig_size = (output_size[0] / dpi, output_size[1] / dpi)
    # Create a new figure with fixed size and DPI
    fig, ax = plt.subplots(figsize=fig_size, dpi=dpi)
    fig.set_dpi(dpi)

    # draw the room
    x, y = room_poly.exterior.xy
    ax.plot(x, y, '-', label='Room', color='black', linewidth=2)

    # draw the solutions
    idx = 0
    for instance_id, asset in assets.items():
        if instance_id.startswith('walls'):
            continue
        center_x, center_y, center_z = asset.position.cpu().detach().numpy()
        # asset.rotation[-1].cpu().detach().item()
        rotation = asset.get_theta()
        rotated_corners = asset.get_2dpolygon().cpu().detach().numpy()

          # Choose color based on randomize_color flag
        if randomize_color:
            color = (random.random(), random.random(), random.random())
        else:
            color = color_palette[idx % len(color_palette)]

        # create a polygon for the solution
        obj_poly = Polygon(rotated_corners)
        x, y = obj_poly.exterior.xy
        ax.plot(x, y, '-', linewidth=2, color=color, clip_on=False)
        ax.text(rotated_corners[0][0]-0.3, rotated_corners[0][1]-0.3, asset.id, fontsize=8, ha='center', color=color, clip_on=False)

        # ax.text(center_x, center_y, object_name, fontsize=18, ha='center')

        # the object points towards the +y axis
        # get the direction of the object after rotation
        #degree = np.radians(-rotation+90)
        # set arrow direction based on rotation
        ax.arrow(center_x, center_y, np.cos(rotation)/2, np.sin(rotation)/2, head_width=0.1, fc=color, clip_on=False, color=color)
        idx += 1

    # Fix the x-y axis based on the room polygon's bounding box
    min_x, min_y, max_x, max_y = room_poly.bounds
    ax.set_xlim(min_x, max_x)
    ax.set_ylim(min_y, max_y)
    # axis off
    #ax.axis('off')
    ax.spines['top'].set_visible(False)
    ax.spines['right'].set_visible(False)
    ax.spines['bottom'].set_visible(False)
    ax.spines['left'].set_visible(False)
    ax.set_aspect('equal', 'box')  # to keep the ratios equal along x and y axis
    #plt.savefig(output_path, bbox_inches='tight', pad_inches=0, dpi=dpi)
    plt.tight_layout(pad=0)
    plt.savefig(output_path, pad_inches=0.1, dpi=dpi)
    plt.close(fig)


if __name__ == "__main__":
    #vertices = [
    #    [0, 0, -1.6],
    #    [5, 0, -1.6], 
    #    [5, 5, -1.6],
    #    [0, 5, -1.6],
    #]
    vertices = [
        [-1, -1, -1.6],
        [-1, 5, -1.6], 
        [5, 5, -1.6],
        [5, -1, -1.6],
    ]
    assets = [
        Asset(
            id=1,
            category="chair",
            bounding_box=[[1, 1, 1], [2, 2, 2]],
            rotation=[0, 90, 0]
        ),
        Asset(
            id=1,
            category="chair",
            bounding_box=[[0, 0, 0], [1, 1, 1]],
            rotation=[0, 30, 0]
        ),
        Asset(
            id=2,
            category="table",
            bounding_box=[[1, 1, 0.8], [2, 3, 1]],
            rotation=[0, 145, 0]
        ),
    ]
    create_time = str(datetime.datetime.now()).replace(" ", "-").replace(":", "-").replace(".", "-")
    #output_path = f"tmp/{create_time}.pdf"
    output_path = f"tmp/test.pdf"
    os.makedirs("tmp", exist_ok=True)
    visualize_grid(vertices, assets, output_path)

    ### overlay text
    image_path = "/Users/sunfanyun/Downloads/3D_scene_generation/GenLayout/data/sceneVerse/preprocessed/ProcThor/0_shelf/render_{}.png"
    image_paths = [image_path.format(degree) for degree in [0, 90, 180, 270]]
    texts = [f"{degree}°" for degree in [0, 90, 180, 270]]
    output_path = "tmp.png"
    overlay_text(image_paths, texts, output_path)