lybic-guiagents 0.1.0__py3-none-any.whl

desktop_env/evaluators/metrics/gimp.py

@@ -0,0 +1,637 @@
+import os
+import logging
+from typing import List, Union
+from skimage.metrics import structural_similarity as ssim
+from PIL import Image, ImageChops, ImageStat
+
+
+def compare_image_list(pred_img_path_list: Union[str, List[str]],
+                       gold_img_path_list: Union[str, List[str]]) -> float:
+    """ Compare two image lists, only if all images are the same, return 1.0, otherwise return 0.0
+    """
+    if type(pred_img_path_list) != list:
+        pred_img_path_list = [pred_img_path_list]
+        gold_img_path_list = [gold_img_path_list]
+    for pred_img_path, gold_img_path in zip(pred_img_path_list, gold_img_path_list):
+        if not pred_img_path or not gold_img_path:
+            return 0.0
+        pred_img = Image.open(pred_img_path)
+        gold_img = Image.open(gold_img_path)
+        diff = ImageChops.difference(pred_img, gold_img)
+        if diff.getbbox():
+            return 0.0
+    return 1.0
+
+
+def get_gimp_export_path():
+    # Path to GIMP's configuration file. This example assumes GIMP version 2.10.
+    # You need to adjust the path according to the GIMP version and user's file system.
+    gimp_config_file = os.path.expanduser("~/.config/GIMP/2.10/gimprc")
+
+    try:
+        # Open and read the configuration file
+        with open(gimp_config_file, 'r') as file:
+            for line in file:
+                # Search for the default export path setting
+                if "default-export-path" in line:
+                    # Extract the current path from the line (assuming it's enclosed in quotes)
+                    current_path = line.split('"')[1]
+                    # Compare the current path with the expected path
+                    return current_path
+    except FileNotFoundError:
+        # Handle the case where the configuration file is not found
+        logging.debug("GIMP configuration file not found")
+        return False
+
+
+def check_file_exists(directory, filename):
+    file_path = os.path.join(directory, filename)
+    return 1 if os.path.isfile(file_path) else 0
+
+
+def increase_saturation(image1_path: str, image2_path: str) -> float:
+    def calculate_saturation(image):
+        # convert the image to HSV mode
+        hsv_image = image.convert("HSV")
+
+        saturation_channel = hsv_image.split()[1]
+
+        # calculate the mean saturation level
+        stat = ImageStat.Stat(saturation_channel)
+        mean_saturation = stat.mean[0]
+
+        return mean_saturation
+
+    image1 = Image.open(image1_path)
+    image2 = Image.open(image2_path)
+
+    # calculate the saturation level of each image
+    saturation1 = calculate_saturation(image1)
+    saturation2 = calculate_saturation(image2)
+
+    return 1 if saturation1 < saturation2 else 0
+
+
+def decrease_brightness(image1_path: str, image2_path: str) -> float:
+    def calculate_brightness(image):
+        # Convert the image to grayscale mode
+        grayscale_image = image.convert("L")
+
+        # Get the image data
+        pixels = list(grayscale_image.getdata())
+
+        brightness = sum(pixels) / len(pixels)
+        return brightness
+
+    image1 = Image.open(image1_path)
+    image2 = Image.open(image2_path)
+
+    brightness1 = calculate_brightness(image1)
+    brightness2 = calculate_brightness(image2)
+
+    return 1 if brightness1 > brightness2 else 0
+
+
+import cv2
+import numpy as np
+
+
+def find_yellow_triangle(image):
+    # Convert the image to RGBA
+    rgba = cv2.cvtColor(image, cv2.COLOR_BGR2RGBA)
+
+    # define range of yellow color in HSV
+    lower_yellow = np.array([0, 0, 0], dtype=np.uint8)
+    upper_yellow = np.array([255, 255, 255], dtype=np.uint8)
+
+    # expand the dimensions of lower and upper yellow to match the image dimensions
+    lower_yellow = np.reshape(lower_yellow, (1, 1, 3))
+    upper_yellow = np.reshape(upper_yellow, (1, 1, 3))
+    # build a mask for the yellow color
+    mask = cv2.inRange(rgba, lower_yellow, upper_yellow)
+
+    # search for contours in the mask
+    contours, _ = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+
+    # choose the largest contour
+    max_contour = max(contours, key=cv2.contourArea)
+
+    # calculate the center of the contour
+    M = cv2.moments(max_contour)
+    cx = int(M['m10'] / M['m00'])
+    cy = int(M['m01'] / M['m00'])
+
+    return cx, cy
+
+
+def compare_triangle_positions(image1, image2):
+    image1 = cv2.imread(image1, cv2.IMREAD_COLOR)
+    image2 = cv2.imread(image2, cv2.IMREAD_COLOR)
+    # find the center of the yellow triangle in each image
+    cx1, cy1 = find_yellow_triangle(image1)
+    cx2, cy2 = find_yellow_triangle(image2)
+
+    # calculate the distance between the center of the triangle and the center of the image
+    center_distance1 = np.sqrt(
+        (cx1 - image1.shape[1] // 2) ** 2 + (cy1 - image1.shape[0] // 2) ** 2)
+    center_distance2 = np.sqrt(
+        (cx2 - image2.shape[1] // 2) ** 2 + (cy2 - image2.shape[0] // 2) ** 2)
+
+    return 1 if center_distance1 > center_distance2 else 0
+
+
+# Functions for the GIMP evaluator
+def calculate_brightness(image):
+    """Calculate the average brightness of an image"""
+    grayscale = image.convert('L')
+    stat = ImageStat.Stat(grayscale)
+    return stat.mean[0]
+
+
+def normalize_brightness(image, target_brightness):
+    """Normalize the brightness of an image to a target brightness in [0, 1]"""
+    current_brightness = calculate_brightness(image)
+    factor = target_brightness / current_brightness
+
+    # Apply a point transform to each pixel
+    def point_transform(x):
+        return min(255, max(0, int(x * factor)))
+
+    return image.point(point_transform)
+
+
+def measure_saturation(hsv_image):
+    """Measure the average saturation of an image"""
+    # Split into H, S, V channels
+    _, s, _ = hsv_image.split()
+    # Convert the saturation channel to a numpy array
+    s_array = np.array(s)
+    # Calculate the average saturation
+    avg_saturation = np.mean(s_array)
+    return avg_saturation
+
+
+def calculate_contrast(image):
+    """Calculate the contrast of an image as the standard deviation of the pixel
+    values."""
+    pixels = np.asarray(image, dtype=np.float32)
+    return np.std(pixels)
+
+
+def calculate_image_sharpness(image_path):
+    # Load the image in grayscale
+    image = cv2.imread(image_path, cv2.IMREAD_GRAYSCALE)
+    # Apply the Laplacian operator
+    laplacian = cv2.Laplacian(image, cv2.CV_64F)
+    # Calculate the variance
+    variance = np.var(laplacian)
+    return variance
+
+
+def structure_check_by_mse(img1, img2, threshold=0.03):
+    """Check if two images are approximately the same by MSE"""
+    mse = np.mean(
+        (np.array(img1, dtype=np.float32) / 255
+         - np.array(img2, dtype=np.float32) / 255) ** 2)
+    structure_same = True if mse < threshold else False
+    logging.debug(f"MSE: {mse}, threshold: {threshold}")
+    return structure_same
+
+
+def structure_check_by_ssim(img1, img2, threshold=0.9):
+    """Check if two images are approximately the same by SSIM"""
+    similarity = ssim(np.array(img1), np.array(img2), multichannel=True, channel_axis=-1)
+    logging.debug("SSIM: %s", similarity)
+    return similarity >= threshold
+
+
+def check_brightness_decrease_and_structure_sim(src_path, tgt_path, threshold=0.03):
+    """
+    Check the brightness of src is lower than tgt and the structures are similar
+    gimp:7a4deb26-d57d-4ea9-9a73-630f66a7b568
+    """
+    if src_path is None or tgt_path is None:
+        return 0.
+
+    img_src = Image.open(src_path)
+    img_tgt = Image.open(tgt_path)
+
+    # Brightness comparison
+    brightness_src = calculate_brightness(img_src)
+    brightness_tgt = calculate_brightness(img_tgt)
+    brightness_reduced = brightness_tgt > brightness_src
+    
+    # print(f"Brightness src: {brightness_src}, tgt: {brightness_tgt}, reduced: {brightness_reduced}")
+
+    # Normalize and compare images
+    target_brightness = 128
+    img_src_normalized = normalize_brightness(img_src, target_brightness)
+    img_tgt_normalized = normalize_brightness(img_tgt, target_brightness)
+
+    structure_same = structure_check_by_mse(img_src_normalized, img_tgt_normalized, threshold=threshold)
+    if brightness_reduced and structure_same:
+        return 1.
+    else:
+        return 0.
+
+
+def check_saturation_increase_and_structure_sim(src_path, tgt_path):
+    """
+    Check the saturation of src is higher than tgt and the structures are similar
+    gimp:554785e9-4523-4e7a-b8e1-8016f565f56a
+    """
+    if src_path is None or tgt_path is None:
+        return 0.
+
+    img_src = Image.open(src_path)
+    hsv_img_src = img_src.convert('HSV')
+    img_tgt = Image.open(tgt_path)
+    hsv_img_tgt = img_tgt.convert('HSV')
+
+    # Saturation comparison
+    src_saturation = measure_saturation(hsv_img_src)
+    tgt_saturation = measure_saturation(hsv_img_tgt)
+
+    saturation_increased = tgt_saturation < src_saturation
+
+    # Structure comparison
+    h1, s1, v1 = hsv_img_src.split()
+    h2, s2, v2 = hsv_img_tgt.split()
+    h_same = structure_check_by_ssim(h1, h2)
+    v_same = structure_check_by_ssim(v1, v2)
+    if h_same and v_same:
+        structure_same = True
+    else:
+        structure_same = False
+
+    if saturation_increased and structure_same:
+        return 1.
+    else:
+        return 0.
+
+
+def check_file_exists_and_structure_sim(src_path, tgt_path):
+    """
+    Check if the image has been exported to the desktop
+    gimp:77b8ab4d-994f-43ac-8930-8ca087d7c4b4
+    """
+    if src_path is None or tgt_path is None:
+        return 0.
+
+    # Check if the file exists
+    export_file_exists = os.path.isfile(src_path)
+    if not export_file_exists:
+        return 0.
+
+    # Check whether the target image is the same as the source image
+    img_src = Image.open(src_path)
+    img_tgt = Image.open(tgt_path)
+    structure_same = structure_check_by_ssim(img_src, img_tgt)
+
+    if structure_same:
+        return 1.
+    else:
+        return 0.
+
+
+def check_triangle_position(tgt_path):
+    """
+    Check if the triangle is in the middle of the image.
+    gimp:f4aec372-4fb0-4df5-a52b-79e0e2a5d6ce
+    """
+    if tgt_path is None:
+        return 0.
+
+    # Load the image
+    img = Image.open(tgt_path)
+    img_array = np.array(img)
+
+    # We assume the triangle is a different color from the background
+    # Find the unique colors
+    unique_colors, counts = np.unique(img_array.reshape(-1, img_array.shape[2]), axis=0,
+                                      return_counts=True)
+    unique_colors_sorted = unique_colors[np.argsort(counts)]
+
+    # Assuming the background is the most common color and the triangle is a different color
+    triangle_color = unique_colors_sorted[1]
+
+    # Create a mask where the triangle pixels are True
+    triangle_mask = np.all(img_array == triangle_color, axis=2)
+
+    # Get the coordinates of the triangle pixels
+    triangle_coords = np.argwhere(triangle_mask)
+
+    # Calculate the centroid of the triangle
+    centroid = triangle_coords.mean(axis=0)
+
+    # Check if the centroid is approximately in the middle of the image
+    image_center = np.array(img_array.shape[:2]) / 2
+
+    # We will consider the triangle to be in the middle if the centroid is within 5% of the image's center
+    tolerance = 0.05 * np.array(img_array.shape[:2])
+    middle = np.all(np.abs(centroid - image_center) < tolerance)
+
+    if bool(middle):
+        return 1.
+    else:
+        return 0.
+
+
+def check_structure_sim(src_path, tgt_path):
+    """
+    Check if the structure of the two images are similar
+    gimp:2a729ded-3296-423d-aec4-7dd55ed5fbb3
+    """
+    if src_path is None or tgt_path is None:
+        return 0.
+
+    img_src = Image.open(src_path)
+    img_tgt = Image.open(tgt_path)
+    structure_same = structure_check_by_ssim(img_src, img_tgt)
+    if structure_same:
+        return 1.
+    else:
+        return 0.
+
+
+def check_structure_sim_resized(src_path, tgt_path):
+    """
+    Check if the structure of the two images are similar after resizing.
+    gimp:d16c99dc-2a1e-46f2-b350-d97c86c85c15
+    """
+    if src_path is None or tgt_path is None:
+        return 0.
+
+    img_src = Image.open(src_path)
+    img_tgt = Image.open(tgt_path)
+
+    # Check if source image has transparency and extract content area
+    if img_src.mode in ('RGBA', 'LA') or 'transparency' in img_src.info:
+        if img_src.mode != 'RGBA':
+            img_src = img_src.convert('RGBA')
+        
+        # Get alpha channel and find bounding box of non-transparent pixels
+        alpha = img_src.split()[-1]
+        bbox = alpha.getbbox()
+        
+        if bbox is None:
+            # Image is completely transparent
+            logging.debug("Source image is completely transparent")
+            return 0.
+        
+        # Crop to content area only
+        img_src_content = img_src.crop(bbox)
+        logging.debug(f"Source image cropped from {img_src.size} to {img_src_content.size}")
+        
+        # Convert to RGB for comparison
+        img_src_content = img_src_content.convert('RGB')
+        img_src_resized = img_src_content.resize(img_tgt.size)
+    else:
+        # No transparency, resize normally
+        img_src_resized = img_src.resize(img_tgt.size)
+    
+    # Ensure target image is RGB for comparison
+    if img_tgt.mode != 'RGB':
+        img_tgt = img_tgt.convert('RGB')
+
+    # Check if the structure is similar
+    structure_same = structure_check_by_ssim(img_src_resized, img_tgt)
+    if structure_same:
+        return 1.
+    else:
+        return 0.
+
+
+def check_contrast_increase_and_structure_sim(src_path, tgt_path):
+    """
+    Check if the src image has higher contrast than the tgt image and the structures are similar
+    gimp:f723c744-e62c-4ae6-98d1-750d3cd7d79d
+    """
+    if src_path is None or tgt_path is None:
+        return 0.
+
+    # Load images
+    source_image = Image.open(src_path)
+    target_image = Image.open(tgt_path)
+
+    # Calculate contrast
+    source_contrast = calculate_contrast(source_image)
+    target_contrast = calculate_contrast(target_image)
+    higher_contrast = target_contrast < source_contrast
+
+    # Check structure
+    structure_same = structure_check_by_ssim(source_image, target_image, threshold=0.65)
+
+    if higher_contrast and structure_same:
+        return 1.
+    else:
+        return 0.
+
+
+def check_config_status(actual_config_path, rule):
+    """
+    Check if the GIMP status is as expected
+    """
+    if actual_config_path is None:
+        return 0.
+
+    with open(actual_config_path, 'r') as f:
+        content = f.readlines()
+
+    for line in content:
+        if line.startswith('#') or line == '\n':
+            continue
+        items = line.strip().lstrip('(').rstrip(')\n').split()
+        if isinstance(rule["key"], str):
+            if items[0] == rule["key"] and items[-1] == rule["value"]:
+                return 1.
+        elif isinstance(rule["key"], list) and len(rule["key"]) == 2:
+            if items[0] == rule["key"][0] \
+                    and items[1] == rule["key"][1] \
+                    and items[-1] == rule["value"]:
+                return 1.
+    return 0.
+
+
+def check_image_size(src_path, rule):
+    """
+    Check if the size of the src image is correct
+    multi-apps:42f4d1c7-4521-4161-b646-0a8934e36081
+    """
+    if src_path is None:
+        return 0.
+
+    # Load the image
+    img = Image.open(src_path)
+    
+    # Check if we should ignore transparent parts
+    ignore_transparent = rule.get("ignore_transparent", False)
+    
+    if ignore_transparent and img.mode in ('RGBA', 'LA') or 'transparency' in img.info:
+        # Calculate bounding box of non-transparent pixels
+        if img.mode != 'RGBA':
+            img = img.convert('RGBA')
+        
+        # Get alpha channel
+        alpha = img.split()[-1]
+        
+        # Find bounding box of non-transparent pixels
+        bbox = alpha.getbbox()
+        
+        if bbox is None:
+            # Image is completely transparent
+            actual_width = 0
+            actual_height = 0
+        else:
+            # Calculate actual content size
+            actual_width = bbox[2] - bbox[0]
+            actual_height = bbox[3] - bbox[1]
+        
+        logging.debug(f"Original size: {img.size}, Content size: {actual_width}x{actual_height}")
+    else:
+        # Use original image size
+        actual_width = img.size[0]
+        actual_height = img.size[1]
+        logging.debug(f"Image size: {img.size}")
+
+    # Check the size
+    if rule.get("height", None) is not None:
+        height_same = actual_height == rule["height"]
+    else:
+        height_same = True
+    if rule.get("width", None) is not None:
+        width_same = actual_width == rule["width"]
+    else:
+        width_same = True
+
+    if height_same and width_same:
+        logging.debug(f"height_same: {height_same}, width_same: {width_same}")
+        return 1.
+    else:
+        logging.debug(f"height_same: {height_same}, width_same: {width_same}")
+        return 0.
+
+
+def check_palette_and_structure_sim(src_path, tgt_path):
+    """
+    Check if the src image is palette-based and the structure of the two images are similar
+    gimp:06ca5602-62ca-47f6-ad4f-da151cde54cc
+    """
+    if src_path is None or tgt_path is None:
+        return 0.
+
+    # Check if the source image is palette-based
+    source_image = Image.open(src_path)
+    palette_based = source_image.mode == 'P'
+
+    # Check structure
+    target_image = Image.open(tgt_path)
+    source_image = source_image.convert('RGB')
+    structure_same = structure_check_by_ssim(source_image, target_image)
+    if palette_based and structure_same:
+        return 1.
+    else:
+        return 0.
+
+
+def check_textbox_on_leftside(src_path):
+    """
+    Check if the textbox is on the left side of the image.
+    gimp:e2dd0213-26db-4349-abe5-d5667bfd725c
+    """
+    if src_path is None:
+        return 0.
+
+    source_image = Image.open(src_path)
+    gray_image = source_image.convert("L")
+    width, height = source_image.size
+
+    # Find the bounds of the black text
+    left_most_dark_pixel = width  # Start with the farthest possible left position
+    for y in range(height):
+        for x in range(width):
+            # If the pixel is dark, consider it as part of the text
+            if gray_image.getpixel((x, y)) < 128:  # Arbitrary threshold for "dark"
+                left_most_dark_pixel = min(left_most_dark_pixel, x)
+                break  # Stop after finding the first dark pixel in this row
+
+    # Here we define "almost" on the left side as being within the left 5% of the image
+    if left_most_dark_pixel < width * 0.05:
+        return 1.
+    else:
+        return 0.
+
+
+def check_image_mirror(src_path, tgt_path):
+    """
+    Check if the image is mirrored
+    gimp:72f83cdc-bf76-4531-9a1b-eb893a13f8aa
+    """
+    if src_path is None or tgt_path is None:
+        return 0.
+
+    # Load images
+    source_image = Image.open(src_path)
+    target_image = Image.open(tgt_path)
+
+    # Check if the image is mirrored
+    transposed_image = source_image.transpose(Image.FLIP_LEFT_RIGHT)
+    # Use 0.99 because the image may not be exactly mirrored by gimp
+    mirrored = structure_check_by_ssim(transposed_image, target_image, 0.99)
+    if mirrored:
+        return 1.
+    else:
+        return 0.
+
+
+def check_green_background(src_path, tgt_path):
+    """
+    Check if the background of the source image is green.
+    gimp:734d6579-c07d-47a8-9ae2-13339795476b
+    """
+    if src_path is None or tgt_path is None:
+        return 0.
+
+    # Load images
+    source_image = Image.open(src_path)
+    target_image = Image.open(tgt_path)
+
+    source_pixels = np.array(source_image)
+    target_pixels = np.array(target_image)
+
+    for x in range(target_image.width):
+        for y in range(target_image.height):
+            # Identify background pixel in target image (not black)
+            if tuple(target_pixels[x, y][:3]) != (0, 0, 0):
+                # Check if corresponding pixel in source image is green
+                # Here, "green" means more green than red or blue
+                r, g, b = source_pixels[x, y][:3]
+                if not (g > r and g > b):
+                    return 0.
+
+    return 1.
+
+
+def check_sharper(src_path, tgt_path):
+    """
+    Check if the source image is sharper than the target image.
+    multi-app:bb7db4c2-30b5-4be7-8dd7-b8c4ec7d3108
+    """
+    sharpness_src = calculate_image_sharpness(src_path)
+    sharpness_tgt = calculate_image_sharpness(tgt_path)
+    return 1.0 if sharpness_src > sharpness_tgt else 0.0
+
+
+def check_image_file_size(src_path, rule):
+    """
+    Check if the size of the src image within 500KB
+    """
+    if src_path is None:
+        return 0.0
+
+    # Check the size
+    file_size = os.path.getsize(src_path)
+    if file_size < rule["max_size"]:
+        return 1.0
+    else:
+        return 0.0

desktop_env/evaluators/metrics/libreoffice.py

@@ -0,0 +1,28 @@
+import fnmatch
+from typing import Dict, List
+
+import lxml.cssselect
+import lxml.etree
+from lxml.etree import _Element as Element
+
+_libconf_namespaces = [("oor", "http://openoffice.org/2001/registry")]
+_libconf_ns_mapping = dict(_libconf_namespaces)
+_setup_locale_selector = lxml.cssselect.CSSSelector('item[oor|path$=L10N]>prop[oor|name=ooSetupSystemLocale]>value',
+                                                    namespaces=_libconf_ns_mapping)
+_locale_selector = lxml.cssselect.CSSSelector('item[oor|path$=L10N]>prop[oor|name=ooLocale]>value',
+                                              namespaces=_libconf_ns_mapping)
+
+
+def check_libre_locale(config_file: str, rules: Dict[str, List[str]]) -> float:
+    config: Element = lxml.etree.parse(config_file).getroot()
+    setup_locale_setting: List[Element] = _setup_locale_selector(config)
+    locale_setting: List[Element] = _locale_selector(config)
+
+    setup_locale_setting: str = setup_locale_setting[0].text \
+        if len(setup_locale_setting) > 0 \
+        else locale_setting[0].text
+
+    return float(any(fnmatch.fnmatchcase(setup_locale_setting, ptn) \
+                     for ptn in rules["locale_set"]
+                     )
+                 )