Add generation scripts for all tasks

README.md

@@ -20,7 +20,7 @@ size_categories:
 
 Percept-V is a benchmark of **30 synthetic visual perception tasks**, 200 samples each (**6,000 samples total**), designed to isolate *perception* from *reasoning* in vision-language models. Every task is procedurally generated from simple primitives — circles, lines, grids, shapes, colours — so a model that genuinely sees the image should solve it near-perfectly, and failures point at perceptual rather than reasoning limits.
 
-Tasks span counting, colour identification, shape identification, spatial localisation, layering/occlusion, grid navigation, and two-image comparison. Each task ships with its images, ground truth, prompts, and the exact parsing and scoring scripts used to evaluate it.
+Tasks span counting, colour identification, shape identification, spatial localisation, layering/occlusion, grid navigation, and two-image comparison. Each task ships with its images, ground truth, prompts, the script that generated them, and the exact parsing and scoring scripts used to evaluate it.
 
 ## Repository layout
 
@@ -35,10 +35,13 @@ Each task is a self-contained directory:
 │   ├── input_prompt.txt     # describes what the image contains
 │   ├── rules.txt            # the task the model must perform
 │   └── output_prompt.txt    # required output format
+├── script.py                # generator that produced data/ and data.json
 ├── utils.py                 # parses raw model text into a structured answer
 └── eval.py                  # scores parsed answers against the ground truth
 ```
 
+`colours_present`, `layered_colours` and `list_colours` also contain `swatches.png`, the colour reference strip their generator appends below each image.
+
 ### Prompt construction
 
 The three prompt files are fragments meant to be concatenated into a single instruction, e.g. for `sort_lines`:
@@ -197,8 +200,29 @@ Eight tasks — `circle_right_triangle`, `cross_and_knots`, `graph_counting`, `g
 - `eval.py` takes `--answer`/`-a` and `--output`/`-o`; the defaults refer to files that are not shipped here, so pass both explicitly.
 - Several `utils.py` files contain a second, commented-out `output_from_text` inside a triple-quoted string, left over from earlier prompt formats. Only the live top-level definition is used.
 
+## Regenerating the data
+
+`<task>/script.py` is the generator used for the released data. The one exception is `colours_present/script.py`, which includes the 2026-09-11 fix, so its output now matches the corrected labels. Each task was produced by a single call with 10 images per difficulty level:
+
+```bash
+mkdir -p gen/counting_circles && cd gen/counting_circles      # use an empty directory
+cp <path-to-Percept-V>/counting_circles/script.py .
+python script.py --num_images 10 --num_sizes 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
+```
+
+- **Difficulty levels:** `--num_sizes` is 1–20 for every task except `grid_path` and `maze_solving`, which use 3–22. `circle_right_triangle`, `cross_and_knots`, `grid_path`, `locate_circles_colour` and `locate_circles_shape` use their default `--grid_size 6`.
+- **Output location:** the script writes `data/` and `data.json` into the **current directory**, overwriting existing ones, so do not run it inside a downloaded copy of this dataset. File numbering starts at `--file` (default 1).
+- **No fixed random seeds:** a run produces a new sample from the same distribution, not the released images.
+- **Requirements:** Python 3 with `numpy`, `matplotlib` and `Pillow`, plus `opencv-python` (imported by `colours_present`, `layered_colours`, `list_colours`, `mirror_image`, `water_image`) and `networkx` (`graph_counting`).
+- **Files the scripts read from the working directory:**
+  - `swatches.png`, for `colours_present`, `layered_colours` and `list_colours`: copy it from the task directory.
+  - An Arial font file, named `arial.ttf` (`grid_path`, `locate_circles_colour`, `locate_circles_shape`) or `ARIAL.ttf` (`sort_lines`). It is not included in this repository. If Pillow finds it neither in the working directory nor in the system font folders, `grid_path` and `sort_lines` stop with an error, and the two `locate_circles` tasks fall back to Pillow's much smaller default font.
+  - Background images `background_image/bg_1.png` … `bg_10.png`, for `list_colours` and `list_shapes`. These are not included in this repository.
+
 ## Changelog
 
+- **2026-09-11 — Generation scripts added.** Every task directory now includes its `script.py`, plus `swatches.png` where the generator needs it. See "Regenerating the data".
+
 - **2026-09-11 — `colours_present` ground truth corrected.** In earlier versions of `colours_present/data.json`, the 20 yes/no answers were listed in a different colour order from the one given in `rules.txt`, so 183 of the 200 records had wrong labels. Scores on this task computed before this date are not valid. `colours_present/eval.py` now takes the gold labels from `data.json` (matched on `id`) instead of from the answer file, so re-running it on existing answer files gives corrected scores without repeating inference. It prints a note when an answer file still carries the old labels, and accepts `--gold` to point at a different `data.json`. The task is single-image; the table and loader above are updated accordingly.
 
 ## Licence

change_colour/script.py

@@ -0,0 +1,139 @@
+from PIL import Image, ImageDraw
+import sys
+import random
+import os
+import json
+import argparse
+import random
+
+
+def create_images(num_images, num_objects_list , file):
+    # Ensure that the directory exists
+    # output_dir = "./data"
+    output_dir = os.path.join(os.getcwd(), "data")
+    if not os.path.exists(output_dir):
+        os.makedirs(output_dir)
+
+    data = []
+    image_width, image_height = 1500, 1000
+    append = (file != 1)
+    for num_objects in num_objects_list:
+        max_obj = num_objects*2
+        for img_index in range(num_images):
+            # Create a blank white image
+            image = Image.new("RGB", (image_width, image_height), "white")
+            draw = ImageDraw.Draw(image)
+
+            # List to hold positions of circles
+            colour_dict = {1: "red", 2: "blue", 3: "green"}
+            colours1 = []
+            colours2 = []
+            positions = []
+
+            # Randomly select a radius for each circle
+            radii = [random.randint(10, 30) for _ in range(max_obj)]
+
+            # Generate non-overlapping positions for the circles
+            while len(positions) < max_obj:
+                x = random.randint(max(radius for radius in radii), image_width - max(radius for radius in radii))
+                y = random.randint(max(radius for radius in radii), image_height - max(radius for radius in radii))
+
+                # Check if the new circle overlaps or touches any existing circles
+                overlap = False
+                for (px, py, r) in positions:
+                    distance = ((px - x) ** 2 + (py - y) ** 2) ** 0.5
+                    if distance < r + max(radii):
+                        overlap = True
+                        break
+                
+                if not overlap:
+                    radius = radii[len(positions)]
+                    positions.append((x, y, radius))
+                    colours1.append(colour_dict[random.randint(1, 3)])
+                    """colours2.append(colour_dict[random.randint(1, 3)])
+                    if(colours1[-1] != colours2[-1]):
+                        difference += 1"""
+                    
+            colours2 = colours1.copy()
+            indices = random.sample(range(0, max_obj), num_objects)
+            for index in indices:
+                if(colours2[index] == 'red'):
+                    colours2[index] = 'blue'
+                elif(colours2[index] == 'blue'):
+                    colours2[index] = 'green'
+                else:
+                    colours2[index] = 'red'
+
+            # Draw the circles
+            i=0
+            for (x, y, radius) in positions:
+                draw.ellipse([x - radius, y - radius, x + radius, y + radius], fill=colours1[i])
+                i=i+1
+
+            # Save the image with the filename `firsti.png`
+            image_filename = f"first{file}.png"
+            image_path = os.path.join(output_dir, image_filename)
+            image.save(image_path)
+
+            i=0
+            for (x, y, radius) in positions:
+                draw.ellipse([x - radius, y - radius, x + radius, y + radius], fill=colours2[i])
+                i=i+1
+            
+            #Save the image with the filename `secondi.png`
+            image_filename = f"second{file}.png"
+            file += 1
+            image_path = os.path.join(output_dir, image_filename)
+            image.save(image_path)
+
+
+
+            # Store the number of objects in the data dictionary
+            # data[image_filename] = {
+            #     "num_objects": num_objects
+            # }
+            gold_output = {
+                "id": image_filename,
+                "num_differences": num_objects
+            }
+            data.append(gold_output)
+
+            # print(f"Image saved at: {image_path}")
+
+    if append:
+        with open(os.path.join(os.getcwd() , "data.json"), "r") as f:
+            old_data = json.load(f)
+            old_data.extend(data)
+        with open(os.path.join(os.getcwd() , "data.json"), "w") as f:
+            json.dump(old_data, f, indent=2)
+    else:
+        with open(os.path.join(os.getcwd() , "data.json"), "w") as f:
+            json.dump(data, f, indent=2)
+
+if __name__ == "__main__":
+    # Parse command line arguments
+    parser = argparse.ArgumentParser(description='Create a grid of circles and triangles.')
+    parser.add_argument(
+        '--num_images', 
+        type=int, 
+        help='Number of images to generate',
+        default=1
+    )
+    parser.add_argument(
+        '--num_sizes', 
+        nargs='*', 
+        type=int,
+        help='List of count of circles',
+        default=[5]
+    )
+    parser.add_argument(
+        '--file', 
+        type=int, 
+        help='Starting file number',
+        default=1
+    )
+    args = parser.parse_args()
+    file = args.file
+    num_object_list = args.num_sizes
+    append = (file != 1)
+    create_images(args.num_images, num_object_list , file)

circle_boxes/script.py

@@ -0,0 +1,132 @@
+import matplotlib.pyplot as plt
+import PIL
+from PIL import Image
+import random
+import numpy as np
+import os
+import json
+import argparse
+
+def generate_shapes(num_images, num_objects_list , file):
+    # Set up the plot
+
+    output_dir = os.path.join(os.getcwd(), "data")
+    input_dir = os.path.join(os.getcwd(), "background_image")
+    if not os.path.exists(output_dir):
+        os.makedirs(output_dir)
+
+    data = []
+    append = (file != 1)
+
+    for n in num_objects_list:
+        max_objects = 2*n
+        for img_index in range(num_images):
+            width, height = 1500, 1000
+            fig, ax = plt.subplots()
+            ax.set_aspect('equal')
+            plt.axis('off')
+            #fig.set_figheight(height)
+            #fig.set_figwidth(width)
+            ax.set_xlim(-1500, 1500)
+            ax.set_ylim(-1000, 1000)
+
+            plt.axvline(x = 0, color = 'blue')
+            # Generate random positions for the shapes
+            left = random.randint(0, max_objects)
+            right = max_objects-left
+            positions_left, positions_right = [], []
+            radius = 30
+        
+            """shape = plt.Rectangle((-(width - radius), 50), 2850, 875, ec="blue", fill=False)
+            ax.add_patch(shape)
+            shape = plt.Rectangle((-(width - radius), -50), 2850, 875, ec="blue", fill=False)
+            ax.add_patch(shape)"""
+
+            for i in range(left):
+                while True:
+                    x, y = random.randint(-(width-radius), -radius), random.randint(-(height-radius), (height-radius))
+                    # Ensure shapes don't overlap
+                    if all(((x - px) ** 2 + (y - py) ** 2) ** 0.5 > 2 * radius for px, py in positions_left) and (abs(x) > radius and abs(y) > radius):
+                        positions_left.append((x, y))
+                        break
+
+            for i in range(right):
+                while True:
+                    x, y = random.randint(radius, (width-radius)), random.randint(-(height-radius), (height-radius))
+                    # Ensure shapes don't overlap
+                    if all(((x - px) ** 2 + (y - py) ** 2) ** 0.5 > 2 * radius for px, py in positions_right) and (abs(x) > radius and abs(y) > radius):
+                        positions_right.append((x, y))
+                        break
+
+            # Draw shapes and label them
+            """first, second, third, fourth = 0, 0, 0, 0
+            plt.axhline(0, color='black', linewidth=0.5)
+            plt.axvline(0, color='black', linewidth=0.5)"""
+
+            for i, (x, y) in enumerate(positions_left):
+                shape = plt.Circle((x, y), radius, color='red')
+                ax.add_patch(shape)
+                #ax.text(x, y, str(i + 1), color='white', ha='center', va='center', fontsize=8, weight='bold')
+
+            for i, (x, y) in enumerate(positions_right):
+                shape = plt.Circle((x, y), radius, color='red')
+                ax.add_patch(shape)
+
+            # Save the plot to a file
+            filename = f"{file}.png"
+            file += 1
+            filepath = os.path.join(output_dir, filename)
+            plt.savefig(filepath, bbox_inches='tight')
+            plt.close()
+
+            answer = max(left, right) - n
+
+            gold_output = {
+                "id": filename,
+                "answer": answer,
+                "num_objects": n
+            }
+            data.append(gold_output)
+
+
+    if append:
+        with open(os.path.join(os.getcwd() , "data.json"), "r") as f:
+            old_data = json.load(f)
+            old_data.extend(data)
+        with open(os.path.join(os.getcwd() , "data.json"), "w") as f:
+            json.dump(old_data, f, indent=2)
+    else:
+        with open(os.path.join(os.getcwd() , "data.json"), "w") as f:
+            json.dump(data, f, indent=2)
+
+
+
+# # Example usage
+# generate_shapes(10, 'shapes.png')
+if __name__ == "__main__":
+    # Parse command line arguments
+    parser = argparse.ArgumentParser(description='Create an image of different objects')
+    parser.add_argument(
+        '--num_images', 
+        type=int, 
+        help='Number of images to generate',
+        default=1
+    )
+    parser.add_argument(
+        '--num_sizes', 
+        nargs='*', 
+        type=int,
+        help='List of count of objects',
+        default=[5]
+    )
+    parser.add_argument(
+        '--file', 
+        type=int, 
+        help='Starting file number',
+        default=1
+    )
+    args = parser.parse_args()
+    file = args.file
+    num_object_list = args.num_sizes
+    append = (file != 1)
+    generate_shapes(args.num_images, num_object_list , file)

circle_location/script.py

@@ -0,0 +1,125 @@
+import matplotlib.pyplot as plt
+import PIL
+from PIL import Image
+import random
+import numpy as np
+import os
+import json
+import argparse
+
+def generate_shapes(num_images, num_objects_list , file):
+    # Set up the plot
+
+    output_dir = os.path.join(os.getcwd(), "data")
+    input_dir = os.path.join(os.getcwd(), "background_image")
+    if not os.path.exists(output_dir):
+        os.makedirs(output_dir)
+
+    data = []
+    append = (file != 1)
+
+    for n in num_objects_list:
+        for img_index in range(num_images):
+            #im = Image.open(os.path.join(input_dir, f"bg_{img_index+1}.png"))
+            fig, ax = plt.subplots()
+            #ax.imshow(im)
+            ax.set_aspect('equal')
+            plt.axis('off')
+
+            # Adjust plot limits to prevent cutoff
+            plt.xlim(-1500.0, 1500.0)
+            plt.ylim(-1000, 1000)
+
+            # Generate random positions for the shapes
+            positions = []
+            radius = 75
+            height, width = 1000, 1500
+        
+            for i in range(n):
+                while True:
+                    x, y = random.randint(-(width - radius), (width - radius)), random.randint(-(height - radius), (height-radius))
+                    # Ensure shapes don't overlap
+                    if all(((x - px) ** 2 + (y - py) ** 2) ** 0.5 > 2 * radius for px, py in positions) and (abs(x) > radius and abs(y) > radius):
+                        positions.append((x, y))
+                        break
+
+            # Draw shapes and label them
+            first, second, third, fourth = 0, 0, 0, 0
+            plt.axhline(0, color='black', linewidth=0.5)
+            plt.axvline(0, color='black', linewidth=0.5)
+
+            for i, (x, y) in enumerate(positions):
+                #color = random.choice(colours)
+                #shape_type = random.choice(shapes)
+                if x>0 and y>0:
+                    first += 1
+                elif x<0 and y>0:
+                    second += 1
+                elif x<0 and y<0:
+                    third += 1
+                else:
+                    fourth += 1
+
+                shape = plt.Circle((x, y), radius, color='black')
+                ax.add_patch(shape)
+                #ax.text(x, y, str(i + 1), color='white', ha='center', va='center', fontsize=8, weight='bold')
+
+            # Save the plot to a file
+            filename = f"{file}.png"
+            file += 1
+            filepath = os.path.join(output_dir, filename)
+            plt.savefig(filepath, bbox_inches='tight')
+            plt.close()
+            iterable = [first, second, third, fourth]
+            answer = max(enumerate(iterable), key=lambda x: x[1])[0] + 1
+
+            gold_output = {
+                "id": filename,
+                "quadrant": answer,
+                "count": iterable[answer-1],
+                "num_objects": n
+            }
+            data.append(gold_output)
+
+
+    if append:
+        with open(os.path.join(os.getcwd() , "data.json"), "r") as f:
+            old_data = json.load(f)
+            old_data.extend(data)
+        with open(os.path.join(os.getcwd() , "data.json"), "w") as f:
+            json.dump(old_data, f, indent=2)
+    else:
+        with open(os.path.join(os.getcwd() , "data.json"), "w") as f:
+            json.dump(data, f, indent=2)
+
+
+
+# # Example usage
+# generate_shapes(10, 'shapes.png')
+if __name__ == "__main__":
+    # Parse command line arguments
+    parser = argparse.ArgumentParser(description='Create an image of different objects')
+    parser.add_argument(
+        '--num_images', 
+        type=int, 
+        help='Number of images to generate',
+        default=1
+    )
+    parser.add_argument(
+        '--num_sizes', 
+        nargs='*', 
+        type=int,
+        help='List of count of objects',
+        default=[5]
+    )
+    parser.add_argument(
+        '--file', 
+        type=int, 
+        help='Starting file number',
+        default=1
+    )
+    args = parser.parse_args()
+    file = args.file
+    num_object_list = args.num_sizes
+    append = (file != 1)
+    generate_shapes(args.num_images, num_object_list , file)

circle_right_triangle/script.py

@@ -0,0 +1,190 @@
+import matplotlib.pyplot as plt
+import numpy as np
+import random
+import argparse
+import os
+import json
+
+def create_shape_grid(rows, cols, circles_count, triangles_count):
+    # Initialize the grid
+    #right = random.choice([True, False])
+    grid = np.empty((rows, cols), dtype=object)
+    
+    # Fill the grid with None
+    for i in range(rows):
+        for j in range(cols):
+            grid[i, j] = None
+    
+    
+    triangle_positions = []
+    
+    # Place triangles in the grid
+    for _ in range(triangles_count):
+        while True:
+            row, col = random.randint(0, rows - 1), random.randint(0, cols - 1)
+            if grid[row, col] is None:
+                grid[row, col] = 'triangle'
+                triangle_positions.append((row, col))
+                # shapes_placed += 1
+                break
+
+    """shapes_placed = 0
+    if right:
+        #place atleast one circle to right of triangle and rest randomly
+        placed_right = False
+        for row, col in triangle_positions:
+            if col < cols - 1 and grid[row, col + 1] is None:
+                placed_right = True
+                grid[row, col + 1] = 'circle'
+                shapes_placed += 1
+                break
+        
+        if not placed_right:
+            right = False
+            
+        while shapes_placed < circles_count:
+            row, col = random.randint(0, rows - 1), random.randint(0, cols - 1)
+            if grid[row, col] is None:
+                grid[row, col] = 'circle'
+                shapes_placed += 1
+
+    else:
+        #no circle should be placed to the right of triangle
+        while shapes_placed < circles_count:
+            row, col = random.randint(0, rows - 1), random.randint(0, cols - 1)
+            if col == 0 or grid[row, col - 1] != 'triangle':
+                if grid[row, col] is None:
+                    grid[row, col] = 'circle'
+                    shapes_placed += 1"""
+    
+    positions = []
+    for i in range(rows):
+        for j in range(cols):
+            positions.append((i, j))
+    
+    for pos in triangle_positions:
+        positions.remove(pos)
+    
+    circle_positions = random.sample(positions, circles_count)
+    for i, tup in enumerate(circle_positions):
+        row, col = tup[0], tup[1]
+        grid[row, col] = 'circle'
+
+    right = False
+    for i in range(rows):
+        for j in range(cols-1):
+            if grid[i, j] == 'triangle' and grid[i, j+1] == 'circle':
+                right = True
+                break
+
+    return grid , right
+
+def draw_grid(grid):
+    global file, output_dir
+    fig, ax = plt.subplots(figsize=(8, 8))
+    ax.set_xlim(0, grid.shape[1])
+    ax.set_ylim(0, grid.shape[0])
+    ax.set_xticks(np.arange(0, grid.shape[1] + 1))
+    ax.set_yticks(np.arange(0, grid.shape[0] + 1))
+    ax.grid(True)
+
+    # Create cell outlines
+    for i in range(grid.shape[0] + 1):
+        ax.axhline(i, color='black', lw=1)
+    for j in range(grid.shape[1] + 1):
+        ax.axvline(j, color='black', lw=1)
+
+    for (i, j), shape in np.ndenumerate(grid):
+        if shape == 'circle':
+            circle = plt.Circle((j + 0.5, grid.shape[0] - (i + 0.5)), 0.4, color='blue', ec='black')
+            ax.add_artist(circle)
+        elif shape == 'triangle':
+            triangle = plt.Polygon([[j + 0.5, grid.shape[0] - (i + 0.1)], 
+                                     [j + 0.1, grid.shape[0] - (i + 0.8)], 
+                                     [j + 0.9, grid.shape[0] - (i + 0.8)]], 
+                                    color='red', ec='black')
+            ax.add_artist(triangle)
+
+    ax.set_aspect('equal')
+    plt.title('Grid of Circles and Triangles')
+    
+    #1 Save the image if the output directory exists
+    image_filename = f"{file}.png"
+    file += 1
+    image_path = os.path.join(output_dir, image_filename)
+    
+    # Uncomment below if you want to save the figure
+    plt.savefig(image_path)
+    plt.close()
+    
+    # plt.show()
+
+# # Input for grid dimensions, number of circles, and triangles
+# num_rows = 5  # Number of rows
+# num_cols = 5 # Number of columns
+# num_circles = 3 # Number of circles
+# num_triangles = 3  # Number of triangles
+
+# grid = create_shape_grid(num_rows, num_cols, num_circles, num_triangles)
+# draw_grid(grid)
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description='Create a grid of circles and triangles.')
+    parser.add_argument(
+        '--num_images', 
+        type=int, 
+        help='Number of images to generate',
+        default=1
+    )
+    parser.add_argument(
+        '--num_sizes', 
+        nargs='*', 
+        help='List of n values (grid size , number of shapes) to generate', 
+        default=[3 , 1]
+    )
+    parser.add_argument(
+        '--grid_size', 
+        type=int, 
+        help='Grid size', 
+        default=6
+    )
+    parser.add_argument(
+        '--file', 
+        type=int, 
+        help='Starting file number',
+        default=1
+    )
+    args = parser.parse_args()
+    file = args.file
+    num_sizes = args.num_sizes
+    data = []
+    append = (file != 1)
+    output_dir = os.path.join(os.getcwd(), "data")
+    if not os.path.exists(output_dir):
+        os.makedirs(output_dir)
+
+    for j in range(0, len(num_sizes)):
+        for i in range(args.num_images):
+            rows, cols = args.grid_size, args.grid_size
+            circles = int(num_sizes[j])
+            triangles = min(int(num_sizes[j]), args.grid_size**2 - int(num_sizes[j]))
+            grid,right = create_shape_grid(rows, cols, circles, triangles)
+            # print(grid)
+            data.append({
+                'id': f"{file}.png",
+                'rows': rows,
+                'cols': cols,
+                'circles': circles,
+                'triangles': triangles,
+                'right': right
+            })
+            draw_grid(grid)
+    if append:
+        with open(os.path.join(os.getcwd() , "data.json"), "r") as f:
+            old_data = json.load(f)
+            old_data.extend(data)
+        with open(os.path.join(os.getcwd() , "data.json"), "w") as f:
+            json.dump(old_data, f, indent=2)
+    else:
+        with open(os.path.join(os.getcwd() , "data.json"), "w") as f:
+            json.dump(data, f, indent=2)

colours_present/script.py

@@ -0,0 +1,146 @@
+import matplotlib.pyplot as plt
+import cv2
+import PIL
+from PIL import Image
+import random
+import numpy as np
+import os
+import json
+import argparse
+
+def generate_shapes(num_images, num_objects_list , file):
+    # Set up the plot
+
+    output_dir = os.path.join(os.getcwd(), "data")
+    if not os.path.exists(output_dir):
+        os.makedirs(output_dir)
+
+    data = []
+    append = (file != 1)
+
+    for n in num_objects_list:
+        for img_index in range(num_images):
+            fig, ax = plt.subplots()
+            ax.set_aspect('equal')
+            plt.axis('off')
+
+            # Adjust plot limits to prevent cutoff
+            plt.xlim(-0.1, 1.1)
+            plt.ylim(-0.1, 1.1)
+
+            # Generate random positions for the shapes
+            positions = []
+            radius = 0.05
+            shapes = ['circle', 'triangle', 'rectangle', 'pentagon']
+            # Must be a list in the order given in prompts/rules.txt: gold_answer is built by
+            # iterating it. (A set here made the gold order depend on the process's hash seed.)
+            colours = ['black', 'gray', 'brown', 'maroon', 'red', 'coral', 'tan', 'orange', 'ivory', 'goldenrod', 'yellow', 'green', 'olive', 'turquoise', 'skyblue', 'blue', 'lavender', 'purple', 'pink', 'fuchsia']
+            colours_n = random.sample(colours, n)
+
+            gold_answer = []
+            for i in colours:
+                if i in colours_n:
+                    gold_answer.append('Yes')
+                else:
+                    gold_answer.append('No')
+
+            for i in range(n):
+                while True:
+                    x, y = random.uniform(0.1, 0.9), random.uniform(0.1, 0.9)
+                    # Ensure shapes don't overlap
+                    if all(((x - px) ** 2 + (y - py) ** 2) ** 0.5 > 2 * radius for px, py in positions):
+                        positions.append((x, y))
+                        break
+
+            # Choose one odd-colored shape
+            #odd_index = random.randint(0, n - 1)
+
+            # Draw shapes and label them
+            for i, (x, y) in enumerate(positions):
+                color = colours_n[i]
+                shape_type = random.choice(shapes)
+
+                if shape_type == 'circle':
+                    shape = plt.Circle((x, y), radius, ec='black', color=color)
+                elif shape_type == 'triangle':
+                    triangle = np.array([[x, y + radius], [x - radius, y - radius], [x + radius, y - radius]])
+                    shape = plt.Polygon(triangle, ec='black', color=color)
+                elif shape_type == 'rectangle':
+                    shape = plt.Rectangle((x - radius, y - radius), 2 * radius, 2 * radius, ec='black', color=color)
+                elif shape_type == 'pentagon':
+                    pentagon = np.array([
+                        [x, y + radius], [x + 0.95 * radius, y + 0.31 * radius],
+                        [x + 0.59 * radius, y - 0.81 * radius], [x - 0.59 * radius, y - 0.81 * radius],
+                        [x - 0.95 * radius, y + 0.31 * radius]
+                    ])
+                    shape = plt.Polygon(pentagon, ec='black', color=color)
+
+                ax.add_patch(shape)
+                #ax.text(x, y, str(i + 1), color='white', ha='center', va='center', fontsize=8, weight='bold')
+
+            # Save the plot to a file
+            filename = f"{file}.png"
+            filepath = os.path.join(output_dir, filename)
+            plt.savefig(filepath, bbox_inches='tight')
+            plt.close()
+
+            img1 = cv2.imread("data/"+f"{file}.png")
+            img2 = cv2.imread("swatches.png")
+            if img1.shape[1] != img2.shape[1]:
+                max_width = max(img1.shape[1], img2.shape[1])
+                img1 = cv2.resize(img1, (max_width, img1.shape[0]))
+                img2 = cv2.resize(img2, (max_width, img2.shape[0]))
+
+            merged_image = cv2.vconcat([img1, img2])
+            cv2.imwrite(filepath, merged_image)
+            file += 1
+
+            gold_output = {
+                "id": filename,
+                "colours_present": gold_answer,
+                "num_objects": n
+            }
+            data.append(gold_output)
+
+
+    if append:
+        with open(os.path.join(os.getcwd() , "data.json"), "r") as f:
+            old_data = json.load(f)
+            old_data.extend(data)
+        with open(os.path.join(os.getcwd() , "data.json"), "w") as f:
+            json.dump(old_data, f, indent=2)
+    else:
+        with open(os.path.join(os.getcwd() , "data.json"), "w") as f:
+            json.dump(data, f, indent=2)
+
+
+
+# # Example usage
+# generate_shapes(10, 'shapes.png')
+if __name__ == "__main__":
+    # Parse command line arguments
+    parser = argparse.ArgumentParser(description='Create an image of different objects')
+    parser.add_argument(
+        '--num_images', 
+        type=int, 
+        help='Number of images to generate',
+        default=1
+    )
+    parser.add_argument(
+        '--num_sizes', 
+        nargs='*', 
+        type=int,
+        help='List of count of objects',
+        default=[5]
+    )
+    parser.add_argument(
+        '--file', 
+        type=int, 
+        help='Starting file number',
+        default=1
+    )
+    args = parser.parse_args()
+    file = args.file
+    num_object_list = args.num_sizes
+    append = (file != 1)
+    generate_shapes(args.num_images, num_object_list , file)

comparing_size/script.py

@@ -0,0 +1,103 @@
+import matplotlib.pyplot as plt
+import random
+import os
+import json
+import argparse
+
+def create_images(num_images, num_objects_list , file):
+    # Ensure the output directory exists
+    output_dir = os.path.join(os.getcwd(), "data")
+    if not os.path.exists(output_dir):
+        os.makedirs(output_dir)
+
+    data = []
+    
+    append = (file != 1)
+    for num_objects in num_objects_list:
+        dpi = 100  # Dots per inch
+        width_inches = 1  # 100 pixels
+        height_inches = num_objects + 1  # 100 pixels per row
+        for img_index in range(num_images):
+            fig, ax = plt.subplots(figsize=(width_inches, height_inches), dpi=dpi)
+            image_data = []
+            for i in range (num_objects):
+                y = num_objects - i - 1 
+                while True:
+                    radius1 = random.uniform(0.05, 0.2)
+                    radius2 = random.uniform(0.05, 0.2)
+                    if abs(radius1 - radius2) >= 0.05:
+                        break
+
+                if radius1 > radius2:
+                    image_data.append("Blue")
+                else:
+                    image_data.append("Green")
+                # Ensure the circles do not overlap by adjusting positions
+                x1, x2 = 0.25, 0.75
+
+                # Add circles to the plot
+                circle1 = plt.Circle((x1, y), radius1, color='blue', fill=True)
+                circle2 = plt.Circle((x2, y), radius2, color='green', fill=True)
+                ax.add_patch(circle1)
+                ax.add_patch(circle2)
+
+                # if i < num_objects -1:
+                ax.plot([0, 1], [y - 0.5, y - 0.5], color='black')
+
+            ax.set_xlim(0, 1)
+            ax.set_ylim(-0.6, num_objects - 0.5)
+            ax.set_aspect('equal')
+            ax.axis('off')
+
+            image_filename = f"{file}.png"
+            file += 1
+            image_path = os.path.join(output_dir, image_filename)
+            plt.savefig(image_path, bbox_inches='tight', dpi=dpi)
+            plt.close(fig)
+            
+            
+
+            # Store the number of objects in the image_data dictionary
+            gold_output = {
+                "id": image_filename,
+                "Gold_output": image_data,
+                "Rows" : num_objects
+            }
+            data.append(gold_output)
+
+    if append:
+        with open(os.path.join(os.getcwd() , "data.json"), "r") as f:
+            old_data = json.load(f)
+            old_data.extend(data)
+        with open(os.path.join(os.getcwd() , "data.json"), "w") as f:
+            json.dump(old_data, f, indent=2)
+    else:
+        with open(os.path.join(os.getcwd() , "data.json"), "w") as f:
+            json.dump(data, f, indent=2)
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description='Create a grid of circles and triangles.')
+    parser.add_argument(
+        '--num_images', 
+        type=int, 
+        help='Number of images to generate',
+        default=1
+    )
+    parser.add_argument(
+        '--num_sizes', 
+        nargs='*', 
+        type=int,
+        help='List of number of rows',
+        default=[5]
+    )
+    parser.add_argument(
+        '--file', 
+        type=int, 
+        help='Starting file number',
+        default=1
+    )
+    args = parser.parse_args()
+    file = args.file
+    num_object_list = args.num_sizes
+    append = (file != 1)
+    create_images(args.num_images, num_object_list , file)

count_coloured_circles/script.py

@@ -0,0 +1,117 @@
+from PIL import Image, ImageDraw
+import random
+import os
+import json
+import argparse
+
+def create_images(num_images, num_objects_list , file):
+    # Ensure that the directory exists
+    # output_dir = "./data"
+    output_dir = os.path.join(os.getcwd(), "data")
+    if not os.path.exists(output_dir):
+        os.makedirs(output_dir)
+
+    data = []
+    image_width, image_height = 500, 300
+    append = (file != 1)
+    for num_objects in num_objects_list:
+        max_obj = 2*num_objects
+        for img_index in range(num_images):
+            # Create a blank white image
+            image = Image.new("RGB", (image_width, image_height), "white")
+            draw = ImageDraw.Draw(image)
+
+            # List to hold positions of circles
+            positions = []
+
+            # Randomly select a radius for each circle
+            radii = [random.randint(10, 20) for _ in range(max_obj)]
+
+            # Generate non-overlapping positions for the circles
+            while len(positions) < max_obj:
+                x = random.randint(max(radius for radius in radii), image_width - max(radius for radius in radii))
+                y = random.randint(max(radius for radius in radii), image_height - max(radius for radius in radii))
+
+                # Check if the new circle overlaps or touches any existing circles
+                overlap = False
+                for (px, py, r) in positions:
+                    distance = ((px - x) ** 2 + (py - y) ** 2) ** 0.5
+                    if distance < r + max(radii):
+                        overlap = True
+                        break
+
+                if not overlap:
+                    radius = radii[len(positions)]
+                    positions.append((x, y, radius))
+
+            # Draw the circles
+            red_circle = num_objects
+            indices = random.sample(range(0, max_obj), num_objects)
+            for i, (x, y, radius) in enumerate(positions):
+                color = ""
+                if i in indices:
+                    color = "red"
+                # draw.ellipse([x - radius, y - radius, x + radius, y + radius], fill="black")
+                #draw a random colored circle from red blue green yellow
+                else:
+                    colors = ["blue", "green", "yellow"]
+                    color = random.choice(colors)
+                draw.ellipse([x - radius, y - radius, x + radius, y + radius], fill=color)
+
+
+            # Save the image with the filename `i.png`
+            image_filename = f"{file}.png"
+            file += 1
+            image_path = os.path.join(output_dir, image_filename)
+            image.save(image_path)
+
+            # Store the number of objects in the data dictionary
+            # data[image_filename] = {
+            #     "num_objects": num_objects
+            # }
+            gold_output = {
+                "id": image_filename,
+                "num_objects": num_objects,
+                "red_circle": red_circle
+            }
+            data.append(gold_output)
+
+            # print(f"Image saved at: {image_path}")
+
+    if append:
+        with open(os.path.join(os.getcwd() , "data.json"), "r") as f:
+            old_data = json.load(f)
+            old_data.extend(data)
+        with open(os.path.join(os.getcwd() , "data.json"), "w") as f:
+            json.dump(old_data, f, indent=2)
+    else:
+        with open(os.path.join(os.getcwd() , "data.json"), "w") as f:
+            json.dump(data, f, indent=2)
+
+if __name__ == "__main__":
+    # Parse command line arguments
+    parser = argparse.ArgumentParser(description='Create a grid of circles and triangles.')
+    parser.add_argument(
+        '--num_images', 
+        type=int, 
+        help='Number of images to generate',
+        default=1
+    )
+    parser.add_argument(
+        '--num_sizes', 
+        nargs='*', 
+        type=int,
+        help='List of count of circles',
+        default=[5]
+    )
+    parser.add_argument(
+        '--file', 
+        type=int, 
+        help='Starting file number',
+        default=1
+    )
+    args = parser.parse_args()
+    file = args.file
+    num_object_list = args.num_sizes
+    append = (file != 1)
+    create_images(args.num_images, num_object_list , file)

counting_circles/script.py

@@ -0,0 +1,104 @@
+from PIL import Image, ImageDraw
+import random
+import os
+import json
+import argparse
+
+def create_images(num_images, num_objects_list , file):
+    # Ensure that the directory exists
+    # output_dir = "./data"
+    output_dir = os.path.join(os.getcwd(), "data")
+    if not os.path.exists(output_dir):
+        os.makedirs(output_dir)
+
+    data = []
+    image_width, image_height = 500, 300
+    append = (file != 1)
+    for num_objects in num_objects_list:
+        for img_index in range(num_images):
+            # Create a blank white image
+            image = Image.new("RGB", (image_width, image_height), "white")
+            draw = ImageDraw.Draw(image)
+
+            # List to hold positions of circles
+            positions = []
+
+            # Randomly select a radius for each circle
+            radii = [random.randint(10, 30) for _ in range(num_objects)]
+
+            # Generate non-overlapping positions for the circles
+            while len(positions) < num_objects:
+                x = random.randint(max(radius for radius in radii), image_width - max(radius for radius in radii))
+                y = random.randint(max(radius for radius in radii), image_height - max(radius for radius in radii))
+
+                # Check if the new circle overlaps or touches any existing circles
+                overlap = False
+                for (px, py, r) in positions:
+                    distance = ((px - x) ** 2 + (py - y) ** 2) ** 0.5
+                    if distance < r + max(radii):
+                        overlap = True
+                        break
+
+                if not overlap:
+                    radius = radii[len(positions)]
+                    positions.append((x, y, radius))
+
+            # Draw the circles
+            for (x, y, radius) in positions:
+                draw.ellipse([x - radius, y - radius, x + radius, y + radius], fill="black")
+
+            # Save the image with the filename `i.png`
+            image_filename = f"{file}.png"
+            file += 1
+            image_path = os.path.join(output_dir, image_filename)
+            image.save(image_path)
+
+            # Store the number of objects in the data dictionary
+            # data[image_filename] = {
+            #     "num_objects": num_objects
+            # }
+            gold_output = {
+                "id": image_filename,
+                "num_objects": num_objects
+            }
+            data.append(gold_output)
+
+            # print(f"Image saved at: {image_path}")
+
+    if append:
+        with open(os.path.join(os.getcwd() , "data.json"), "r") as f:
+            old_data = json.load(f)
+            old_data.extend(data)
+        with open(os.path.join(os.getcwd() , "data.json"), "w") as f:
+            json.dump(old_data, f, indent=2)
+    else:
+        with open(os.path.join(os.getcwd() , "data.json"), "w") as f:
+            json.dump(data, f, indent=2)
+
+if __name__ == "__main__":
+    # Parse command line arguments
+    parser = argparse.ArgumentParser(description='Create a grid of circles and triangles.')
+    parser.add_argument(
+        '--num_images', 
+        type=int, 
+        help='Number of images to generate',
+        default=1
+    )
+    parser.add_argument(
+        '--num_sizes', 
+        nargs='*', 
+        type=int,
+        help='List of count of circles',
+        default=[5]
+    )
+    parser.add_argument(
+        '--file', 
+        type=int, 
+        help='Starting file number',
+        default=1
+    )
+    args = parser.parse_args()
+    file = args.file
+    num_object_list = args.num_sizes
+    append = (file != 1)
+    create_images(args.num_images, num_object_list , file)

counting_locations/script.py

@@ -0,0 +1,124 @@
+import os
+import json
+from PIL import Image, ImageDraw
+import random
+import argparse
+
+# Function to draw an object
+def draw_object(draw, position, color):
+    x, y = position
+    size = 30
+    draw.ellipse([x, y, x + size, y + size], fill=color)
+
+def create_images(num_images, num_objects_list , file):
+    append = (file != 1)
+    data = []
+    for num_objects in num_objects_list:
+        print(f"Creating {num_images} images with {num_objects} objects...")
+        max_obj = 2*num_objects
+        for i in range(num_images):
+            # Image dimensions
+            width, height = 500, 300
+
+            # Create a blank image with a white background
+            image = Image.new("RGB", (width, height), "white")
+            draw = ImageDraw.Draw(image)
+
+            # Draw a simple table (a rectangle)
+            table_top_left = (10, 140)
+            table_bottom_right = (width-10, 160)
+            draw.rectangle([table_top_left, table_bottom_right], fill="brown")
+
+            # Randomly generate positions for objects
+            positions = []
+            num_over_table = 0
+            num_under_table = 0
+            for i in range(max_obj):
+                while True:
+                    # Randomly decide whether the object is over or under the table
+                    if i < num_objects:
+                        # Over the table (above the table's top edge)
+                        x = random.randint(10, width - 30)
+                        y = random.randint(0, table_top_left[1] - 40)
+                        if not any(abs(x - px) < 35 and abs(y - py) < 35 for px, py in positions):
+                            positions.append((x, y))
+                            num_over_table += 1
+                            break
+                        
+                    else:
+                        # Under the table (below the table's bottom edge)
+                        x = random.randint(10, width - 30)
+                        y = random.randint(table_bottom_right[1] + 10, height - 40)
+                        if not any(abs(x - px) < 35 and abs(y - py) < 35 for px, py in positions):
+                            positions.append((x, y))
+                            num_under_table += 1
+                            break
+               
+
+            # Draw the objects on the image
+            for pos in positions:
+                draw_object(draw, pos, color=random.choice(["red", "blue", "green", "yellow"]))
+
+            # Save the image with numerical naming in the ./data folder
+            image_filename = f"{file}.png"
+            file += 1
+            image_path = os.path.join(output_dir, image_filename)
+            image.save(image_path)
+
+            # Generate a random "gold output" for demonstration purposes
+            gold_output = {
+            "id": image_filename,
+            "num_objects_over_table": num_over_table,
+            "num_objects_under_table": num_under_table
+            # "object_positions": positions
+            }
+
+            # Add the filename and gold output to the data dictionary
+            data.append(gold_output)
+
+    if append:
+        with open(os.path.join(os.getcwd() , "data.json"), "r") as f:
+            old_data = json.load(f)
+            old_data.extend(data)
+        with open(os.path.join(os.getcwd() , "data.json"), "w") as f:
+            json.dump(old_data, f, indent=2)
+    else:
+        with open(os.path.join(os.getcwd() , "data.json"), "w") as f:
+            json.dump(data, f, indent=2)
+
+    print(f"Images saved in {output_dir} and data written to data.json.")
+
+
+if __name__ == "__main__":
+
+    parser = argparse.ArgumentParser(description='Create a grid of circles and triangles.')
+    parser.add_argument(
+        '--num_images', 
+        type=int, 
+        help='Number of images to generate',
+        default=1
+    )
+    parser.add_argument(
+        '--num_sizes', 
+        nargs='*', 
+        type=int,
+        help='List of n values',
+        default=[5 , 3]
+    )
+    parser.add_argument(
+        '--file', 
+        type=int, 
+        help='Starting file number',
+        default=1
+    )
+    args = parser.parse_args()
+    file = args.file
+    num_object_list = args.num_sizes
+    # print(num_object_list)
+    # Create images with the specified number of objects
+    # Directory to save images
+    output_dir = os.path.join(os.getcwd(), "data")
+    if not os.path.exists(output_dir):
+        os.makedirs(output_dir)
+
+    create_images(args.num_images, num_object_list , file)

counting_shapes/script.py

@@ -0,0 +1,131 @@
+from PIL import Image, ImageDraw
+import random
+import os
+import json
+import argparse
+
+num_circle = 0 
+num_triangle = 0
+num_square = 0
+
+def random_shape(draw, shape_type, x, y, size):
+    """
+    Draw a random shape on the provided image.
+    """
+    global num_circle, num_square, num_triangle, num_star
+    if shape_type == "circle":
+        draw.ellipse([x - size, y - size, x + size, y + size], fill="black")
+        num_circle +=1
+    elif shape_type == "square":
+        draw.rectangle([x - size, y - size, x + size, y + size], fill="black")
+        num_square +=1
+    elif shape_type == "triangle":
+        points = [
+            (x, y - size),  # Top
+            (x - size, y + size),  # Bottom left
+            (x + size, y + size),  # Bottom right
+        ]
+        draw.polygon(points, fill="black")
+        num_triangle +=1
+
+def create_images(num_images, num_objects_list , file):
+    # Ensure the output directory exists
+    global num_circle, num_square, num_triangle, num_star
+    output_dir = os.path.join(os.getcwd(), "data")
+    if not os.path.exists(output_dir):
+        os.makedirs(output_dir)
+
+    data = []
+    image_width, image_height = 500, 300
+    append = (file != 1)
+    for num_objects in num_objects_list:
+        for img_index in range(num_images):
+            # Create a blank white image
+            image = Image.new("RGB", (image_width, image_height), "white")
+            draw = ImageDraw.Draw(image)
+
+            # List to hold positions and sizes of shapes
+            shapes = []
+            num_circle =0 
+            num_triangle = 0
+            num_star = 0
+            num_square = 0
+
+
+            # Possible shape types
+            shape_types = ["circle", "square", "triangle"]
+
+            while len(shapes) < num_objects:
+                shape_type = random.choice(shape_types)
+                size = random.randint(10, 20)
+                x = random.randint(size+50, image_width - size - 50)
+                y = random.randint(size + 50, image_height - size - 50)
+
+                # Check if the new shape overlaps or touches any existing shapes
+                overlap = False
+                for (sx, sy, ssize,_) in shapes:
+                    distance = ((sx - x) ** 2 + (sy - y) ** 2) ** 0.5
+                    if distance < (ssize + size)*1.5:
+                        overlap = True
+                        break
+
+                if not overlap:
+                    shapes.append((x, y, size, shape_type))
+            # print(shapes)
+            # Draw the shapes
+            for (x, y, size, shape_type) in shapes:
+                random_shape(draw, shape_type, x, y, size)
+
+            # Save the image with the filename `i.png`
+            image_filename = f"{file}.png"
+            file += 1
+            image_path = os.path.join(output_dir, image_filename)
+            image.save(image_path)
+
+            # Store the number of objects in the data dictionary
+            gold_output = {
+                "id": image_filename,
+                "circles" : num_circle,
+                "squares" : num_square,
+                "triangles" : num_triangle
+            }
+            data.append(gold_output)
+
+    # Save the data to a JSON file
+    if append:
+        with open(os.path.join(os.getcwd() , "data.json"), "r") as f:
+            old_data = json.load(f)
+            old_data.extend(data)
+        with open(os.path.join(os.getcwd() , "data.json"), "w") as f:
+            json.dump(old_data, f, indent=2)
+    else:
+        with open(os.path.join(os.getcwd() , "data.json"), "w") as f:
+            json.dump(data, f, indent=2)
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description='Create a grid of circles and triangles.')
+    parser.add_argument(
+        '--num_images', 
+        type=int, 
+        help='Number of images to generate',
+        default=1
+    )
+    parser.add_argument(
+        '--num_sizes', 
+        nargs='*', 
+        type=int,
+        help='List of num shapes',
+        default=[5]
+    )
+    parser.add_argument(
+        '--file', 
+        type=int, 
+        help='Starting file number',
+        default=1
+    )
+    args = parser.parse_args()
+    file = args.file
+    num_object_list = args.num_sizes
+    # print(num_object_list)
+    # Create images with the specified number of objects
+    create_images(args.num_images, num_object_list , file)

cross_and_knots/script.py

@@ -0,0 +1,155 @@
+import numpy as np
+import matplotlib.pyplot as plt
+import random
+import os
+import json
+import argparse
+
+
+def create_grid_with_crosses(n, k , output_dir):
+    # Create a figure and axis
+    global file
+    
+    fig, ax = plt.subplots()
+
+    # Set the limits of the grid
+    ax.set_xlim(0, n)
+    ax.set_ylim(0, n)
+
+    # Disable axis labels and ticks
+    ax.set_xticks(np.arange(0, n+1, 1))
+    ax.set_yticks(np.arange(0, n+1, 1))
+    ax.grid(True)
+    ax.tick_params(left=False, bottom=False, labelleft=False, labelbottom=False)
+
+    # Randomly select k unique cells for crosses
+    if (k < n*n):
+        crosses = set()
+        while len(crosses) < k:
+            cross_position = (random.randint(0, n-1), random.randint(0, n-1))
+            crosses.add(cross_position)
+
+        # Store cross positions in a list
+        cross_list = list(crosses)
+    else:
+        cross_list = []
+        crosses = set()
+        for i in range(n):
+            for j in range(n):
+                cross_list.append((i,j))
+                crosses.add((i,j))
+        
+
+    # Label the cells (i,j) that don't have crosses
+    for i in range(n):
+        for j in range(n):
+            if (i, j) not in crosses:
+                label = f"({i},{j})"
+                ax.text(j + 0.5, n - i - 0.5, label, va='center', ha='center', fontsize=8, color='blue')
+            else:
+                ax.text(j + 0.5, n - i - 0.5, 'X', va='center', ha='center', fontsize=25, color='black')
+
+    # Draw grid lines
+    ax.set_xticks(np.arange(0, n+1, 1), minor=False)
+    ax.set_yticks(np.arange(0, n+1, 1), minor=False)
+    plt.grid(True)
+
+    # Show the plot
+    plt.gca().set_aspect('equal', adjustable='box')
+    # plt.show()
+    image_filename = f"{file}.png"
+    file += 1
+    image_path = os.path.join(output_dir, image_filename)
+    plt.savefig(image_path)
+    plt.close()
+
+    return cross_list
+
+
+def is_safe_from_cross(crosses, i, j, n):
+    """Checks if all non-diagonal adjacent cells of (i, j) do not contain crosses."""
+    # Define directions for non-diagonal moves (up, down, left, right)
+    directions = [(-1, 0), (1, 0), (0, -1), (0, 1) , (0,0)]
+    
+    for di, dj in directions:
+        ni, nj = i + di, j + dj
+        # Check if the adjacent cell is within bounds and contains a cross
+        if 0 <= ni < n and 0 <= nj < n:
+            if (ni, nj) in crosses:
+                return False
+    return True
+
+if __name__ == "__main__":
+
+    parser = argparse.ArgumentParser(description="Generate data for cross and knots")
+    parser.add_argument(
+        '--num_images', 
+        type=int, 
+        help='Number of images to generate',
+        default=1
+    )
+    parser.add_argument(
+        '--num_sizes', 
+        nargs='*', 
+        help='List of n values (grid size , number of crosses) to generate',
+        default=[3 , 1]
+    )
+    parser.add_argument(
+        '--grid_size', 
+        type=int, 
+        help='Grid size', 
+        default=6
+    )
+    parser.add_argument(
+        '--file', 
+        type=int, 
+        help='Output directory',
+        default=1
+    )
+    args = parser.parse_args()
+    num_images = args.num_images
+    num_sizes = args.num_sizes
+    file = args.file    
+    append = (file != 1)
+    # num_images = int(sys.argv[1])
+    # num_sizes = sys.argv[2:]
+    # # print(num_images)
+    # file = 1
+    data  = []
+    output_dir = os.path.join(os.getcwd(), "data")
+    if not os.path.exists(output_dir):
+        os.makedirs(output_dir)
+
+    for j in range(0, len(num_sizes)):
+        for i in range(num_images):
+            n = args.grid_size
+            crosses = int(num_sizes[j])
+            # print(n,k)
+            cross_positions = create_grid_with_crosses(args.grid_size, crosses , output_dir)
+
+            safe_cells = []
+            for k in range(n):
+                for l in range(n):
+                    if is_safe_from_cross(set(cross_positions), k, l, n):
+                        safe_cells.append((k, l))
+
+            data.append({
+                "id" : f"{file-1}.png",
+                "n" : args.grid_size,    
+                "crosses" : crosses,
+                "cross_positions" : cross_positions,
+                "gold_output" : safe_cells
+            })
+            # Print the list of cross positions
+            # print("Cross positions:", cross_positions)
+    if append:
+        with open(os.path.join(os.getcwd() , "data.json"), "r") as f:
+            old_data = json.load(f)
+            old_data.extend(data)
+        with open(os.path.join(os.getcwd() , "data.json"), "w") as f:
+            json.dump(old_data, f, indent=2)
+    else:
+        with open(os.path.join(os.getcwd() , "data.json"), "w") as f:
+            json.dump(data, f, indent=2)
+
+

graph_counting/script.py

@@ -0,0 +1,101 @@
+import networkx as nx
+import matplotlib.pyplot as plt
+import random
+import argparse
+import os
+import json
+
+
+def generate_graph(num_nodes, num_edges):
+    # Create an empty graph
+    G = nx.Graph()
+    
+    # Add nodes to the graph
+    G.add_nodes_from(range(num_nodes))
+    
+    # Add edges to the graph
+    possible_edges = [(i, j) for i in range(num_nodes) for j in range(i+1, num_nodes)]
+    random_edges = random.sample(possible_edges, num_edges)
+    G.add_edges_from(random_edges)
+    
+    return G
+
+def draw_graph(G, idx):
+
+    global file
+    # Draw the graph
+    plt.figure(figsize=(12, 12))
+    pos = nx.spring_layout(G)  # Layout for visualization
+    nx.draw(G, pos, with_labels=False, node_color='lightblue', edge_color='gray', node_size=2000, font_size=15)
+    image_filename = f"{file}.png"
+    file += 1
+    image_path = os.path.join(output_dir, image_filename)
+    plt.savefig(image_path)
+    plt.close()
+
+# Parameters: number of nodes and number of edges
+
+
+# num_nodes = 10
+
+# # Generate and draw the graph
+# for i in range(1, 11):
+#     num_edges = random.randint(10, 15)
+#     G = generate_graph(num_nodes, num_edges)
+#     draw_graph(G, idx=i)
+
+if __name__ == '__main__':
+    output_dir = os.path.join(os.getcwd(), "data")
+    if not os.path.exists(output_dir):
+        os.makedirs(output_dir)
+    
+    parser = argparse.ArgumentParser(description='Create a grid of circles and triangles.')
+    parser.add_argument(
+        '--num_images', 
+        type=int, 
+        help='Number of images to generate',
+        default=1
+    )
+    parser.add_argument(
+        '--num_sizes', 
+        nargs='*', 
+        type = int,
+        help='List of num of nodes',
+        default=[5]
+    )
+    parser.add_argument(
+        '--file', 
+        type=int, 
+        help='Starting file number',
+        default=1
+    )
+    args = parser.parse_args()
+    file = args.file
+    num_nodes = args.num_sizes
+    num_images = args.num_images
+    append = (file != 1)
+    data = []
+    
+    for num_node in num_nodes:
+        for i in range(num_images):
+            if num_node == 1:
+                num_edges = 0
+            else:
+                min_edge = min((num_node*(num_node-1))//2, (num_node+5))
+                num_edges = random.randint(num_node-1, min_edge)
+            G = generate_graph(num_node, num_edges)
+            draw_graph(G, idx=i)
+            data.append({
+                "id": f"{file-1}.png",
+                "num_nodes": num_node,
+                "num_edges": num_edges
+            })
+    if append:
+        with open(os.path.join(os.getcwd() , "data.json"), "r") as f:
+            old_data = json.load(f)
+            old_data.extend(data)
+        with open(os.path.join(os.getcwd() , "data.json"), "w") as f:
+            json.dump(old_data, f, indent=2)
+    else:
+        with open(os.path.join(os.getcwd() , "data.json"), "w") as f:
+            json.dump(data, f, indent=2)

grid_path/script.py

@@ -0,0 +1,155 @@
+from PIL import Image, ImageDraw, ImageFont
+import random
+import argparse
+import os
+import json
+
+def create_grid_image(n, m, image_size=800):
+    global file, output_dir
+    # Create a new image with white background
+    img = Image.new('RGB', (image_size, image_size), 'white')
+    draw = ImageDraw.Draw(img)
+
+    image_list = []
+    grid = []
+
+    # Calculate cell size based on grid size
+    cell_size = image_size // n
+    border_color = 'black'
+    shape_colors = ['red', 'green', 'blue', 'purple']
+    # shape_colors = ['red']
+
+    # Load a default font with a larger size for better visibility
+    font_size = cell_size // 2
+    font = ImageFont.truetype("arial.ttf", font_size)
+
+    # Draw grid borders
+    for i in range(n + 1):
+        draw.line([(i * cell_size, 0), (i * cell_size, image_size)], fill=border_color, width=2)
+        draw.line([(0, i * cell_size), (image_size, i * cell_size)], fill=border_color, width=2)
+
+    # Add shapes inside each cell
+    for i in range(n):
+        row = []
+        for j in range(n):
+            shape_type = random.choice(['circle', 'square', 'triangle'])
+            shape_color = random.choice(shape_colors)
+            top_left = (j * cell_size + 5, i * cell_size + 5)
+            bottom_right = ((j + 1) * cell_size - 5, (i + 1) * cell_size - 5)
+
+            if shape_type == 'circle':
+                draw.ellipse([top_left, bottom_right], fill=shape_color)
+                row.append('circle')
+            elif shape_type == 'square':
+                draw.rectangle([top_left, bottom_right], fill=shape_color)
+                row.append('square')
+            elif shape_type == 'triangle':
+                mid_x = (top_left[0] + bottom_right[0]) / 2
+                draw.polygon([top_left, (bottom_right[0], top_left[1]), (mid_x, bottom_right[1])], fill=shape_color)
+                row.append('triangle')
+        grid.append(row)
+    # print(grid)
+    # Generate a random path of length m
+    path = [(random.randint(0, n - 1), random.randint(0, n - 1))]
+    while len(path) < m:
+        last_x, last_y = path[-1]
+        possible_moves = [(last_x + dx, last_y + dy) for dx, dy in [(0, 1), (1, 0), (0, -1), (-1, 0)]]
+        valid_moves = [(x, y) for x, y in possible_moves if 0 <= x < n and 0 <= y < n and (x, y) not in path]
+        if valid_moves:
+            path.append(random.choice(valid_moves))
+        else:
+            break  # No more moves possible
+
+    # Draw the path with arrows and mark the start and end cells
+    arrow_dict = {(1, 0): '→', (0, 1): '↓', (-1, 0): '←', (0, -1): '↑'}
+    # print(path)
+    for index in range(len(path) - 1):
+        x1, y1 = path[index]
+        x2, y2 = path[index + 1]
+        start = (x1 * cell_size + cell_size // 2, y1 * cell_size + cell_size // 2)
+        end = (x2 * cell_size + cell_size // 2, y2 * cell_size + cell_size // 2)
+        draw.line([start, end], fill='black', width=4)
+        # print(x1 , y1)
+        image_list.append(grid[y1][x1])
+        # Draw arrow in the middle of the line
+        dx, dy = x2 - x1, y2 - y1
+        if (dx, dy) in arrow_dict:
+            arrow = arrow_dict[(dx, dy)]
+            arrow_position = ((start[0] + end[0]) // 2, (start[1] + end[1]) // 2 - cell_size*0.045)
+            # print(arrow_position , start , end)
+            draw.text(arrow_position, arrow, fill='black', font=font, anchor="mm")
+    
+    # Label the start and end cells with larger and bolder text
+    start_x, start_y = path[0]
+    end_x, end_y = path[-1]
+    draw.text((start_x * cell_size + cell_size // 2, start_y * cell_size + cell_size // 2), 'S', fill='black', font=font, anchor="mm")
+    draw.text((end_x * cell_size + cell_size // 2, end_y * cell_size + cell_size // 2), 'E', fill='black', font=font, anchor="mm")
+
+    image_list.append(grid[end_y][end_x])
+    # Save the image
+    # img.save('grid_image_with_path.png')
+    image_filename = f"{file}.png"
+    file += 1
+    image_path = os.path.join(output_dir, image_filename)
+    img.save(image_path)
+
+    return image_list 
+    
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description='Create a grid of circles and triangles.')
+    parser.add_argument(
+        '--num_images', 
+        type=int, 
+        help='Number of images to generate',
+        default=1
+    )
+    parser.add_argument(
+        '--num_sizes', 
+        nargs='*', 
+        help='List of n values',
+        default=[5 , 3]
+    )
+    parser.add_argument(
+        '--grid_size', 
+        type=int, 
+        help='Grid size', 
+        default=6
+    )
+    parser.add_argument(
+        '--file', 
+        type=int, 
+        help='Starting file number',
+        default=1
+    )
+    args = parser.parse_args()
+    file = args.file
+    num_sizes = args.num_sizes
+    append = (file != 1)
+    data = []
+    output_dir = os.path.join(os.getcwd(), "data")
+    if not os.path.exists(output_dir):
+        os.makedirs(output_dir)
+
+    for j in range(0, len(num_sizes)):
+        for i in range(args.num_images):
+            rows = args.grid_size
+            path_size = int(num_sizes[j])
+            image_list = create_grid_image(rows, path_size)
+            # print(grid)
+            data.append({
+                'id': f"{file-1}.png",
+                'rows': rows,
+                'path_size': path_size,
+                'gold_output': image_list
+            })
+
+    if append:
+        with open(os.path.join(os.getcwd() , "data.json"), "r") as f:
+            old_data = json.load(f)
+            old_data.extend(data)
+        with open(os.path.join(os.getcwd() , "data.json"), "w") as f:
+            json.dump(old_data, f, indent=2)
+    else:
+        with open(os.path.join(os.getcwd() , "data.json"), "w") as f:
+            json.dump(data, f, indent=2)

identifying_shapes/script.py

@@ -0,0 +1,108 @@
+import matplotlib.pyplot as plt
+import matplotlib.patches as mp
+import random
+import os
+import json
+import sys
+import argparse
+
+
+def create_images(num_images, num_objects_list, items_list):
+    # Ensure the output directory exists
+    output_dir = os.path.join(os.getcwd(), "data")
+    if not os.path.exists(output_dir):
+        os.makedirs(output_dir)
+
+    data = []
+    
+    file = 1
+    for num_objects in num_objects_list:
+        dpi = 100  # Dots per inch
+        width_inches = 1  # 100 pixels
+        height_inches = num_objects  # 100 pixels per row
+        for img_index in range(num_images):
+            fig, ax = plt.subplots(figsize=(width_inches, height_inches), dpi=dpi)
+            image_data = []
+            image_side = []
+            for i in range (num_objects):
+                shape, sides = random.choice(list(items_list.items()))
+                y = num_objects - i - 1 
+                image_data.append(shape)
+                image_side.append(sides)
+                # Ensure the circles do not overlap by adjusting positions
+                # Add circles to the plot
+                if(shape == 'Circle'):
+                    circle = mp.Circle((0.5, y), 0.3, color='blue', fill=True)
+                    ax.add_patch(circle)
+                if(shape == 'Diamond'):
+                    sq = mp.RegularPolygon((0.5, y), numVertices=4, radius=0.3, facecolor='green')
+                    ax.add_patch(sq)
+                if(shape == 'Triangle'):
+                    tri = mp.RegularPolygon((0.5, y), numVertices=3, radius=0.3, facecolor='red')
+                    ax.add_patch(tri)
+                if(shape == 'Pentagon'):
+                    pent = mp.RegularPolygon((0.5, y), numVertices=5, radius=0.3, facecolor='cyan')
+                    ax.add_patch(pent)
+                if(shape == 'Hexagon'):
+                    hex = mp.RegularPolygon((0.5, y), numVertices=6, radius=0.3, facecolor='magenta')
+                    ax.add_patch(hex)
+
+                if i < num_objects -1:
+                    ax.plot([0, 1], [y - 0.5, y - 0.5], color='black')
+
+            ax.set_xlim(0, 1)
+            ax.set_ylim(-0.5, num_objects - 0.5)
+            ax.set_aspect('equal')
+            ax.axis('off')
+
+            image_filename = f"{file}.png"
+            file += 1
+            image_path = os.path.join(output_dir, image_filename)
+            plt.savefig(image_path, bbox_inches='tight', dpi=dpi)
+            plt.close(fig)
+            
+            
+
+            # Store the number of objects in the image_data dictionary
+            gold_output = {
+                "id": image_filename,
+                "Gold_output": image_data,
+                "Gold_side": image_side,
+                "Rows" : num_objects
+            }
+            data.append(gold_output)
+
+    # Save the data to a JSON file
+    with open(os.path.join(os.getcwd() , "data.json"), "w") as json_file:
+        json.dump(data, json_file, indent=4)
+
+if __name__ == "__main__":
+    # Parse command line arguments
+    parser = argparse.ArgumentParser(description='Create a grid of circles and triangles.')
+    parser.add_argument(
+        '--num_images', 
+        type=int, 
+        help='Number of images to generate',
+        default=1
+    )
+    parser.add_argument(
+        '--num_sizes', 
+        nargs='*', 
+        type=int,
+        help='List of count of circles',
+        default=[5]
+    )
+    parser.add_argument(
+        '--file', 
+        type=int, 
+        help='Starting file number',
+        default=1
+    )
+    args = parser.parse_args()
+    file = args.file
+    num_object_list = args.num_sizes
+    append = (file != 1)
+    items_list = {'Circle':0, 'Triangle':3, 'Diamond':4, 'Pentagon':5, 'Hexagon':6}
+    create_images(args.num_images, num_object_list, items_list)
+    # print(num_object_list)
+    # Create images with the specified number of objects

inside_circles/script.py

@@ -0,0 +1,111 @@
+import matplotlib.pyplot as plt
+import PIL
+from PIL import Image
+import random
+import numpy as np
+import os
+import json
+import argparse
+
+def generate_shapes(num_images, num_objects_list , file):
+    # Set up the plot
+
+    output_dir = os.path.join(os.getcwd(), "data")
+    input_dir = os.path.join(os.getcwd(), "background_image")
+    if not os.path.exists(output_dir):
+        os.makedirs(output_dir)
+
+    data = []
+    append = (file != 1)
+
+    for n in num_objects_list:
+        for img_index in range(num_images):
+            fig, ax = plt.subplots()
+            ax.set_aspect('equal')
+            plt.axis('off')
+
+            # Adjust plot limits to prevent cutoff
+            plt.xlim(-0.7, 1.4)
+            plt.ylim(-0.7, 1.4)
+
+            # Generate random positions for the shapes
+            positions = []
+            radii = []
+            gold_answer = 0
+            for i in range(n):
+                x, y = random.uniform(0.1, 0.9), random.uniform(0.1, 0.9)
+                positions.append((x, y))
+                radius = random.uniform(0.1, 0.5)
+                radii.append(radius)
+
+            # Draw shapes and label them
+            cx, cy = random.uniform(0.1, 0.9), random.uniform(0.1, 0.9)
+            ax.add_patch(plt.Circle((cx, cy), 0.05, color='red'))
+            for i, (x, y) in enumerate(positions):
+                shape = plt.Circle((x, y), radii[i], color='black', fill=False)
+                ax.add_patch(shape)
+                
+                if ((cx - x)**2 + (cy - y)**2)**0.5 < radii[i]:
+                    gold_answer += 1
+
+            # Save the plot to a file
+            filename = f"{file}.png"
+            file += 1
+            filepath = os.path.join(output_dir, filename)
+            plt.savefig(filepath, bbox_inches='tight')
+            plt.close()
+            answer = False
+            if gold_answer == 0:
+                answer = False
+            else:
+                answer = True
+
+            gold_output = {
+                "id": filename,
+                "inside_circles": answer,
+                "num_circles": n
+            }
+            data.append(gold_output)
+
+
+    if append:
+        with open(os.path.join(os.getcwd() , "data.json"), "r") as f:
+            old_data = json.load(f)
+            old_data.extend(data)
+        with open(os.path.join(os.getcwd() , "data.json"), "w") as f:
+            json.dump(old_data, f, indent=2)
+    else:
+        with open(os.path.join(os.getcwd() , "data.json"), "w") as f:
+            json.dump(data, f, indent=2)
+
+
+
+# # Example usage
+# generate_shapes(10, 'shapes.png')
+if __name__ == "__main__":
+    # Parse command line arguments
+    parser = argparse.ArgumentParser(description='Create an image of different objects')
+    parser.add_argument(
+        '--num_images', 
+        type=int, 
+        help='Number of images to generate',
+        default=1
+    )
+    parser.add_argument(
+        '--num_sizes', 
+        nargs='*', 
+        type=int,
+        help='List of count of objects',
+        default=[5]
+    )
+    parser.add_argument(
+        '--file', 
+        type=int, 
+        help='Starting file number',
+        default=1
+    )
+    args = parser.parse_args()
+    file = args.file
+    num_object_list = args.num_sizes
+    append = (file != 1)
+    generate_shapes(args.num_images, num_object_list , file)

layered_colours/script.py

@@ -0,0 +1,110 @@
+import matplotlib.pyplot as plt
+from itertools import combinations
+import cv2
+import random
+import os
+import json
+import argparse
+import numpy as np
+
+
+
+def generate_depth_images(num_images , num_object_list , file , image_size=(500, 500)):
+    output_dir = os.path.join(os.getcwd(), "data")
+    if not os.path.exists(output_dir):
+        os.makedirs(output_dir)
+
+    data = []
+    append = (file != 1)
+
+    for n in num_object_list:
+        for _ in range(num_images):  
+            colors = {'black', 'gray', 'brown', 'maroon', 'red', 'coral', 'tan', 'orange', 'ivory', 'goldenrod', 'yellow', 'green', 'olive', 'turquoise', 'skyblue', 'blue', 'lavender', 'purple', 'pink', 'fuchsia'}
+            colors_n = random.choice(list(combinations(colors, n)))
+            #print(colors_n)
+            random.shuffle(list(colors_n))
+            
+            fig, ax = plt.subplots()
+            ax.set_aspect('equal')
+            plt.axis('off')
+
+            # Adjust plot limits to prevent cutoff
+            plt.xlim(-1.0, 1.0)
+            plt.ylim(-1.0, 1.0)
+
+            # Generate random positions for the shapes
+            radii = np.linspace(0.9, 0.05, n)
+
+            # Draw shapes and label them
+            cx, cy = 0.0, 0.0
+            for i in range(n):
+                shape = plt.Circle((cx, cy), radii[i], color=colors_n[i], ec='black', fill=True)
+                ax.add_patch(shape)
+
+            # Save the plot to a file
+            filename = f"{file}.png"
+            filepath = os.path.join(output_dir, filename)
+            plt.savefig(filepath, bbox_inches='tight')
+            plt.close()
+
+            img1 = cv2.imread("data/"+f"{file}.png")
+            img2 = cv2.imread("swatches.png")
+            if img1.shape[1] != img2.shape[1]:
+                max_width = max(img1.shape[1], img2.shape[1])
+                img1 = cv2.resize(img1, (max_width, img1.shape[0]))
+                img2 = cv2.resize(img2, (max_width, img2.shape[0]))
+
+            merged_image = cv2.vconcat([img1, img2])
+            cv2.imwrite(filepath, merged_image)
+            file += 1
+
+            gold_output = {
+                "id": filename,
+                "num_layers" : n,
+                "colors": colors_n[::-1],    
+            }
+            data.append(gold_output)
+
+    if append:
+        with open(os.path.join(os.getcwd() , "data.json"), "r") as f:
+            old_data = json.load(f)
+            old_data.extend(data)
+        with open(os.path.join(os.getcwd() , "data.json"), "w") as f:
+            json.dump(old_data, f, indent=2)
+    else:
+        with open(os.path.join(os.getcwd() , "data.json"), "w") as f:
+            json.dump(data, f, indent=2)
+            
+
+# # Generate and display an example image
+# n_shapes = 3
+# image = generate_depth_images(n_shapes)
+# image.show()
+
+if __name__ == "__main__":
+    # Parse command line arguments
+    parser = argparse.ArgumentParser(description='Create a grid of circles and triangles.')
+    parser.add_argument(
+        '--num_images', 
+        type=int, 
+        help='Number of images to generate',
+        default=1
+    )
+    parser.add_argument(
+        '--num_sizes', 
+        nargs='*', 
+        type=int,
+        help='List of count of layers',
+        default=[5]
+    )
+    parser.add_argument(
+        '--file', 
+        type=int, 
+        help='Starting file number',
+        default=1
+    )
+    args = parser.parse_args()
+    file = args.file
+    num_object_list = args.num_sizes
+    append = (file != 1)
+    generate_depth_images(args.num_images, num_object_list , file)

layered_shapes/script.py

@@ -0,0 +1,131 @@
+from PIL import Image, ImageDraw
+import random
+import os
+import json
+import argparse
+import math
+
+
+
+def generate_depth_images(num_images , num_object_list , file , image_size=(1800, 1800)):
+    output_dir = os.path.join(os.getcwd(), "data")
+    if not os.path.exists(output_dir):
+        os.makedirs(output_dir)
+
+    data = []
+    append = (file != 1)
+
+    for n in num_object_list:
+        for _ in range(num_images):  
+            canvas = Image.new("RGB", image_size, (255, 255, 255))
+            draw = ImageDraw.Draw(canvas)
+            def color_distance(c1, c2):
+                return sum((a - b) ** 2 for a, b in zip(c1, c2))
+            
+            def generate_distinct_colors(n, min_diff=500):
+                colors = []
+                while len(colors) < n:
+                    new_color = (random.randint(50, 205), random.randint(50, 205), random.randint(50, 205))
+                    if all(color_distance(new_color, c) > min_diff for c in colors):
+                        colors.append(new_color)
+                return colors
+            
+            colors = generate_distinct_colors(n)
+            # colors = [(random.randint(50, 255), random.randint(50, 255), random.randint(50, 255)) for _ in range(n)]
+            #shapes = [ 'triangle' , 'square' , 'pentagon', 'hexagon']
+            shapes = ['diamond', 'hexagon', 'octagon']
+            
+            center_x, center_y = image_size[0] // 2, image_size[1] // 2  # Keep all shapes centered
+            
+            def draw_polygon(sides, radius, center, color):
+                angle = 360 / sides
+                points = [
+                    (
+                        center[0] + radius * math.cos(math.radians(i * angle)),
+                        center[1] + radius * math.sin(math.radians(i * angle))
+                    )
+                    for i in range(sides)
+                ]
+                draw.polygon(points, outline='black', fill=color)
+
+            order = []
+            prev_size = 800
+            for i in reversed(range(n)):  # Draw from back to front
+
+                size = prev_size
+                shape_type = random.choice(shapes)
+                order.append(shape_type)
+
+                if shape_type == 'diamond':
+                    draw_polygon(4 , size, (center_x, center_y), colors[i])
+                    prev_size = size*math.cos(math.radians(45))
+                elif shape_type == 'circle':
+                    draw_polygon(360, (size-((i/n)*200)), (center_x, center_y), colors[i])
+                    prev_size = size
+                elif shape_type == 'octagon':
+                    draw_polygon(8, size, (center_x, center_y), colors[i])
+                    prev_size = size*math.cos(math.radians(22.5))
+                elif shape_type == 'hexagon':
+                    draw_polygon(6, size, (center_x, center_y), colors[i])
+                    prev_size = size*math.cos(math.radians(30))
+                
+                #prev_size -= (200/n)
+
+
+            image_filename = f"{file}.png"
+            file += 1
+            image_path = os.path.join(output_dir, image_filename)
+            canvas.save(image_path)
+
+            reversed_order = order[::-1]
+
+            gold_output = {
+                "id": image_filename,
+                "num_layers" : n,
+                "order": reversed_order,    
+            }
+            data.append(gold_output)
+
+    if append:
+        with open(os.path.join(os.getcwd() , "data.json"), "r") as f:
+            old_data = json.load(f)
+            old_data.extend(data)
+        with open(os.path.join(os.getcwd() , "data.json"), "w") as f:
+            json.dump(old_data, f, indent=2)
+    else:
+        with open(os.path.join(os.getcwd() , "data.json"), "w") as f:
+            json.dump(data, f, indent=2)
+            
+
+# # Generate and display an example image
+# n_shapes = 3
+# image = generate_depth_images(n_shapes)
+# image.show()
+
+if __name__ == "__main__":
+    # Parse command line arguments
+    parser = argparse.ArgumentParser(description='Create a grid of circles and triangles.')
+    parser.add_argument(
+        '--num_images', 
+        type=int, 
+        help='Number of images to generate',
+        default=1
+    )
+    parser.add_argument(
+        '--num_sizes', 
+        nargs='*', 
+        type=int,
+        help='List of count of layers',
+        default=[5]
+    )
+    parser.add_argument(
+        '--file', 
+        type=int, 
+        help='Starting file number',
+        default=1
+    )
+    args = parser.parse_args()
+    file = args.file
+    num_object_list = args.num_sizes
+    append = (file != 1)
+    generate_depth_images(args.num_images, num_object_list , file)

list_colours/script.py

@@ -0,0 +1,143 @@
+from itertools import combinations
+import matplotlib.pyplot as plt
+import PIL
+from PIL import Image
+import cv2
+import random
+import numpy as np
+import os
+import json
+import argparse
+
+def generate_shapes(num_images, num_objects_list , file):
+    # Set up the plot
+
+    output_dir = os.path.join(os.getcwd(), "data")
+    input_dir = os.path.join(os.getcwd(), "background_image")
+    if not os.path.exists(output_dir):
+        os.makedirs(output_dir)
+
+    data = []
+    append = (file != 1)
+
+    for n in num_objects_list:
+        for img_index in range(num_images):
+            im = Image.open(os.path.join(input_dir, f"bg_{img_index+1}.png"))
+            fig, ax = plt.subplots()
+            ax.imshow(im)
+            ax.set_aspect('equal')
+            plt.axis('off')
+
+            # Adjust plot limits to prevent cutoff
+            #plt.xlim(-1500.0, 1500.0)
+            #plt.ylim(-1000, 1000)
+
+            # Generate random positions for the shapes
+            positions = []
+            radius = 150
+            shapes = ['circle', 'triangle', 'rectangle', 'pentagon']
+            #colours = ['red', 'green', 'blue', 'yellow', 'orange', 'pink']
+            height, width = im.size
+            gold_answer = []
+            for i in range(n):
+                while True:
+                    x, y = random.randint(2*radius, height-(2*radius)), random.randint(2*radius, width-(2*radius))
+                    # Ensure shapes don't overlap
+                    if all(((x - px) ** 2 + (y - py) ** 2) ** 0.5 > 2 * radius for px, py in positions):
+                        positions.append((x, y))
+                        break
+
+            # Choose one odd-colored shape
+            #odd_index = random.randint(0, n - 1)
+
+            # Draw shapes and label them
+            colours = {'black', 'gray', 'brown', 'maroon', 'red', 'coral', 'tan', 'orange', 'ivory', 'goldenrod', 'yellow', 'green', 'olive', 'turquoise', 'skyblue', 'blue', 'lavender', 'purple', 'pink', 'fuchsia'}
+            colours_n = random.choice(list(combinations(colours, n)))
+            for i, (x, y) in enumerate(positions):
+                color = colours_n[i]
+                shape_type = random.choice(shapes)
+                gold_answer.append(color)
+
+                if shape_type == 'circle':
+                    shape = plt.Circle((x, y), radius, color=color)
+                elif shape_type == 'triangle':
+                    triangle = np.array([[x, y + radius], [x - radius, y - radius], [x + radius, y - radius]])
+                    shape = plt.Polygon(triangle, color=color)
+                elif shape_type == 'rectangle':
+                    shape = plt.Rectangle((x - radius, y - radius), 2 * radius, 2 * radius, color=color)
+                elif shape_type == 'pentagon':
+                    pentagon = np.array([
+                        [x, y + radius], [x + 0.95 * radius, y + 0.31 * radius],
+                        [x + 0.59 * radius, y - 0.81 * radius], [x - 0.59 * radius, y - 0.81 * radius],
+                        [x - 0.95 * radius, y + 0.31 * radius]
+                    ])
+                    shape = plt.Polygon(pentagon, color=color)
+
+                ax.add_patch(shape)
+                #ax.text(x, y, str(i + 1), color='white', ha='center', va='center', fontsize=8, weight='bold')
+
+            # Save the plot to a file
+            filename = f"{file}.png"
+            filepath = os.path.join(output_dir, filename)
+            plt.savefig(filepath, bbox_inches='tight')
+            plt.close()
+            answer = sorted(gold_answer)
+            img1 = cv2.imread("data/"+f"{file}.png")
+            img2 = cv2.imread("swatches.png")
+            if img1.shape[1] != img2.shape[1]:
+                max_width = max(img1.shape[1], img2.shape[1])
+                img1 = cv2.resize(img1, (max_width, img1.shape[0]))
+                img2 = cv2.resize(img2, (max_width, img2.shape[0]))
+
+            merged_image = cv2.vconcat([img1, img2])
+            cv2.imwrite(filepath, merged_image)
+            file += 1
+            gold_output = {
+                "id": filename,
+                "list_colours": answer,
+                "num_objects": n
+            }
+            data.append(gold_output)
+
+
+    if append:
+        with open(os.path.join(os.getcwd() , "data.json"), "r") as f:
+            old_data = json.load(f)
+            old_data.extend(data)
+        with open(os.path.join(os.getcwd() , "data.json"), "w") as f:
+            json.dump(old_data, f, indent=2)
+    else:
+        with open(os.path.join(os.getcwd() , "data.json"), "w") as f:
+            json.dump(data, f, indent=2)
+
+
+
+# # Example usage
+# generate_shapes(10, 'shapes.png')
+if __name__ == "__main__":
+    # Parse command line arguments
+    parser = argparse.ArgumentParser(description='Create an image of different objects')
+    parser.add_argument(
+        '--num_images', 
+        type=int, 
+        help='Number of images to generate',
+        default=1
+    )
+    parser.add_argument(
+        '--num_sizes', 
+        nargs='*', 
+        type=int,
+        help='List of count of objects',
+        default=[5]
+    )
+    parser.add_argument(
+        '--file', 
+        type=int, 
+        help='Starting file number',
+        default=1
+    )
+    args = parser.parse_args()
+    file = args.file
+    num_object_list = args.num_sizes
+    append = (file != 1)
+    generate_shapes(args.num_images, num_object_list , file)

list_shapes/script.py

@@ -0,0 +1,131 @@
+import matplotlib.pyplot as plt
+import PIL
+from PIL import Image
+import random
+import numpy as np
+import os
+import json
+import argparse
+
+def generate_shapes(num_images, num_objects_list , file):
+    # Set up the plot
+
+    output_dir = os.path.join(os.getcwd(), "data")
+    input_dir = os.path.join(os.getcwd(), "background_image")
+    if not os.path.exists(output_dir):
+        os.makedirs(output_dir)
+
+    data = []
+    append = (file != 1)
+
+    for n in num_objects_list:
+        for img_index in range(num_images):
+            im = Image.open(os.path.join(input_dir, f"bg_{img_index+1}.png"))
+            fig, ax = plt.subplots()
+            ax.imshow(im)
+            ax.set_aspect('equal')
+            plt.axis('off')
+
+            # Adjust plot limits to prevent cutoff
+            #plt.xlim(-1500.0, 1500.0)
+            #plt.ylim(-1000, 1000)
+
+            # Generate random positions for the shapes
+            positions = []
+            radius = 75
+            shapes = ['circle', 'triangle', 'square', 'pentagon']
+            colours = ['red', 'green', 'blue']
+            height, width = im.size
+            gold_answer = set()
+            for i in range(n):
+                while True:
+                    x, y = random.randint(2*radius, height-(2*radius)), random.randint(2*radius, width-(2*radius))
+                    # Ensure shapes don't overlap
+                    if all(((x - px) ** 2 + (y - py) ** 2) ** 0.5 > 2 * radius for px, py in positions):
+                        positions.append((x, y))
+                        break
+
+            # Choose one odd-colored shape
+            #odd_index = random.randint(0, n - 1)
+
+            # Draw shapes and label them
+            for i, (x, y) in enumerate(positions):
+                color = random.choice(colours)
+                shape_type = random.choice(shapes)
+                gold_answer.add(shape_type)
+
+                if shape_type == 'circle':
+                    shape = plt.Circle((x, y), radius, color=color)
+                elif shape_type == 'triangle':
+                    triangle = np.array([[x, y + radius], [x - radius, y - radius], [x + radius, y - radius]])
+                    shape = plt.Polygon(triangle, color=color)
+                elif shape_type == 'square':
+                    shape = plt.Rectangle((x - radius, y - radius), 2 * radius, 2 * radius, color=color)
+                elif shape_type == 'pentagon':
+                    pentagon = np.array([
+                        [x, y + radius], [x + 0.95 * radius, y + 0.31 * radius],
+                        [x + 0.59 * radius, y - 0.81 * radius], [x - 0.59 * radius, y - 0.81 * radius],
+                        [x - 0.95 * radius, y + 0.31 * radius]
+                    ])
+                    shape = plt.Polygon(pentagon, color=color)
+
+                ax.add_patch(shape)
+                #ax.text(x, y, str(i + 1), color='white', ha='center', va='center', fontsize=8, weight='bold')
+
+            # Save the plot to a file
+            filename = f"{file}.png"
+            file += 1
+            filepath = os.path.join(output_dir, filename)
+            plt.savefig(filepath, bbox_inches='tight')
+            plt.close()
+            answer = sorted(list(gold_answer))
+
+            gold_output = {
+                "id": filename,
+                "list_shapes": answer,
+                "num_objects": n
+            }
+            data.append(gold_output)
+
+
+    if append:
+        with open(os.path.join(os.getcwd() , "data.json"), "r") as f:
+            old_data = json.load(f)
+            old_data.extend(data)
+        with open(os.path.join(os.getcwd() , "data.json"), "w") as f:
+            json.dump(old_data, f, indent=2)
+    else:
+        with open(os.path.join(os.getcwd() , "data.json"), "w") as f:
+            json.dump(data, f, indent=2)
+
+
+
+# # Example usage
+# generate_shapes(10, 'shapes.png')
+if __name__ == "__main__":
+    # Parse command line arguments
+    parser = argparse.ArgumentParser(description='Create an image of different objects')
+    parser.add_argument(
+        '--num_images', 
+        type=int, 
+        help='Number of images to generate',
+        default=1
+    )
+    parser.add_argument(
+        '--num_sizes', 
+        nargs='*', 
+        type=int,
+        help='List of count of objects',
+        default=[5]
+    )
+    parser.add_argument(
+        '--file', 
+        type=int, 
+        help='Starting file number',
+        default=1
+    )
+    args = parser.parse_args()
+    file = args.file
+    num_object_list = args.num_sizes
+    append = (file != 1)
+    generate_shapes(args.num_images, num_object_list , file)

locate_circles_colour/script.py

@@ -0,0 +1,168 @@
+from PIL import Image, ImageDraw, ImageFont
+import random
+import argparse
+import os
+import json
+
+def create_labeled_grid(n, m, cell_size=100, margin=40):
+    """
+    Create and save an image with a labeled grid.
+    
+    Args:
+        rows (int): Number of rows in the grid
+        cols (int): Number of columns in the grid
+        cell_size (int): Size of each cell in pixels
+        margin (int): Margin around the grid for labels
+        filename (str): Name of the output file
+    """
+    global file, output_dir
+
+    rows = cols = n
+
+    # Calculate total size including margins for labels
+    width = cols * cell_size + 2 * margin
+    height = rows * cell_size + 2 * margin
+    
+    # Create a new white image
+    image = Image.new('RGB', (width, height), 'white')
+    draw = ImageDraw.Draw(image)
+    
+    # Try to use Arial font, fall back to default if not available
+    try:
+        font = ImageFont.truetype("arial.ttf", size=20)
+    except IOError:
+        font = ImageFont.load_default()
+    
+    # Draw vertical lines and column labels
+    for i in range(cols + 1):
+        x = margin + i * cell_size
+        # Draw vertical line
+        draw.line([(x, margin), (x, height - margin)], fill='black', width=2)
+        # Draw column label (skip last number)
+        if i < cols:
+            label = str(i + 1)
+            # Get text size for centering
+            text_bbox = draw.textbbox((0, 0), label, font=font)
+            text_width = text_bbox[2] - text_bbox[0]
+            draw.text((x + (cell_size - text_width) // 2, margin // 2), 
+                     label, fill='black', font=font)
+    
+    # Draw horizontal lines and row labels
+    for i in range(rows + 1):
+        y = margin + i * cell_size
+        # Draw horizontal line
+        draw.line([(margin, y), (width - margin, y)], fill='black', width=2)
+        # Draw row label (skip last number)
+        if i < rows:
+            # Changed from letters to numbers
+            label = str(i + 1)
+            text_bbox = draw.textbbox((0, 0), label, font=font)
+            text_height = text_bbox[3] - text_bbox[1]
+            draw.text((margin // 2, y + (cell_size - text_height) // 2), 
+                     label, fill='black', font=font)
+            
+    shape_colors = ['red', 'blue', 'purple' , 'yellow']
+    shape_types = ['circle']
+
+    coord_list = []
+    
+    # for random m cells draw a green circle in them
+    k = 0
+
+    while k < m:
+        i = random.randint(0, rows - 1)
+        j = random.randint(0, cols - 1)
+        if (i+1, j+1) in coord_list:
+            # k -= 1
+            continue
+        # print(k , i, j)
+        top_left = (margin + j * cell_size + 5, margin + i * cell_size + 5)
+        bottom_right = (margin + (j + 1) * cell_size - 5, margin + (i + 1) * cell_size - 5)
+        draw.ellipse([top_left, bottom_right], fill='green')
+        coord_list.append((i+1, j+1))
+        k += 1
+    
+    for i in range(rows):
+        for j in range(cols):
+            if (i+1, j+1) not in coord_list:
+                shape_type = random.choice(shape_types)
+                if shape_type != 'circle':
+                    shape_color = random.choice(shape_colors + ['green'])
+                else:
+                    shape_color = random.choice(shape_colors)
+                top_left = (margin + j * cell_size + 5, margin + i * cell_size + 5)
+                bottom_right = (margin + (j + 1) * cell_size - 5, margin + (i + 1) * cell_size - 5)
+                if shape_type == 'circle':
+                    draw.ellipse([top_left, bottom_right], fill=shape_color)
+                elif shape_type == 'square':
+                    draw.rectangle([top_left, bottom_right], fill=shape_color)
+                elif shape_type == 'triangle':
+                    mid_x = (top_left[0] + bottom_right[0]) / 2
+                    draw.polygon([top_left, (bottom_right[0], top_left[1]), (mid_x, bottom_right[1])], fill=shape_color)
+
+
+    image_filename = f"{file}.png"
+    file += 1
+    image_path = os.path.join(output_dir, image_filename)
+    image.save(image_path)
+
+    return coord_list
+
+# Example usage
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description='Create a grid of circles and triangles.')
+    parser.add_argument(
+        '--num_images', 
+        type=int, 
+        help='Number of images to generate',
+        default=1
+    )
+    parser.add_argument(
+        '--num_sizes', 
+        nargs='*', 
+        help='List of n values',
+        default=[5 , 3]
+    )
+    parser.add_argument(
+        '--grid_size', 
+        type=int, 
+        help='Grid size', 
+        default=6
+    )
+    parser.add_argument(
+        '--file', 
+        type=int, 
+        help='Starting file number',
+        default=1
+    )
+    args = parser.parse_args()
+    file = args.file
+    num_sizes = args.num_sizes
+    append = (file != 1)
+    data = []
+    output_dir = os.path.join(os.getcwd(), "data")
+    if not os.path.exists(output_dir):
+        os.makedirs(output_dir)
+
+    for j in range(0, len(num_sizes)):
+        for i in range(args.num_images):
+            rows = args.grid_size
+            n_circles = int(num_sizes[j])
+            coord_list = create_labeled_grid(rows, n_circles)
+            # print(grid)
+            data.append({
+                'id': f"{file-1}.png",
+                'rows': rows,
+                'n_circles': n_circles,
+                'gold_output': coord_list
+            })
+
+    if append:
+        with open(os.path.join(os.getcwd() , "data.json"), "r") as f:
+            old_data = json.load(f)
+            old_data.extend(data)
+        with open(os.path.join(os.getcwd() , "data.json"), "w") as f:
+            json.dump(old_data, f, indent=2)
+    else:
+        with open(os.path.join(os.getcwd() , "data.json"), "w") as f:
+            json.dump(data, f, indent=2)

locate_circles_shape/script.py

@@ -0,0 +1,168 @@
+from PIL import Image, ImageDraw, ImageFont
+import random
+import argparse
+import os
+import json
+
+def create_labeled_grid(n, m, cell_size=100, margin=40):
+    """
+    Create and save an image with a labeled grid.
+    
+    Args:
+        rows (int): Number of rows in the grid
+        cols (int): Number of columns in the grid
+        cell_size (int): Size of each cell in pixels
+        margin (int): Margin around the grid for labels
+        filename (str): Name of the output file
+    """
+    global file, output_dir
+
+    rows = cols = n
+
+    # Calculate total size including margins for labels
+    width = cols * cell_size + 2 * margin
+    height = rows * cell_size + 2 * margin
+    
+    # Create a new white image
+    image = Image.new('RGB', (width, height), 'white')
+    draw = ImageDraw.Draw(image)
+    
+    # Try to use Arial font, fall back to default if not available
+    try:
+        font = ImageFont.truetype("arial.ttf", size=20)
+    except IOError:
+        font = ImageFont.load_default()
+    
+    # Draw vertical lines and column labels
+    for i in range(cols + 1):
+        x = margin + i * cell_size
+        # Draw vertical line
+        draw.line([(x, margin), (x, height - margin)], fill='black', width=2)
+        # Draw column label (skip last number)
+        if i < cols:
+            label = str(i + 1)
+            # Get text size for centering
+            text_bbox = draw.textbbox((0, 0), label, font=font)
+            text_width = text_bbox[2] - text_bbox[0]
+            draw.text((x + (cell_size - text_width) // 2, margin // 2), 
+                     label, fill='black', font=font)
+    
+    # Draw horizontal lines and row labels
+    for i in range(rows + 1):
+        y = margin + i * cell_size
+        # Draw horizontal line
+        draw.line([(margin, y), (width - margin, y)], fill='black', width=2)
+        # Draw row label (skip last number)
+        if i < rows:
+            # Changed from letters to numbers
+            label = str(i + 1)
+            text_bbox = draw.textbbox((0, 0), label, font=font)
+            text_height = text_bbox[3] - text_bbox[1]
+            draw.text((margin // 2, y + (cell_size - text_height) // 2), 
+                     label, fill='black', font=font)
+            
+    shape_colors = ['green']
+    shape_types = ['square', 'triangle']
+
+    coord_list = []
+    
+    # for random m cells draw a green circle in them
+    k = 0
+
+    while k < m:
+        i = random.randint(0, rows - 1)
+        j = random.randint(0, cols - 1)
+        if (i+1, j+1) in coord_list:
+            # k -= 1
+            continue
+        # print(k , i, j)
+        top_left = (margin + j * cell_size + 5, margin + i * cell_size + 5)
+        bottom_right = (margin + (j + 1) * cell_size - 5, margin + (i + 1) * cell_size - 5)
+        draw.ellipse([top_left, bottom_right], fill='green')
+        coord_list.append((i+1, j+1))
+        k += 1
+    
+    for i in range(rows):
+        for j in range(cols):
+            if (i+1, j+1) not in coord_list:
+                shape_type = random.choice(shape_types)
+                if shape_type != 'circle':
+                    shape_color = random.choice(shape_colors + ['green'])
+                else:
+                    shape_color = random.choice(shape_colors)
+                top_left = (margin + j * cell_size + 5, margin + i * cell_size + 5)
+                bottom_right = (margin + (j + 1) * cell_size - 5, margin + (i + 1) * cell_size - 5)
+                if shape_type == 'circle':
+                    draw.ellipse([top_left, bottom_right], fill=shape_color)
+                elif shape_type == 'square':
+                    draw.rectangle([top_left, bottom_right], fill=shape_color)
+                elif shape_type == 'triangle':
+                    mid_x = (top_left[0] + bottom_right[0]) / 2
+                    draw.polygon([top_left, (bottom_right[0], top_left[1]), (mid_x, bottom_right[1])], fill=shape_color)
+
+
+    image_filename = f"{file}.png"
+    file += 1
+    image_path = os.path.join(output_dir, image_filename)
+    image.save(image_path)
+
+    return coord_list
+
+# Example usage
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description='Create a grid of circles and triangles.')
+    parser.add_argument(
+        '--num_images', 
+        type=int, 
+        help='Number of images to generate',
+        default=1
+    )
+    parser.add_argument(
+        '--num_sizes', 
+        nargs='*', 
+        help='List of n values',
+        default=[5 , 3]
+    )
+    parser.add_argument(
+        '--grid_size', 
+        type=int, 
+        help='Grid size', 
+        default=6
+    )
+    parser.add_argument(
+        '--file', 
+        type=int, 
+        help='Starting file number',
+        default=1
+    )
+    args = parser.parse_args()
+    file = args.file
+    num_sizes = args.num_sizes
+    append = (file != 1)
+    data = []
+    output_dir = os.path.join(os.getcwd(), "data")
+    if not os.path.exists(output_dir):
+        os.makedirs(output_dir)
+
+    for j in range(0, len(num_sizes)):
+        for i in range(args.num_images):
+            rows = args.grid_size
+            n_circles = int(num_sizes[j])
+            coord_list = create_labeled_grid(rows, n_circles)
+            # print(grid)
+            data.append({
+                'id': f"{file-1}.png",
+                'rows': rows,
+                'n_circles': n_circles,
+                'gold_output': coord_list
+            })
+
+    if append:
+        with open(os.path.join(os.getcwd() , "data.json"), "r") as f:
+            old_data = json.load(f)
+            old_data.extend(data)
+        with open(os.path.join(os.getcwd() , "data.json"), "w") as f:
+            json.dump(old_data, f, indent=2)
+    else:
+        with open(os.path.join(os.getcwd() , "data.json"), "w") as f:
+            json.dump(data, f, indent=2)

match_outline/script.py

@@ -0,0 +1,156 @@
+import matplotlib.pyplot as plt
+import numpy as np
+import random
+import os
+import json
+import argparse
+
+def create_images(num_images, num_objects_list , file):
+    # Ensure the output directory exists
+    output_dir = os.path.join(os.getcwd(), "data")
+    if not os.path.exists(output_dir):
+        os.makedirs(output_dir)
+
+    data = []
+    
+    append = (file != 1)
+    for num_objects in num_objects_list:
+        dpi = 100  # Dots per inch
+        width_inches = 1  # 100 pixels
+        height_inches = num_objects + 1  # 100 pixels per row
+        for img_index in range(num_images):
+            shapes1, shapes2 = [], []
+            fig, ax = plt.subplots(figsize=(width_inches, height_inches), dpi=dpi)
+            for i in range (num_objects):
+                y = num_objects - i - 1
+                x = 0.5
+                radius = 0.1
+                shapes = ['circle', 'triangle', 'rectangle', 'pentagon']
+                #colours = ['red', 'green', 'blue']
+
+
+                # Add circles to the plot
+                shape_type = random.choice(shapes)
+                shapes1.append(shape_type)
+                if shape_type == 'circle':
+                    shape = plt.Circle((x, y), radius, color="blue")
+                elif shape_type == 'triangle':
+                    triangle = np.array([[x, y + radius], [x - radius, y - radius], [x + radius, y - radius]])
+                    shape = plt.Polygon(triangle, color="blue")
+                elif shape_type == 'rectangle':
+                    shape = plt.Rectangle((x - radius, y - radius), 2 * radius, 2 * radius, color="blue")
+                elif shape_type == 'pentagon':
+                    pentagon = np.array([
+                        [x, y + radius], [x + 0.95 * radius, y + 0.31 * radius],
+                        [x + 0.59 * radius, y - 0.81 * radius], [x - 0.59 * radius, y - 0.81 * radius],
+                        [x - 0.95 * radius, y + 0.31 * radius]
+                    ])
+                    shape = plt.Polygon(pentagon, color="blue")
+                ax.add_patch(shape)
+
+                # if i < num_objects -1:
+                ax.plot([0, 1], [y - 0.5, y - 0.5], color='black')
+
+            ax.set_xlim(0, 1)
+            ax.set_ylim(-0.6, num_objects - 0.5)
+            ax.set_aspect('equal')
+            ax.axis('off')
+
+            image_filename = f"first{file}.png"
+            image_path = os.path.join(output_dir, image_filename)
+            plt.savefig(image_path, bbox_inches='tight', dpi=dpi)
+            plt.close(fig)
+
+            fig, ax = plt.subplots(figsize=(width_inches, height_inches), dpi=dpi)
+            for i in range (num_objects):
+                y = num_objects - i - 1
+                x = 0.5
+                radius = 0.1
+                shapes = ['circle', 'triangle', 'rectangle', 'pentagon']
+                #colours = ['red', 'green', 'blue']
+
+
+                # Add circles to the plot
+                shape_type = random.choice(shapes)
+                shapes2.append(shape_type)
+                if shape_type == 'circle':
+                    shape = plt.Circle((x, y), radius, ec="blue", fill=False)
+                elif shape_type == 'triangle':
+                    triangle = np.array([[x, y + radius], [x - radius, y - radius], [x + radius, y - radius]])
+                    shape = plt.Polygon(triangle, ec="blue", fill = False)
+                elif shape_type == 'rectangle':
+                    shape = plt.Rectangle((x - radius, y - radius), 2 * radius, 2 * radius, ec="blue", fill=False)
+                elif shape_type == 'pentagon':
+                    pentagon = np.array([
+                        [x, y + radius], [x + 0.95 * radius, y + 0.31 * radius],
+                        [x + 0.59 * radius, y - 0.81 * radius], [x - 0.59 * radius, y - 0.81 * radius],
+                        [x - 0.95 * radius, y + 0.31 * radius]
+                    ])
+                    shape = plt.Polygon(pentagon, ec="blue", fill=False)
+                ax.add_patch(shape)
+
+                # if i < num_objects -1:
+                ax.plot([0, 1], [y - 0.5, y - 0.5], color='black')
+
+            ax.set_xlim(0, 1)
+            ax.set_ylim(-0.6, num_objects - 0.5)
+            ax.set_aspect('equal')
+            ax.axis('off')
+
+            image_filename = f"second{file}.png"
+            file += 1
+            image_path = os.path.join(output_dir, image_filename)
+            plt.savefig(image_path, bbox_inches='tight', dpi=dpi)
+            plt.close(fig)
+
+            answer = 0
+            for i in range(num_objects):
+                if(shapes1[i] == shapes2[i]):
+                    answer += 1
+            
+            
+
+            # Store the number of objects in the image_data dictionary
+            gold_output = {
+                "id": image_filename,
+                "Gold_output": answer,
+                "Rows" : num_objects
+            }
+            data.append(gold_output)
+
+    if append:
+        with open(os.path.join(os.getcwd() , "data.json"), "r") as f:
+            old_data = json.load(f)
+            old_data.extend(data)
+        with open(os.path.join(os.getcwd() , "data.json"), "w") as f:
+            json.dump(old_data, f, indent=2)
+    else:
+        with open(os.path.join(os.getcwd() , "data.json"), "w") as f:
+            json.dump(data, f, indent=2)
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description='Create a grid of circles and triangles.')
+    parser.add_argument(
+        '--num_images', 
+        type=int, 
+        help='Number of images to generate',
+        default=1
+    )
+    parser.add_argument(
+        '--num_sizes', 
+        nargs='*', 
+        type=int,
+        help='List of number of rows',
+        default=[5]
+    )
+    parser.add_argument(
+        '--file', 
+        type=int, 
+        help='Starting file number',
+        default=1
+    )
+    args = parser.parse_args()
+    file = args.file
+    num_object_list = args.num_sizes
+    append = (file != 1)
+    create_images(args.num_images, num_object_list , file)

match_shadow/script.py

@@ -0,0 +1,156 @@
+import matplotlib.pyplot as plt
+import numpy as np
+import random
+import os
+import json
+import argparse
+
+def create_images(num_images, num_objects_list , file):
+    # Ensure the output directory exists
+    output_dir = os.path.join(os.getcwd(), "data")
+    if not os.path.exists(output_dir):
+        os.makedirs(output_dir)
+
+    data = []
+    
+    append = (file != 1)
+    for num_objects in num_objects_list:
+        dpi = 100  # Dots per inch
+        width_inches = 1  # 100 pixels
+        height_inches = num_objects + 1  # 100 pixels per row
+        for img_index in range(num_images):
+            shapes1, shapes2 = [], []
+            fig, ax = plt.subplots(figsize=(width_inches, height_inches), dpi=dpi)
+            for i in range (num_objects):
+                y = num_objects - i - 1
+                x = 0.5
+                radius = 0.1
+                shapes = ['circle', 'triangle', 'rectangle', 'pentagon']
+                #colours = ['red', 'green', 'blue']
+
+
+                # Add circles to the plot
+                shape_type = random.choice(shapes)
+                shapes1.append(shape_type)
+                if shape_type == 'circle':
+                    shape = plt.Circle((x, y), radius, color="blue")
+                elif shape_type == 'triangle':
+                    triangle = np.array([[x, y + radius], [x - radius, y - radius], [x + radius, y - radius]])
+                    shape = plt.Polygon(triangle, color="blue")
+                elif shape_type == 'rectangle':
+                    shape = plt.Rectangle((x - radius, y - radius), 2 * radius, 2 * radius, color="blue")
+                elif shape_type == 'pentagon':
+                    pentagon = np.array([
+                        [x, y + radius], [x + 0.95 * radius, y + 0.31 * radius],
+                        [x + 0.59 * radius, y - 0.81 * radius], [x - 0.59 * radius, y - 0.81 * radius],
+                        [x - 0.95 * radius, y + 0.31 * radius]
+                    ])
+                    shape = plt.Polygon(pentagon, color="blue")
+                ax.add_patch(shape)
+
+                # if i < num_objects -1:
+                ax.plot([0, 1], [y - 0.5, y - 0.5], color='black')
+
+            ax.set_xlim(0, 1)
+            ax.set_ylim(-0.6, num_objects - 0.5)
+            ax.set_aspect('equal')
+            ax.axis('off')
+
+            image_filename = f"first{file}.png"
+            image_path = os.path.join(output_dir, image_filename)
+            plt.savefig(image_path, bbox_inches='tight', dpi=dpi)
+            plt.close(fig)
+
+            fig, ax = plt.subplots(figsize=(width_inches, height_inches), dpi=dpi)
+            for i in range (num_objects):
+                y = num_objects - i - 1
+                x = 0.5
+                radius = 0.1
+                shapes = ['circle', 'triangle', 'rectangle', 'pentagon']
+                #colours = ['red', 'green', 'blue']
+
+
+                # Add circles to the plot
+                shape_type = random.choice(shapes)
+                shapes2.append(shape_type)
+                if shape_type == 'circle':
+                    shape = plt.Circle((x, y), radius, color="blue")
+                elif shape_type == 'triangle':
+                    triangle = np.array([[x, y - radius], [x - radius, y + radius], [x + radius, y + radius]])
+                    shape = plt.Polygon(triangle, color="blue")
+                elif shape_type == 'rectangle':
+                    shape = plt.Rectangle((x - radius, y - radius), 2 * radius, 2 * radius, color="blue")
+                elif shape_type == 'pentagon':
+                    pentagon = np.array([
+                        [x, y - radius], [x + 0.95 * radius, y - 0.31 * radius],
+                        [x + 0.59 * radius, y + 0.81 * radius], [x - 0.59 * radius, y + 0.81 * radius],
+                        [x - 0.95 * radius, y - 0.31 * radius]
+                    ])
+                    shape = plt.Polygon(pentagon, color="blue")
+                ax.add_patch(shape)
+
+                # if i < num_objects -1:
+                ax.plot([0, 1], [y - 0.5, y - 0.5], color='black')
+
+            ax.set_xlim(0, 1)
+            ax.set_ylim(-0.6, num_objects - 0.5)
+            ax.set_aspect('equal')
+            ax.axis('off')
+
+            image_filename = f"second{file}.png"
+            file += 1
+            image_path = os.path.join(output_dir, image_filename)
+            plt.savefig(image_path, bbox_inches='tight', dpi=dpi)
+            plt.close(fig)
+
+            answer = 0
+            for i in range(num_objects):
+                if(shapes1[i] == shapes2[i]):
+                    answer += 1
+            
+            
+
+            # Store the number of objects in the image_data dictionary
+            gold_output = {
+                "id": image_filename,
+                "Gold_output": answer,
+                "Rows" : num_objects
+            }
+            data.append(gold_output)
+
+    if append:
+        with open(os.path.join(os.getcwd() , "data.json"), "r") as f:
+            old_data = json.load(f)
+            old_data.extend(data)
+        with open(os.path.join(os.getcwd() , "data.json"), "w") as f:
+            json.dump(old_data, f, indent=2)
+    else:
+        with open(os.path.join(os.getcwd() , "data.json"), "w") as f:
+            json.dump(data, f, indent=2)
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description='Create a grid of circles and triangles.')
+    parser.add_argument(
+        '--num_images', 
+        type=int, 
+        help='Number of images to generate',
+        default=1
+    )
+    parser.add_argument(
+        '--num_sizes', 
+        nargs='*', 
+        type=int,
+        help='List of number of rows',
+        default=[5]
+    )
+    parser.add_argument(
+        '--file', 
+        type=int, 
+        help='Starting file number',
+        default=1
+    )
+    args = parser.parse_args()
+    file = args.file
+    num_object_list = args.num_sizes
+    append = (file != 1)
+    create_images(args.num_images, num_object_list , file)

maze_solving/script.py

@@ -0,0 +1,179 @@
+from PIL import Image, ImageDraw
+import random
+import os
+import argparse
+import json
+# Global counter to ensure unique numbering across the entire maze
+current_path_number = 1
+end_x, end_y = 1, 1
+path_length = 3
+
+def create_grid(n, m):
+    grid = [['#' for _ in range(m)] for _ in range(n)]
+    return grid
+
+def carve_path(grid, x, y):
+    global current_path_number
+    global end_x, end_y
+    global path_length
+    grid[x][y] = str(current_path_number)
+    current_path_number += 1
+    directions = [(0, 1), (1, 0), (0, -1), (-1, 0)]
+    random.shuffle(directions)
+
+    for dx, dy in directions:
+        nx, ny = x + dx * 2, y + dy * 2
+        if 0 <= nx < len(grid) and 0 <= ny < len(grid[0]) and grid[nx][ny] == '#':
+            grid[x + dx][y + dy] = str(current_path_number)
+            if current_path_number == path_length:
+                end_x, end_y = x+dx, y+dy
+            current_path_number += 1
+            carve_path(grid, nx, ny)
+
+def find_solution(grid, start_pos, end_pos):
+    # BFS to find the optimal path
+    from collections import deque
+    
+    n, m = len(grid), len(grid[0])
+    directions = [(0, 1), (1, 0), (0, -1), (-1, 0)]
+    queue = deque([(start_pos, [grid[start_pos[0]][start_pos[1]]])])
+    visited = set([start_pos])
+
+    while queue:
+        (x, y), path = queue.popleft()
+        
+        if (x, y) == end_pos:
+            return path
+        
+        for dx, dy in directions:
+            nx, ny = x + dx, y + dy
+            if 0 <= nx < n and 0 <= ny < m and (nx, ny) not in visited and grid[nx][ny] != '#':
+                queue.append(((nx, ny), path + [grid[nx][ny]]))
+                visited.add((nx, ny))
+    
+    return []
+
+def generate_maze(n, m, path):
+    global current_path_number
+    global path_length
+    current_path_number = 1  # Reset global counter for new maze
+    path_length = path
+
+    grid = create_grid(n, m)
+    start_x, start_y = random.choice(range(1, n, 2)), random.choice(range(1, m, 2))
+    carve_path(grid, start_x, start_y)
+    
+    # Set the end position at the farthest point from the start
+    #end_x, end_y = random.choice(range(1, n, 2)), random.choice(range(1, m, 2))
+    
+    # Ensure start and end are not the same
+    """while (end_x, end_y) == (start_x, start_y):
+        end_x, end_y = random.choice(range(1, n, 2)), random.choice(range(1, m, 2))"""
+    
+    global end_x, end_y
+    if end_x == 1 and end_y == 1:
+        for x in range(n):
+            for y in range(m):
+                if grid[x][y] == str(path_length):
+                    end_x, end_y = x, y
+                    break
+    grid[start_x][start_y] = "S"  # Label the start
+    grid[end_x][end_y] = "E"  # Label the end
+    
+    solution = find_solution(grid, (start_x, start_y), (end_x, end_y))
+    end_x, end_y = 1, 1
+    return grid, (start_x, start_y), (end_x, end_y), solution
+
+def maze_to_image(grid, cell_size=40):
+    n, m = len(grid), len(grid[0])
+    img = Image.new("RGB", (m * cell_size, n * cell_size), color="white")
+    draw = ImageDraw.Draw(img)
+
+    for i, row in enumerate(grid):
+        for j, cell in enumerate(row):
+            top_left = (j * cell_size, i * cell_size)
+            bottom_right = ((j + 1) * cell_size, (i + 1) * cell_size)
+            draw.rectangle([top_left, bottom_right], outline="black", width=1)  # Draw cell borders
+            if cell == '#':
+                draw.rectangle([top_left, bottom_right], fill="black")
+            elif cell == 'S':  # Start cell
+                draw.rectangle([top_left, bottom_right], fill="white" , outline="black", width=1)
+                draw.text((top_left[0] + cell_size//4, top_left[1] + cell_size//4), "S", fill="black")
+                
+            elif cell == 'E':  # End cell
+                draw.rectangle([top_left, bottom_right], fill="white" , outline="black", width=1)
+                draw.text((top_left[0] + cell_size//4, top_left[1] + cell_size//4), "E", fill="black")
+            else:
+                draw.rectangle([top_left, bottom_right], fill="white" , outline="black", width=1)
+                draw.text((top_left[0] + cell_size//4, top_left[1] + cell_size//4), cell, fill="blue")
+    
+    return img
+
+if __name__ == "__main__":
+    output_dir = os.path.join(os.getcwd(), "data")
+    if not os.path.exists(output_dir):
+        os.makedirs(output_dir)
+
+    parser = argparse.ArgumentParser(description='Create a grid of circles and triangles.')
+    parser.add_argument(
+        '--num_images', 
+        type=int, 
+        help='Number of images to generate',
+        default=1
+    )
+    parser.add_argument(
+        '--num_sizes', 
+        nargs='*', 
+        type=int,
+        help='List of n values (num rows , num columns) to generate', 
+        default=[5 , 5]
+    )
+    parser.add_argument(
+        '--file', 
+        type=int, 
+        help='Starting file number',
+        default=1
+    )
+    args = parser.parse_args()
+
+    file = args.file
+    data = []
+    append = (file != 1)
+    num_images = args.num_images
+    num_size = args.num_sizes
+    # num_images = int(sys.argv[1])
+    # num_size = sys.argv[2:]
+    # num_size = [int(num_objects) for num_objects in num_size]
+    # n, m = 11, 11  # Dimensions of the maze (should be odd numbers)
+    for i in range(0 , len(num_size)):
+        n = 11
+        m = 11
+        for _ in range(num_images):
+            maze, start_pos, end_pos, solution = generate_maze(n, m, num_size[i])
+            # solution = [int(cell) for cell in solution]
+            img = maze_to_image(maze)
+            # img.show()
+            gold_output = {
+                "id": f"{file}.png",
+                "path": solution,
+                "Rows": n,
+                "Columns": m
+            }
+            file += 1
+            data.append(gold_output)
+            img.save(os.path.join(output_dir, gold_output["id"]))
+    
+    if append:
+        with open(os.path.join(os.getcwd() , "data.json"), "r") as f:
+            old_data = json.load(f)
+            old_data.extend(data)
+        with open(os.path.join(os.getcwd() , "data.json"), "w") as f:
+            json.dump(old_data, f, indent=2)
+    else:
+        with open(os.path.join(os.getcwd() , "data.json"), "w") as f:
+            json.dump(data, f, indent=2)
+    # maze, start_pos, end_pos, solution = generate_maze(n, m)
+    # print("Optimal Solution Path (cell numbers):", solution)
+    # img = maze_to_image(maze)
+    # img.show()
+    

mirror_image/script.py

@@ -0,0 +1,226 @@
+import matplotlib.pyplot as plt
+import cv2
+import PIL
+from PIL import Image
+import random
+import numpy as np
+import os
+import json
+import argparse
+
+def generate_shapes(num_images, num_objects_list , file):
+    # Set up the plot
+
+    output_dir = os.path.join(os.getcwd(), "data")
+    if not os.path.exists(output_dir):
+        os.makedirs(output_dir)
+
+    data = []
+    append = (file != 1)
+
+    for n in num_objects_list:
+        max_obj = 2*n
+        for img_index in range(num_images):
+            """fig, ax = plt.subplots()
+            ax.set_aspect('equal')
+            plt.axis('off')
+
+            # Adjust plot limits to prevent cutoff
+            plt.xlim(-0.1, 1.1)
+            plt.ylim(-0.1, 1.1)
+
+            # Generate random positions for the shapes
+            positions = []
+            radius = 0.05
+            shapes = ['circle', 'triangle', 'rectangle', 'pentagon']
+            colours = ['red', 'green', 'blue', 'yellow', 'orange', 'black']
+            for i in range(n):
+                while True:
+                    x, y = random.uniform(0.1, 0.9), random.uniform(0.1, 0.9)
+                    # Ensure shapes don't overlap
+                    if all(((x - px) ** 2 + (y - py) ** 2) ** 0.5 > 2 * radius for px, py in positions):
+                        positions.append((x, y))
+                        break
+
+            # Choose one odd-colored shape
+            #odd_index = random.randint(0, n - 1)
+
+            # Draw shapes and label them
+            for i, (x, y) in enumerate(positions):
+                color = random.choice(colours)
+                shape_type = random.choice(shapes)
+
+                if shape_type == 'circle':
+                    shape = plt.Circle((x, y), radius, color=color)
+                elif shape_type == 'triangle':
+                    triangle = np.array([[x, y + radius], [x - radius, y - radius], [x + radius, y - radius]])
+                    shape = plt.Polygon(triangle, color=color)
+                elif shape_type == 'rectangle':
+                    shape = plt.Rectangle((x - radius, y - radius), 2 * radius, 2 * radius, color=color)
+                elif shape_type == 'pentagon':
+                    pentagon = np.array([
+                        [x, y + radius], [x + 0.95 * radius, y + 0.31 * radius],
+                        [x + 0.59 * radius, y - 0.81 * radius], [x - 0.59 * radius, y - 0.81 * radius],
+                        [x - 0.95 * radius, y + 0.31 * radius]
+                    ])
+                    shape = plt.Polygon(pentagon, color=color)
+
+                ax.add_patch(shape)"""
+                #ax.text(x, y, str(i + 1), color='white', ha='center', va='center', fontsize=8, weight='bold')
+
+            # Save the plot to a file
+            fig, ax = plt.subplots()
+            ax.set_aspect('equal')
+            plt.axis('off')
+
+            # Adjust plot limits to prevent cutoff
+            plt.xlim(-203.5, 203.5)
+            plt.ylim(-203.5, 203.5)
+
+            # Generate random positions for the shapes
+            positions = []
+            radius = 3.5
+            shapes = ['circle', 'triangle', 'rectangle', 'pentagon']
+            colours = ['red', 'green', 'blue', 'yellow', 'orange', 'black']
+            for i in range(max_obj):
+                while True:
+                    x, y = random.uniform(-200, -3.5), random.uniform(-200, 200)
+                    # Ensure shapes don't overlap
+                    if all(((x - px) ** 2 + (y - py) ** 2) ** 0.5 > 2 * radius for px, py in positions):
+                        positions.append((x, y))
+                        break
+
+            # Choose one odd-colored shape
+            #odd_index = random.randint(0, n - 1)
+
+            # Draw shapes and label them
+            color, shape_type = [], []
+            plt.axvline(x = 0, color = 'blue')
+            for i, (x, y) in enumerate(positions):
+                color.append(random.choice(colours))
+                shape_type.append(random.choice(shapes))
+
+                if shape_type[-1] == 'circle':
+                    shape = plt.Circle((x, y), radius, color=color[-1])
+                elif shape_type[-1] == 'triangle':
+                    triangle = np.array([[x, y + radius], [x - radius, y - radius], [x + radius, y - radius]])
+                    shape = plt.Polygon(triangle, color=color[-1])
+                elif shape_type[-1] == 'rectangle':
+                    shape = plt.Rectangle((x - radius, y - radius), 2 * radius, 2 * radius, color=color[-1])
+                elif shape_type[-1] == 'pentagon':
+                    pentagon = np.array([
+                        [x, y + radius], [x + 0.95 * radius, y + 0.31 * radius],
+                        [x + 0.59 * radius, y - 0.81 * radius], [x - 0.59 * radius, y - 0.81 * radius],
+                        [x - 0.95 * radius, y + 0.31 * radius]
+                    ])
+                    shape = plt.Polygon(pentagon, color=color[-1])
+
+                ax.add_patch(shape)
+            filename = f"first{file}.png"
+            filepath = os.path.join(output_dir, filename)
+            plt.savefig(filepath, bbox_inches='tight')
+            plt.close()
+
+            fig, ax = plt.subplots()
+            ax.set_aspect('equal')
+            plt.axis('off')
+
+            # Adjust plot limits to prevent cutoff
+            plt.xlim(-203.5, 203.5)
+            plt.ylim(-203.5, 203.5)
+
+            for i in range(n):
+                x = list(positions[i])
+                x[0] = -x[0]
+                positions[i] = tuple(x)
+
+            plt.axvline(x = 0, color = 'blue')
+            for i, (x, y) in enumerate(positions):
+                if shape_type[i] == 'circle':
+                    shape = plt.Circle((x, y), radius, color=color[i])
+                elif shape_type[i] == 'triangle':
+                    triangle = np.array([[x, y + radius], [x - radius, y - radius], [x + radius, y - radius]])
+                    shape = plt.Polygon(triangle, color=color[i])
+                elif shape_type[i] == 'rectangle':
+                    shape = plt.Rectangle((x - radius, y - radius), 2 * radius, 2 * radius, color=color[i])
+                elif shape_type[i] == 'pentagon':
+                    pentagon = np.array([
+                        [x, y + radius], [x + 0.95 * radius, y + 0.31 * radius],
+                        [x + 0.59 * radius, y - 0.81 * radius], [x - 0.59 * radius, y - 0.81 * radius],
+                        [x - 0.95 * radius, y + 0.31 * radius]
+                    ])
+                    shape = plt.Polygon(pentagon, color=color[i])
+
+                ax.add_patch(shape)
+            filename = f"second{file}.png"
+            file += 1
+            filepath = os.path.join(output_dir, filename)
+            plt.savefig(filepath, bbox_inches='tight')
+            plt.close()
+            
+            gold_answer = n
+            """if choice == 0:
+                img = cv2.imread(filepath)
+                img_mirror = np.flip(img, axis=1)
+                cv2.imwrite(os.path.join(output_dir, f"second{file-1}.png"), img_mirror)
+                gold_answer = "Yes"
+            else:
+                angles = [90, 180, 270, 360]
+                angle = random.choice(angles)
+                img = Image.open(filepath)
+                rotated_image = img.rotate(angle, PIL.Image.BILINEAR)
+                rotated_image.save(os.path.join(output_dir, f"second{file-1}.png"), "PNG")
+                gold_answer = "No"
+                
+            """
+
+
+            gold_output = {
+                "id": filename,
+                "mirror_image": gold_answer,
+                "num_objects": n
+            }
+            data.append(gold_output)
+
+
+    if append:
+        with open(os.path.join(os.getcwd() , "data.json"), "r") as f:
+            old_data = json.load(f)
+            old_data.extend(data)
+        with open(os.path.join(os.getcwd() , "data.json"), "w") as f:
+            json.dump(old_data, f, indent=2)
+    else:
+        with open(os.path.join(os.getcwd() , "data.json"), "w") as f:
+            json.dump(data, f, indent=2)
+
+
+
+# # Example usage
+# generate_shapes(10, 'shapes.png')
+if __name__ == "__main__":
+    # Parse command line arguments
+    parser = argparse.ArgumentParser(description='Create an image of different objects')
+    parser.add_argument(
+        '--num_images', 
+        type=int, 
+        help='Number of images to generate',
+        default=1
+    )
+    parser.add_argument(
+        '--num_sizes', 
+        nargs='*', 
+        type=int,
+        help='List of count of objects',
+        default=[5]
+    )
+    parser.add_argument(
+        '--file', 
+        type=int, 
+        help='Starting file number',
+        default=1
+    )
+    args = parser.parse_args()
+    file = args.file
+    num_object_list = args.num_sizes
+    append = (file != 1)
+    generate_shapes(args.num_images, num_object_list , file)

numbered_shapes/script.py

@@ -0,0 +1,146 @@
+import matplotlib.pyplot as plt
+import PIL
+from PIL import Image
+import random
+import numpy as np
+import os
+import json
+import argparse
+
+def generate_shapes(num_images, num_objects_list , file):
+    # Set up the plot
+
+    output_dir = os.path.join(os.getcwd(), "data")
+    #input_dir = os.path.join(os.getcwd(), "background_image")
+    if not os.path.exists(output_dir):
+        os.makedirs(output_dir)
+
+    data = []
+    #max_obj = 30
+    append = (file != 1)
+
+    for n in num_objects_list:
+        max_obj = n*2
+        for img_index in range(num_images):
+            #im = Image.open(os.path.join(input_dir, f"bg_{img_index+1}.png"))
+            fig, ax = plt.subplots()
+            #ax.imshow(im)
+            ax.set_aspect('equal')
+            plt.axis('off')
+
+            # Adjust plot limits to prevent cutoff
+            plt.xlim(-1500, 1500)
+            plt.ylim(-1000, 1000)
+
+            # Generate random positions for the shapes
+            positions = []
+            radius = 75
+            shapes = ['triangle', 'rectangle', 'pentagon']
+            colours = ['red', 'green', 'blue']
+            height, width = 1000, 1500
+            gold_answer = set()
+            for i in range(max_obj):
+                while True:
+                    x, y = random.randint(-(width - radius), (width - radius)), random.randint(-(height - radius), (height-radius))
+                    # Ensure shapes don't overlap
+                    if all(((x - px) ** 2 + (y - py) ** 2) ** 0.5 > 2 * radius for px, py in positions):
+                        positions.append((x, y))
+                        break
+
+            # Choose one odd-colored shape
+            #odd_index = random.randint(0, n - 1)
+
+            # Draw shapes and label them
+            circle, tri, rect, pent = [], [], [], []
+            shape_types = []
+            for _ in range(max_obj):
+                shape_types.append(random.choice(shapes))
+            indices = random.sample(range(0, max_obj), n)
+            for index in indices:
+                shape_types[index] = 'circle'
+
+            for i, (x, y) in enumerate(positions):
+                color = random.choice(colours)
+                shape_type = shape_types[i]
+
+                if shape_type == 'circle':
+                    shape = plt.Circle((x, y), radius, color=color)
+                    circle.append(str(i+1))
+                elif shape_type == 'triangle':
+                    triangle = np.array([[x, y + radius], [x - radius, y - radius], [x + radius, y - radius]])
+                    shape = plt.Polygon(triangle, color=color)
+                    tri.append(str(i+1))
+                elif shape_type == 'rectangle':
+                    shape = plt.Rectangle((x - radius, y - radius), 2 * radius, 2 * radius, color=color)
+                    rect.append(str(i+1))
+                elif shape_type == 'pentagon':
+                    pentagon = np.array([
+                        [x, y + radius], [x + 0.95 * radius, y + 0.31 * radius],
+                        [x + 0.59 * radius, y - 0.81 * radius], [x - 0.59 * radius, y - 0.81 * radius],
+                        [x - 0.95 * radius, y + 0.31 * radius]
+                    ])
+                    shape = plt.Polygon(pentagon, color=color)
+                    pent.append(str(i+1))
+
+                ax.add_patch(shape)
+                ax.text(x, y, str(i + 1), color='white', ha='center', va='center', fontsize=8, weight='bold')
+
+            # Save the plot to a file
+            filename = f"{file}.png"
+            file += 1
+            filepath = os.path.join(output_dir, filename)
+            plt.savefig(filepath, bbox_inches='tight')
+            plt.close()
+
+            gold_output = {
+                "id": filename,
+                "circles": sorted(circle),
+                "triangles": sorted(tri),
+                "rectangles": sorted(rect),
+                "pentagons": sorted(pent),
+                "num_objects": n
+            }
+            data.append(gold_output)
+
+
+    if append:
+        with open(os.path.join(os.getcwd() , "data.json"), "r") as f:
+            old_data = json.load(f)
+            old_data.extend(data)
+        with open(os.path.join(os.getcwd() , "data.json"), "w") as f:
+            json.dump(old_data, f, indent=2)
+    else:
+        with open(os.path.join(os.getcwd() , "data.json"), "w") as f:
+            json.dump(data, f, indent=2)
+
+
+
+# # Example usage
+# generate_shapes(10, 'shapes.png')
+if __name__ == "__main__":
+    # Parse command line arguments
+    parser = argparse.ArgumentParser(description='Create an image of different objects')
+    parser.add_argument(
+        '--num_images', 
+        type=int, 
+        help='Number of images to generate',
+        default=1
+    )
+    parser.add_argument(
+        '--num_sizes', 
+        nargs='*', 
+        type=int,
+        help='List of count of objects',
+        default=[5]
+    )
+    parser.add_argument(
+        '--file', 
+        type=int, 
+        help='Starting file number',
+        default=1
+    )
+    args = parser.parse_args()
+    file = args.file
+    num_object_list = args.num_sizes
+    append = (file != 1)
+    generate_shapes(args.num_images, num_object_list , file)

sort_circles/script.py

@@ -0,0 +1,135 @@
+import matplotlib.pyplot as plt
+import random
+import os
+import json
+import argparse
+
+def generate_circles(num_circles, min_size_diff=0.05):
+    # Create a figure
+    global file
+    fig, ax = plt.subplots(figsize=(num_circles * 3, 5))
+
+    # Data to store the circles' information
+    circles_info = []
+    
+    # X-axis positions to ensure the circles are aligned horizontally
+    x_position = 0
+
+    # Store previously generated sizes to ensure minimum difference between sizes
+    radii = [0]
+    
+    for i in range(1, num_circles + 1):
+        # Generate a random radius ensuring no two are too close in size
+        while True:
+            radius = random.uniform(0.3, 2)  # Random size for the circle
+            if all(abs(radius - r) >= min_size_diff for r in radii):
+                radii.append(radius)
+                break
+
+        x_position += radius + radii[-2] + 0.5  # X-position for the circle
+        y = 2  # Y-position for alignment (all circles in a line)
+        
+        # Plot the circle
+        circle = plt.Circle((x_position, y), radius, color='black', fill=True)
+        ax.add_patch(circle)
+        
+        # Label the circle
+        ax.text(x_position, y, f'{i}', ha='center', va='center', fontsize=24, color='white')
+        
+        # Store the circle's label and size
+        circles_info.append({'label': i , 'size': radius})
+    
+    # Set limits and hide axes
+    ax.set_xlim(0, x_position + 2)
+    ax.set_ylim(0, 4)
+    ax.set_aspect('equal')
+    ax.axis('off')
+    
+    image_filename = f"{file}.png"
+    image_path = os.path.join(output_dir, image_filename)
+    plt.savefig(image_path, bbox_inches='tight')
+    plt.close(fig)
+
+    return circles_info
+
+def sort_circles(circles_info):
+    # Sort the circles based on their size
+    sorted_circles = sorted(circles_info, key=lambda x: x['size'])
+    
+    # Print the gold output
+    # print("Gold output (sorted by size):")
+    # for circle in sorted_circles:
+    #     print(f"{circle['label']}: Size {circle['size']:.2f}")
+    
+    return sorted_circles
+
+# def main():
+#     num_circles = 5  # Specify the number of circles to generate
+#     circles_info = generate_circles(num_circles)  # Generate the circles and store their info
+    
+#     # Sort the circles by size and get the gold output
+#     gold_output = sort_circles(circles_info)
+
+
+    
+#     return gold_output
+    # Optionally, you can save this output to a file or use it for further processing
+
+if __name__ == "__main__":
+    output_dir = os.path.join(os.getcwd(), "data")
+    if not os.path.exists(output_dir):
+        os.makedirs(output_dir)    
+    # file = 1
+    # num_images = int(sys.argv[1])
+    # num_object_list = sys.argv[2:]
+    # num_object_list = [int(num_objects) for num_objects in num_object_list]
+    parser = argparse.ArgumentParser(description='Create a grid of circles and triangles.')
+    parser.add_argument(
+        '--num_images', 
+        type=int, 
+        help='Number of images to generate',
+        default=1
+    )
+    parser.add_argument(
+        '--num_sizes', 
+        nargs='*', 
+        help='List of n values',
+        type=int,
+        default=[5 , 3]
+    )
+    parser.add_argument(
+        '--file', 
+        type=int, 
+        help='Starting file number',
+        default=1
+    )
+    args = parser.parse_args()
+    file = args.file
+    num_object_list = args.num_sizes
+    num_images = args.num_images
+    append = (file != 1)
+    data = []
+    # main()/
+    for num_circles in num_object_list:
+        for _ in range(num_images):
+            circles_info = generate_circles(num_circles)
+            output = sort_circles(circles_info)
+            # Store the number of objects in the image_data dictionary
+            gold_output = [circle['label'] for circle in output]
+            gold_output = {
+                "id": f'{file}.png',
+                "Gold_output": gold_output,
+                "Rows" : num_circles
+            }
+            file += 1
+            data.append(gold_output)
+
+    if append:
+        with open(os.path.join(os.getcwd() , "data.json"), "r") as f:
+            old_data = json.load(f)
+            old_data.extend(data)
+        with open(os.path.join(os.getcwd() , "data.json"), "w") as f:
+            json.dump(old_data, f, indent=2)
+    else:
+        with open(os.path.join(os.getcwd() , "data.json"), "w") as f:
+            json.dump(data, f, indent=2)

sort_lines/script.py

@@ -0,0 +1,109 @@
+from PIL import Image, ImageDraw, ImageFont
+import random
+import os
+import json
+import argparse
+
+def generate_parallel_lines(n=5, image_size=(1000, 1000) , min_size_diff=20):
+
+    global file
+
+    canvas = Image.new("RGB", image_size, (255, 255, 255))
+    draw = ImageDraw.Draw(canvas)
+    
+    line_spacing = image_size[0] // (n + 1)
+    base_y = image_size[1] - 10  # Common base for all lines
+    
+    min_length = image_size[1] // 4
+    max_length = image_size[1] - 40
+    
+    lengths = []
+    # prev_length = random.randint(min_length, max_length)
+    # lengths.append(prev_length)
+    
+    for _ in range(0, n):
+        new_length = random.randint(min_length, max_length)
+        # for prev_length in lengths:
+        #     while abs(new_length - prev_length) < min_size_diff:
+        #         new_length = random.randint(min_length, max_length)
+        # lengths.append(new_length)
+        # prev_length = new_length
+        #Check all length in lengths for minimumm size difference   
+        while any([abs(new_length - prev_length) < min_size_diff for prev_length in lengths]):
+            new_length = random.randint(min_length, max_length)
+        lengths.append(new_length)
+        
+    
+    for i in range(n):
+        x = (i + 1) * line_spacing
+        line_length = lengths[i]
+        start_y = base_y - line_length
+        end_y = base_y
+        color = (random.randint(50, 205), random.randint(50, 205), random.randint(50, 205))
+        
+        draw.line([(x, start_y), (x, end_y)], fill=color, width=3)
+        font = ImageFont.truetype('ARIAL.ttf', 30)
+        draw.text((x - 10, start_y - 30), f"{i+1}", fill=(0, 0, 0), font=font)
+
+    to_sort = [{"label": i+1, "length": lengths[i]} for i in range(n)]
+    sorted_lines = sorted(to_sort, key=lambda x: x['length'])
+    gold_output = sorted_lines
+
+    image_filename = f"{file}.png"
+    image_path = os.path.join(output_dir, image_filename)
+    canvas.save(image_path)
+
+    return gold_output
+
+
+if __name__ == "__main__":
+    output_dir = os.path.join(os.getcwd(), "data")
+    if not os.path.exists(output_dir):
+        os.makedirs(output_dir)
+    parser = argparse.ArgumentParser(description='Create a grid of circles and triangles.')
+    parser.add_argument(
+        '--num_images', 
+        type=int, 
+        help='Number of images to generate',
+        default=1
+    )
+    parser.add_argument(
+        '--num_sizes', 
+        nargs='*', 
+        help='List of n values',
+        type=int,
+        default=[5]
+    )
+    parser.add_argument(
+        '--file', 
+        type=int, 
+        help='Starting file number',
+        default=1
+    )
+    args = parser.parse_args()
+    file = args.file
+    num_object_list = args.num_sizes
+    num_images = args.num_images
+    append = (file != 1)
+    data = []
+    for num_circles in num_object_list:
+        for _ in range(num_images):
+            output = generate_parallel_lines(num_circles)
+            gold_output = [circle['label'] for circle in output]
+            gold_output = {
+                "id": f'{file}.png',
+                "Gold_output": gold_output,
+                "Lines" : num_circles
+            }
+            file += 1
+            data.append(gold_output)
+
+    if append:
+        with open(os.path.join(os.getcwd() , "data.json"), "r") as f:
+            old_data = json.load(f)
+            old_data.extend(data)
+        with open(os.path.join(os.getcwd() , "data.json"), "w") as f:
+            json.dump(old_data, f, indent=2)
+    else:
+        with open(os.path.join(os.getcwd() , "data.json"), "w") as f:
+            json.dump(data, f, indent=2)

vanishing_objects/script.py

@@ -0,0 +1,176 @@
+from PIL import Image, ImageDraw
+import random
+import os
+import json
+import argparse
+
+num_circle = 0 
+num_triangle = 0
+num_square = 0
+num_vanished = 0
+
+def random_shape2(draw, shape_type, x, y, size, flag):
+    """
+    Draw a random shape on the provided image.
+    """
+    global num_circle, num_square, num_triangle, num_vanished
+    #probability = random.uniform(0.0, 1.0)
+    if shape_type == "circle":
+        if flag == False:
+            draw.ellipse([x - size, y - size, x + size, y + size], fill="black")
+        else:
+            draw.ellipse([x - size, y - size, x + size, y + size], fill="white")
+            num_vanished += 1
+    elif shape_type == "square":
+        if flag == False:
+            draw.rectangle([x - size, y - size, x + size, y + size], fill="black")
+        else:
+            draw.rectangle([x - size, y - size, x + size, y + size], fill="white")
+            num_vanished += 1
+    elif shape_type == "triangle":
+        points = [
+            (x, y - size),  # Top
+            (x - size, y + size),  # Bottom left
+            (x + size, y + size),  # Bottom right
+        ]
+        if flag == False:
+            draw.polygon(points, fill="black")
+        else:
+            draw.polygon(points, fill="white")
+            num_vanished += 1
+
+def random_shape(draw, shape_type, x, y, size):
+    """
+    Draw a random shape on the provided image.
+    """
+    global num_circle, num_square, num_triangle
+    if shape_type == "circle":
+        draw.ellipse([x - size, y - size, x + size, y + size], fill="black")
+        num_circle +=1
+    elif shape_type == "square":
+        draw.rectangle([x - size, y - size, x + size, y + size], fill="black")
+        num_square +=1
+    elif shape_type == "triangle":
+        points = [
+            (x, y - size),  # Top
+            (x - size, y + size),  # Bottom left
+            (x + size, y + size),  # Bottom right
+        ]
+        draw.polygon(points, fill="black")
+        num_triangle +=1
+
+def create_images(num_images, num_objects_list , file):
+    # Ensure the output directory exists
+    global num_circle, num_square, num_triangle, num_vanished
+    output_dir = os.path.join(os.getcwd(), "data")
+    if not os.path.exists(output_dir):
+        os.makedirs(output_dir)
+
+    data = []
+    image_width, image_height = 1500, 1000
+    append = (file != 1)
+    #max_obj = 30
+    for num_objects in num_objects_list:
+        max_obj = num_objects*2
+        for img_index in range(num_images):
+            # Create a blank white image
+            image = Image.new("RGB", (image_width, image_height), "white")
+            draw = ImageDraw.Draw(image)
+
+            # List to hold positions and sizes of shapes
+            shapes = []
+            num_circle =0 
+            num_triangle = 0
+            num_square = 0
+            num_vanished = 0
+
+
+            # Possible shape types
+            shape_types = ["circle", "square", "triangle"]
+
+            while len(shapes) < max_obj:
+                shape_type = random.choice(shape_types)
+                size = random.randint(15, 30)
+                x = random.randint(size+50, image_width - size - 50)
+                y = random.randint(size + 50, image_height - size - 50)
+
+                # Check if the new shape overlaps or touches any existing shapes
+                overlap = False
+                for (sx, sy, ssize,_) in shapes:
+                    distance = ((sx - x) ** 2 + (sy - y) ** 2) ** 0.5
+                    if distance < (ssize + size)*1.5:
+                        overlap = True
+                        break
+
+                if not overlap:
+                    shapes.append((x, y, size, shape_type))
+            # print(shapes)
+            # Draw the shapes
+            for (x, y, size, shape_type) in shapes:
+                random_shape(draw, shape_type, x, y, size)
+
+            # Save the image with the filename `i.png`
+            image_filename = f"first{file}.png"
+            image_path = os.path.join(output_dir, image_filename)
+            image.save(image_path)
+            
+            indices = random.sample(range(0, max_obj), num_objects)
+            for i, (x, y, size, shape_type) in enumerate(shapes):
+                flag = False
+                if i in indices:
+                    flag = True
+                random_shape2(draw, shape_type, x, y, size, flag)
+
+            image_filename2 = f"second{file}.png"
+            file += 1
+            image_path2 = os.path.join(output_dir, image_filename2)
+            image.save(image_path2)
+
+            # Store the number of objects in the data dictionary
+            gold_output = {
+                "id": image_filename2,
+                "circles" : num_circle,
+                "squares" : num_square,
+                "triangles" : num_triangle,
+                "vanished" : num_vanished
+            }
+            data.append(gold_output)
+
+    # Save the data to a JSON file
+    if append:
+        with open(os.path.join(os.getcwd() , "data.json"), "r") as f:
+            old_data = json.load(f)
+            old_data.extend(data)
+        with open(os.path.join(os.getcwd() , "data.json"), "w") as f:
+            json.dump(old_data, f, indent=2)
+    else:
+        with open(os.path.join(os.getcwd() , "data.json"), "w") as f:
+            json.dump(data, f, indent=2)
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description='Create an image of different shapes')
+    parser.add_argument(
+        '--num_images', 
+        type=int, 
+        help='Number of images to generate',
+        default=1
+    )
+    parser.add_argument(
+        '--num_sizes', 
+        nargs='*', 
+        type=int,
+        help='List of total number of objects',
+        default=[5]
+    )
+    parser.add_argument(
+        '--file', 
+        type=int, 
+        help='Starting file number',
+        default=1
+    )
+    args = parser.parse_args()
+    file = args.file
+    num_object_list = args.num_sizes
+    # print(num_object_list)
+    # Create images with the specified number of objects
+    create_images(args.num_images, num_object_list , file)

water_image/script.py

@@ -0,0 +1,226 @@
+import matplotlib.pyplot as plt
+import cv2
+import PIL
+from PIL import Image
+import random
+import numpy as np
+import os
+import json
+import argparse
+
+def generate_shapes(num_images, num_objects_list , file):
+    # Set up the plot
+
+    output_dir = os.path.join(os.getcwd(), "data")
+    if not os.path.exists(output_dir):
+        os.makedirs(output_dir)
+
+    data = []
+    append = (file != 1)
+
+    for n in num_objects_list:
+        max_obj = 2*n
+        for img_index in range(num_images):
+            """fig, ax = plt.subplots()
+            ax.set_aspect('equal')
+            plt.axis('off')
+
+            # Adjust plot limits to prevent cutoff
+            plt.xlim(-0.1, 1.1)
+            plt.ylim(-0.1, 1.1)
+
+            # Generate random positions for the shapes
+            positions = []
+            radius = 0.05
+            shapes = ['circle', 'triangle', 'rectangle', 'pentagon']
+            colours = ['red', 'green', 'blue', 'yellow', 'orange', 'black']
+            for i in range(n):
+                while True:
+                    x, y = random.uniform(0.1, 0.9), random.uniform(0.1, 0.9)
+                    # Ensure shapes don't overlap
+                    if all(((x - px) ** 2 + (y - py) ** 2) ** 0.5 > 2 * radius for px, py in positions):
+                        positions.append((x, y))
+                        break
+
+            # Choose one odd-colored shape
+            #odd_index = random.randint(0, n - 1)
+
+            # Draw shapes and label them
+            for i, (x, y) in enumerate(positions):
+                color = random.choice(colours)
+                shape_type = random.choice(shapes)
+
+                if shape_type == 'circle':
+                    shape = plt.Circle((x, y), radius, color=color)
+                elif shape_type == 'triangle':
+                    triangle = np.array([[x, y + radius], [x - radius, y - radius], [x + radius, y - radius]])
+                    shape = plt.Polygon(triangle, color=color)
+                elif shape_type == 'rectangle':
+                    shape = plt.Rectangle((x - radius, y - radius), 2 * radius, 2 * radius, color=color)
+                elif shape_type == 'pentagon':
+                    pentagon = np.array([
+                        [x, y + radius], [x + 0.95 * radius, y + 0.31 * radius],
+                        [x + 0.59 * radius, y - 0.81 * radius], [x - 0.59 * radius, y - 0.81 * radius],
+                        [x - 0.95 * radius, y + 0.31 * radius]
+                    ])
+                    shape = plt.Polygon(pentagon, color=color)
+
+                ax.add_patch(shape)"""
+                #ax.text(x, y, str(i + 1), color='white', ha='center', va='center', fontsize=8, weight='bold')
+
+            # Save the plot to a file
+            fig, ax = plt.subplots()
+            ax.set_aspect('equal')
+            plt.axis('off')
+
+            # Adjust plot limits to prevent cutoff
+            plt.xlim(-203.5, 203.5)
+            plt.ylim(-203.5, 203.5)
+
+            # Generate random positions for the shapes
+            positions = []
+            radius = 3.5
+            shapes = ['circle', 'triangle', 'rectangle', 'pentagon']
+            colours = ['red', 'green', 'blue', 'yellow', 'orange', 'black']
+            for i in range(max_obj):
+                while True:
+                    x, y = random.uniform(-200, 200), random.uniform(3.5, 200)
+                    # Ensure shapes don't overlap
+                    if all(((x - px) ** 2 + (y - py) ** 2) ** 0.5 > 2 * radius for px, py in positions):
+                        positions.append((x, y))
+                        break
+
+            # Choose one odd-colored shape
+            #odd_index = random.randint(0, n - 1)
+
+            # Draw shapes and label them
+            color, shape_type = [], []
+            plt.axhline(y = 0, color = 'blue')
+            for i, (x, y) in enumerate(positions):
+                color.append(random.choice(colours))
+                shape_type.append(random.choice(shapes))
+
+                if shape_type[-1] == 'circle':
+                    shape = plt.Circle((x, y), radius, color=color[-1])
+                elif shape_type[-1] == 'triangle':
+                    triangle = np.array([[x, y + radius], [x - radius, y - radius], [x + radius, y - radius]])
+                    shape = plt.Polygon(triangle, color=color[-1])
+                elif shape_type[-1] == 'rectangle':
+                    shape = plt.Rectangle((x - radius, y - radius), 2 * radius, 2 * radius, color=color[-1])
+                elif shape_type[-1] == 'pentagon':
+                    pentagon = np.array([
+                        [x, y + radius], [x + 0.95 * radius, y + 0.31 * radius],
+                        [x + 0.59 * radius, y - 0.81 * radius], [x - 0.59 * radius, y - 0.81 * radius],
+                        [x - 0.95 * radius, y + 0.31 * radius]
+                    ])
+                    shape = plt.Polygon(pentagon, color=color[-1])
+
+                ax.add_patch(shape)
+            filename = f"first{file}.png"
+            filepath = os.path.join(output_dir, filename)
+            plt.savefig(filepath, bbox_inches='tight')
+            plt.close()
+
+            fig, ax = plt.subplots()
+            ax.set_aspect('equal')
+            plt.axis('off')
+
+            # Adjust plot limits to prevent cutoff
+            plt.xlim(-203.5, 203.5)
+            plt.ylim(-203.5, 203.5)
+
+            for i in range(n):
+                x = list(positions[i])
+                x[1] = -x[1]
+                positions[i] = tuple(x)
+
+            plt.axhline(y = 0, color = 'blue')
+            for i, (x, y) in enumerate(positions):
+                if shape_type[i] == 'circle':
+                    shape = plt.Circle((x, y), radius, color=color[i])
+                elif shape_type[i] == 'triangle':
+                    triangle = np.array([[x, y + radius], [x - radius, y - radius], [x + radius, y - radius]])
+                    shape = plt.Polygon(triangle, color=color[i])
+                elif shape_type[i] == 'rectangle':
+                    shape = plt.Rectangle((x - radius, y - radius), 2 * radius, 2 * radius, color=color[i])
+                elif shape_type[i] == 'pentagon':
+                    pentagon = np.array([
+                        [x, y + radius], [x + 0.95 * radius, y + 0.31 * radius],
+                        [x + 0.59 * radius, y - 0.81 * radius], [x - 0.59 * radius, y - 0.81 * radius],
+                        [x - 0.95 * radius, y + 0.31 * radius]
+                    ])
+                    shape = plt.Polygon(pentagon, color=color[i])
+
+                ax.add_patch(shape)
+            filename = f"second{file}.png"
+            file += 1
+            filepath = os.path.join(output_dir, filename)
+            plt.savefig(filepath, bbox_inches='tight')
+            plt.close()
+            
+            gold_answer = n
+            """if choice == 0:
+                img = cv2.imread(filepath)
+                img_mirror = np.flip(img, axis=1)
+                cv2.imwrite(os.path.join(output_dir, f"second{file-1}.png"), img_mirror)
+                gold_answer = "Yes"
+            else:
+                angles = [90, 180, 270, 360]
+                angle = random.choice(angles)
+                img = Image.open(filepath)
+                rotated_image = img.rotate(angle, PIL.Image.BILINEAR)
+                rotated_image.save(os.path.join(output_dir, f"second{file-1}.png"), "PNG")
+                gold_answer = "No"
+                
+            """
+
+
+            gold_output = {
+                "id": filename,
+                "water_image": gold_answer,
+                "num_objects": n
+            }
+            data.append(gold_output)
+
+
+    if append:
+        with open(os.path.join(os.getcwd() , "data.json"), "r") as f:
+            old_data = json.load(f)
+            old_data.extend(data)
+        with open(os.path.join(os.getcwd() , "data.json"), "w") as f:
+            json.dump(old_data, f, indent=2)
+    else:
+        with open(os.path.join(os.getcwd() , "data.json"), "w") as f:
+            json.dump(data, f, indent=2)
+
+
+
+# # Example usage
+# generate_shapes(10, 'shapes.png')
+if __name__ == "__main__":
+    # Parse command line arguments
+    parser = argparse.ArgumentParser(description='Create an image of different objects')
+    parser.add_argument(
+        '--num_images', 
+        type=int, 
+        help='Number of images to generate',
+        default=1
+    )
+    parser.add_argument(
+        '--num_sizes', 
+        nargs='*', 
+        type=int,
+        help='List of count of objects',
+        default=[5]
+    )
+    parser.add_argument(
+        '--file', 
+        type=int, 
+        help='Starting file number',
+        default=1
+    )
+    args = parser.parse_args()
+    file = args.file
+    num_object_list = args.num_sizes
+    append = (file != 1)
+    generate_shapes(args.num_images, num_object_list , file)