data/hyper/prompt_utils.py

import base64
import numpy as np
from PIL import Image
import webcolors
import pdb
import matplotlib.pyplot as plt
from matplotlib.colors import to_rgb
import seaborn as sns
import io

def create_color_palette_with_names(palette_name='tab10', n_colors=10):
    """
    Generate a color palette with human-readable color names.

    Parameters:
        palette_name (str): The name of the matplotlib or seaborn palette (e.g., 'tab10', 'Set3', 'husl').
        n_colors (int): The number of colors to generate.

    Returns:
        list of tuples: A list of (color_name, RGB tuple) pairs.
    """
    # Load the color palette
    try:
        palette = sns.color_palette(palette_name, n_colors)
    except ValueError:
        raise ValueError(f"Invalid palette name '{palette_name}'. Try using palettes like 'tab10', 'Set3', or 'husl'.")

    # Convert palette to RGB tuples and approximate color names
    color_palette = []
    for rgb in palette:
        nrgb = tuple((int(c * 255) for c in rgb))
        color_name = f"RGB{nrgb}"  # Fallback to RGB values as color names
        color_palette.append((color_name, tuple(nrgb)))
    
    return color_palette

def color_seg(seg_map, palette):
    """
    Convert a segmentation map to a color image using the given palette.
    seg_map: (H, W) with integer class IDs
    palette: list of [R, G, B] colors for each class
    """
    h, w = seg_map.shape
    color_img = np.zeros((h, w, 3), dtype=np.uint8)
    for class_id, color in palette.colors.items():
        color_img[seg_map == class_id] = color
    return color_img


def closest_colour(requested_colour):
    min_colours = {}
    for name in webcolors.names("css3"):
        r_c, g_c, b_c = webcolors.name_to_rgb(name)
        rd = (r_c - requested_colour[0]) ** 2
        gd = (g_c - requested_colour[1]) ** 2
        bd = (b_c - requested_colour[2]) ** 2
        min_colours[(rd + gd + bd)] = name
    return min_colours[min(min_colours.keys())]


def get_significant_classes(segmentation_map, threshold=0.001):
    """
    Identify significant classes in a segmentation map that occupy more than a given percentage
    of the total area.

    Parameters:
        segmentation_map (np.ndarray): A 2D numpy array of shape (image_width, image_height) where
                                        each pixel is an integer indicating a semantic class.
        threshold (float): The minimum proportion of the total area a label must occupy to be retained.
                           Default is 0.03 (3%).

    Returns:
        list: A list of class IDs that occupy more than the threshold proportion of the total area.
    """
    # Calculate the total number of pixels
    total_pixels = segmentation_map.size

    # Get unique labels and their pixel counts
    unique_labels, label_counts = np.unique(segmentation_map, return_counts=True)

    #[5,11], [15,855]

    # Calculate the proportion of each label
    label_proportions = label_counts / total_pixels
    # [0.001, 0.8]

    # Find labels that exceed the threshold
    retained_labels = unique_labels[label_proportions > threshold]
    retained_percents = label_proportions[label_proportions > threshold]
    class_percents = {id:percent for id, percent in zip(retained_labels, retained_percents)}

    return retained_labels.tolist(), class_percents


def get_tableau_colors():
    """
    Extract Tableau colors with their pure names and RGB tuples.

    Returns:
        dict: A dictionary mapping color names to their RGB tuples.
    """
    # Import Tableau colors from Matplotlib
    TABLEAU_COLORS = {
        'red': '#FF0000',
        'blue': '#0000FF', 
        'green': '#00FF00',
        'yellow': '#FFFF00',
        'purple': '#800080',
        'orange': '#FFA500',
        'pink': '#FFC0CB',
        'brown': '#A52A2A',
        'gray': '#808080',
        'cyan': '#00FFFF',
        'magenta': '#FF00FF',
        'lime': '#32CD32',
        'navy': '#000080',
        'olive': '#808000',
        'maroon': '#800000',
        'teal': '#008080',
        'lavender': '#E6E6FA',
        'turquoise': '#40E0D0',
        'indigo': '#4B0082',
        'coral': '#FF7F50'
    }

    # Convert hex to RGB to BGR
    tableau_colors = {name: tuple(int(c * 255) for c in to_rgb(color))
                      for name, color in TABLEAU_COLORS.items()}
    
    return tableau_colors

def generate_color_coded_segmentation_map(segmentation_map, class_colors, label_remap=None):
    """
    Generate a color-coded segmentation map given a segmentation map and class colors.

    Parameters:
        segmentation_map (np.ndarray): A 2D numpy array where each pixel is a class ID.
        class_colors (dict): A dictionary mapping class IDs to RGB tuples, e.g., {0: (255, 0, 0), ...}.

    Returns:
        Image: A PIL Image object of the color-coded segmentation map.
    """
    # Create an empty array for the color-coded image
    height, width = segmentation_map.shape
    color_coded_map = np.zeros((height, width, 3), dtype=np.uint8)

    # Assign colors to each class
    for class_id, (color_name, color) in enumerate(class_colors.items()):
        if label_remap is not None:
            if class_id == len(label_remap)-1:
                break
            class_id = label_remap[class_id]
        mask = segmentation_map == int(class_id)
        color_coded_map[mask] = color
        

    # Convert to a PIL Image for saving or visualization
    return Image.fromarray(color_coded_map)


def rgb_to_color_name(rgb):
    """
    Convert an RGB tuple to a human-readable color name.

    Parameters:
        rgb (tuple): A tuple representing the RGB color, e.g., (255, 0, 0).
    Returns:
        str: The closest color name as a string.
    """
    try:
        # Try to match the exact color name
        return webcolors.rgb_to_name(rgb)
    except ValueError:
        # If no exact match, find the closest color
        closest_name = closest_colour(rgb)
        return closest_name


def generate_prompt_for_segmentation(class_colors, class_labels, class_percents):
    """
    Generate a descriptive prompt for the segmentation map based on class colors and class labels.

    Parameters:
        class_colors (dict): A dictionary mapping class IDs to RGB tuples, e.g., {0: (255, 0, 0), ...}.
        class_labels (dict): A dictionary mapping class IDs to their names, e.g., {0: "building", ...}.
        use_color_names (bool): Whether to use human-readable color names instead of RGB values.

    Returns:
        str: A formatted prompt describing the segmentation map.
    """
    prompt_lines = ["You are an AI visual assistant that can describe the scene given a segmentation map. " 
                    "The map uses colors to represent different land cover types. The color legend is as follows:"]
    
    presented_labels = []
    for class_id, label in class_labels.items():
        color_description = class_colors[class_id]
        percent = class_percents[class_id]
        label = class_labels.get(class_id, "unknown class")
        prompt_lines.append(f"- {color_description} color represents {label}, which occupies {int(percent*100)+1} percent area.")
        presented_labels.append(label)
    
    prompt = ("\n "
              "Do not mention any colors, color coding, or technical details. "
              "Use the given class names. Only mention land cover types in the color legend. "
              "Generate a brief and natural description of the scene by refining "
              f"'The hyperspectral image contains {', '.join(presented_labels)} land types'. "
              "Provide a concise description on their spatial distributions (e.g. left, right, top, bottom)."
              )
    
    return "\n".join(prompt_lines) + prompt



def generate_elevation_map_prompt(segmentation_map, height_map, class_labels):
    """
    Generate a descriptive prompt for an elevation map based on the segmentation map and height map.

    Parameters:
        segmentation_map (np.ndarray): A 2D numpy array where each pixel is a class ID.
        height_map (np.ndarray): A 2D numpy array where each pixel indicates the height at that location.
        class_labels (dict): A dictionary mapping class IDs to their semantic labels.
    
    Returns:
        str: A descriptive prompt for the elevation map.
    """
    # Find the highest and lowest points
    highest_height = np.max(height_map)
    lowest_height = np.min(height_map)

    # Identify the corresponding classes
    highest_class_id = segmentation_map[np.unravel_index(np.argmax(height_map), height_map.shape)]
    lowest_class_id = segmentation_map[np.unravel_index(np.argmin(height_map), height_map.shape)]
    
    highest_class = class_labels.get(highest_class_id, "unknown")
    lowest_class = class_labels.get(lowest_class_id, "unknown")

    # Generate the prompt
    prompt = (
        "This is an elevation map that indicates the height of each pixel. "
        f"The highest areas, at an elevation of approximately {int(highest_height*255/5)} meters, are {highest_class}. "
        f"The lowest areas, at an elevation of approximately {int(lowest_height*255/5)} meters, are {lowest_class}. "
        "Based on the provided context and elevation values, generate a concise and accurate description of the elevation map. "
        "Describe the image by briefly introducing: 1) the heighest and lowest land cover types; "
        "2) Is the terrain relatively flat or does it have significant elevation differences."
    )

    return prompt


def encode_image(image_path):
        with open(image_path, "rb") as image_file:
            return base64.b64encode(image_file.read()).decode('utf-8')


def downsample_image(image, skip_index):
    """
    Downsample a PIL image by skipping pixels.

    Args:
    image (PIL.Image.Image): The source image.
    skip_index (int): The number of pixels to skip.

    Returns:
    PIL.Image.Image: The downsampled image.
    """
    # Ensure the input is a PIL Image
    if not isinstance(image, Image.Image):
        raise ValueError("image must be a PIL.Image.Image object")

    # Get the size of the original image
    width, height = image.size

    # Calculate the size of the downsampled image
    new_width = (width + skip_index - 1) // skip_index
    new_height = (height + skip_index - 1) // skip_index

    # Create a new image of the desired size
    downsampled_image = Image.new("RGB", (new_width, new_height))

    # Copy pixels from the original image to the new image, skipping as appropriate
    for y in range(0, height, skip_index):
        for x in range(0, width, skip_index):
            downsampled_image.putpixel((x // skip_index, y // skip_index), image.getpixel((x, y)))

    return downsampled_image


def resize_and_encode_image(pil_image):
    """
    Resize an image to 128x128 using nearest neighbor interpolation and then encode it to base64.

    Args:
    image_path (str): The path to the image file.

    Returns:
    str: A base64 encoded string of the resized image.
    """
    # Open the image
    resized_img = downsample_image(pil_image, 2)

    # Save the resized image to a bytes buffer
    buffer = io.BytesIO()
    format = pil_image.format if pil_image.format else "PNG"  # Default to PNG if format is None

    resized_img.save(buffer, format=format)

    # Get the byte data from the buffer
    byte_data = buffer.getvalue()

    # Encode the byte data to base64
    base64_encoded = base64.b64encode(byte_data).decode('utf-8')

    return base64_encoded


def generate_flood_map_prompt(binary_mask):
    """
    Generate a descriptive prompt for flood maps for Vision Large Language Models (VLMs).

    Parameters:
        binary_mask (np.ndarray): A 2D numpy array where 1 indicates a flooded area and 0 indicates non-flooded areas.
    
    Returns:
        str: A prompt describing the flood map, including the portion of flooded area and spatial locations.
    """
    # Compute the total and flooded area
    total_area = binary_mask.size
    flooded_area = np.sum(binary_mask)
    flood_percentage = (flooded_area / total_area) * 100

    # Compute the spatial distribution of flooded areas
    height, width = binary_mask.shape
    top_half = binary_mask[:height // 2, :]
    bottom_half = binary_mask[height // 2:, :]
    left_half = binary_mask[:, :width // 2]
    right_half = binary_mask[:, width // 2:]

    # Analyze the spatial distribution
    spatial_parts = []
    if np.sum(top_half) > 0:
        spatial_parts.append("top")
    if np.sum(bottom_half) > 0:
        spatial_parts.append("bottom")
    if np.sum(left_half) > 0:
        spatial_parts.append("left")
    if np.sum(right_half) > 0:
        spatial_parts.append("right")

    spatial_description = ", ".join(spatial_parts) if spatial_parts else "no specific region"

    # Generate the prompt
    prompt = (
        "This is a flood map where areas marked with white pixels indicate flooded regions. "
        f"The flooded area occupies approximately {flood_percentage:.2f}% of the entire map. "
        "Please analyze the flood map and provide insights into the affected areas. You must generate "
        "a short description (less than 70 words) of the elevation image. First describe the portion of floods; "
        "then introduce the location of the flooded areas."
    )

    return prompt