Upload 11 files

.gitattributes

@@ -33,3 +33,5 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+image/render_25.jpg filter=lfs diff=lfs merge=lfs -text
+image/render1.png filter=lfs diff=lfs merge=lfs -text

app.py

@@ -0,0 +1,94 @@
+import base64
+import io
+from fastapi import FastAPI, UploadFile, File, HTTPException
+import os
+import shutil
+from PIL import Image
+from fastapi.responses import JSONResponse
+from semantic_seg_model import segmentation_inference
+from similarity_inference import similarity_inference
+import json
+from gradio_client import Client, file
+
+app = FastAPI()
+
+## Initialize the pipeline
+input_images_dir = "image/"
+temp_processing_dir = input_images_dir + "processed/"
+
+# Define a function to handle the POST request at `imageAnalyzer`
+@app.post("/imageAnalyzer")
+def imageAnalyzer(image: UploadFile = File(...)):
+    """
+    This function takes in an image filepath and will return the PolyHaven url addresses of the 
+    top k materials similar to the wall, ceiling, and floor.
+    """
+    try:
+        # load image
+        image_path = os.path.join(input_images_dir, image.filename)
+        with open(image_path, "wb") as buffer:
+            shutil.copyfileobj(image.file, buffer)
+        image = Image.open(image_path)
+
+        # segment into components
+        segmentation_inference(image, temp_processing_dir)
+
+        # identify similar materials for each component
+        matching_urls = similarity_inference(temp_processing_dir)
+        print(matching_urls)
+
+        # Return the urls in a JSON response
+        return matching_urls
+    
+    except Exception as e:
+        print(str(e))
+        raise HTTPException(status_code=500, detail=str(e))
+    
+
+client = Client("MykolaL/StableDesign")
+
+@app.post("/image-render")
+def imageRender(prompt: str, image: UploadFile = File(...)):
+    """
+    Makes a prediction using the "StableDesign" model hosted on a server.
+
+    Returns:
+        The prediction result.
+    """
+    try:
+        image_path = os.path.join(input_images_dir, image.filename)
+        with open(image_path, "wb") as buffer:
+            shutil.copyfileobj(image.file, buffer)
+        image = Image.open(image_path)
+        # Convert PIL image to the required format for the prediction model, if necessary
+        # This example assumes the model accepts PIL images directly
+        
+        result = client.predict(
+                image=file(image_path),
+                text=prompt,
+                num_steps=50,
+                guidance_scale=10,
+                seed=1111664444,
+                strength=0.9,
+                a_prompt="interior design, 4K, high resolution, photorealistic",
+                n_prompt="window, door, low resolution, banner, logo, watermark, text, deformed, blurry, out of focus, surreal, ugly, beginner",
+                img_size=768,
+                api_name="/on_submit"
+        )
+        image_path = result
+        if not os.path.exists(image_path):
+            raise HTTPException(status_code=404, detail="Image not found")
+        
+        # Open the image file and convert it to base64
+        with open(image_path, "rb") as img_file:
+            base64_str = base64.b64encode(img_file.read()).decode('utf-8')
+        
+        return JSONResponse(content={"image": base64_str}, status_code=200)
+    except Exception as e:
+        print(str(e))
+        raise HTTPException(status_code=500, detail=str(e))
+    
+
+@app.get("/")
+def test():
+    return {"Hello": "World"}

data/embedding_db.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:014a29f36b6fbd851650ef9dd1e13c4fd2a9bcdb5d5776b920a343ed787c3de7
+size 3017909

image_helpers.py

@@ -0,0 +1,113 @@
+import os
+from PIL import Image 
+from cv2 import imread, cvtColor, COLOR_BGR2GRAY, COLOR_BGR2BGRA, COLOR_BGRA2RGB, threshold, THRESH_BINARY_INV, findContours, RETR_EXTERNAL, CHAIN_APPROX_SIMPLE, contourArea, minEnclosingCircle
+import numpy as np
+import torch
+import matplotlib.pyplot as plt
+
+def convert_images_to_grayscale(folder_path):
+    # Check if the folder exists
+    if not os.path.isdir(folder_path):
+        print(f"The folder path {folder_path} does not exist.")
+        return
+    
+    # Iterate over all files in the folder
+    for filename in os.listdir(folder_path):
+        if filename.endswith(('.png', '.jpg', '.jpeg', '.bmp', '.gif')):
+            image_path = os.path.join(folder_path, filename)
+            
+            # Open an image file
+            with Image.open(image_path) as img:
+                # Convert image to grayscale
+                grayscale_img = img.convert('L').convert('RGB')
+                grayscale_img.save(os.path.join(folder_path, filename))
+
+def crop_center_largest_contour(folder_path):
+    for each_image in os.listdir(folder_path):
+        image_path = os.path.join(folder_path, each_image)
+        image = imread(image_path)
+        gray_image = cvtColor(image, COLOR_BGR2GRAY)
+
+        # Threshold the image to get the non-white pixels
+        _, binary_mask = threshold(gray_image, 254, 255, THRESH_BINARY_INV)
+
+        # Find the largest contour
+        contours, _ = findContours(binary_mask, RETR_EXTERNAL, CHAIN_APPROX_SIMPLE)
+        largest_contour = max(contours, key=contourArea)
+
+        # Get the minimum enclosing circle
+        (x, y), radius = minEnclosingCircle(largest_contour)
+        center = (int(x), int(y))
+        radius = int(radius/3) # Divide by three (arbitrary) to make shape better
+
+        # Crop the image to the bounding box of the circle
+        x_min = max(0, center[0] - radius)
+        x_max = min(image.shape[1], center[0] + radius)
+        y_min = max(0, center[1] - radius)
+        y_max = min(image.shape[0], center[1] + radius)
+        cropped_image = image[y_min:y_max, x_min:x_max]
+        cropped_image_rgba = cvtColor(cropped_image, COLOR_BGR2BGRA)
+        cropped_pil_image = Image.fromarray(cvtColor(cropped_image_rgba, COLOR_BGRA2RGB))
+        cropped_pil_image.save(image_path)
+
+def extract_embeddings(transformation_chain, model: torch.nn.Module):
+    """Utility to compute embeddings."""
+    device = model.device
+
+    def pp(batch):
+        images = batch["image"]
+        image_batch_transformed = torch.stack(
+            [transformation_chain(image) for image in images]
+        )
+        new_batch = {"pixel_values": image_batch_transformed.to(device)}
+        with torch.no_grad():
+            embeddings = model(**new_batch).last_hidden_state[:, 0].cpu()
+        return {"embeddings": embeddings}
+
+    return pp
+
+def compute_scores(emb_one, emb_two):
+    """Computes cosine similarity between two vectors."""
+    scores = torch.nn.functional.cosine_similarity(emb_one, emb_two)
+    return scores.numpy().tolist()
+
+
+def fetch_similar(image, transformation_chain, device, model, all_candidate_embeddings, candidate_ids, top_k=3):
+    """Fetches the `top_k` similar images with `image` as the query."""
+    # Prepare the input query image for embedding computation.
+    image_transformed = transformation_chain(image).unsqueeze(0)
+    new_batch = {"pixel_values": image_transformed.to(device)}
+
+    # Compute the embedding.
+    with torch.no_grad():
+        query_embeddings = model(**new_batch).last_hidden_state[:, 0].cpu()
+
+    # Compute similarity scores with all the candidate images at one go.
+    # We also create a mapping between the candidate image identifiers
+    # and their similarity scores with the query image.
+    sim_scores = compute_scores(all_candidate_embeddings, query_embeddings)
+    similarity_mapping = dict(zip(candidate_ids, sim_scores))
+ 
+    # Sort the mapping dictionary and return `top_k` candidates.
+    similarity_mapping_sorted = dict(
+        sorted(similarity_mapping.items(), key=lambda x: x[1], reverse=True)
+    )
+    id_entries = list(similarity_mapping_sorted.keys())[:top_k]
+
+    ids = list(map(lambda x: int(x.split("_")[0]), id_entries))
+    return ids 
+
+def plot_images(images):
+
+    plt.figure(figsize=(20, 10))
+    columns = 6
+    for (i, image) in enumerate(images):
+        ax = plt.subplot(int(len(images) / columns + 1), columns, i + 1)
+        if i == 0:
+            ax.set_title("Query Image\n")
+        else:
+            ax.set_title(
+                "Similar Image # " + str(i) 
+            )
+        plt.imshow(np.array(image).astype("int"))
+        plt.axis("off")

requirements.txt

@@ -0,0 +1,105 @@
+aiohttp==3.9.5
+aiosignal==1.3.1
+annotated-types==0.7.0
+anyio==4.4.0
+asttokens==2.4.1
+attrs==23.2.0
+certifi==2024.2.2
+charset-normalizer==3.3.2
+click==8.1.7
+colorama==0.4.6
+comm==0.2.2
+contourpy==1.2.1
+cycler==0.12.1
+datasets==2.19.1
+debugpy==1.8.1
+decorator==5.1.1
+dill==0.3.8
+dnspython==2.6.1
+email_validator==2.1.1
+executing==2.0.1
+fastapi==0.111.0
+fastapi-cli==0.0.4
+filelock==3.14.0
+fonttools==4.52.1
+frozenlist==1.4.1
+fsspec==2024.3.1
+gradio_client==0.17.0
+h11==0.14.0
+httpcore==1.0.5
+httptools==0.6.1
+httpx==0.27.0
+huggingface-hub==0.23.1
+idna==3.7
+intel-openmp==2021.4.0
+ipykernel==6.29.4
+ipython==8.24.0
+jedi==0.19.1
+Jinja2==3.1.4
+jupyter_client==8.6.2
+jupyter_core==5.7.2
+kiwisolver==1.4.5
+markdown-it-py==3.0.0
+MarkupSafe==2.1.5
+matplotlib==3.9.0
+matplotlib-inline==0.1.7
+mdurl==0.1.2
+mkl==2021.4.0
+mpmath==1.3.0
+multidict==6.0.5
+multiprocess==0.70.16
+nest-asyncio==1.6.0
+networkx==3.3
+numpy==1.26.4
+opencv-python-headless==4.9.0.80
+orjson==3.10.3
+packaging==24.0
+pandas==2.2.2
+parso==0.8.4
+pillow==10.3.0
+platformdirs==4.2.2
+prompt-toolkit==3.0.43
+psutil==5.9.8
+pure-eval==0.2.2
+pyarrow==16.1.0
+pyarrow-hotfix==0.6
+pydantic==2.7.1
+pydantic_core==2.18.2
+Pygments==2.18.0
+pyparsing==3.1.2
+python-dateutil==2.9.0.post0
+python-dotenv==1.0.1
+python-multipart==0.0.9
+# pytz==2024.1
+# pywin32==306
+PyYAML==6.0.1
+pyzmq==26.0.3
+regex==2024.5.15
+requests==2.32.2
+rich==13.7.1
+safetensors==0.4.3
+shellingham==1.5.4
+six==1.16.0
+sniffio==1.3.1
+stack-data==0.6.3
+starlette==0.37.2
+sympy==1.12
+tbb==2021.12.0
+tokenizers==0.19.1
+torch==2.3.0
+torchvision==0.18.0
+tornado==6.4
+tqdm==4.66.4
+traitlets==5.14.3
+transformers==4.41.1
+typer==0.12.3
+typing_extensions==4.12.0
+tzdata==2024.1
+ujson==5.10.0
+urllib3==2.2.1
+uvicorn==0.29.0
+watchfiles==0.21.0
+# wcwidth==0.2.13
+# websockets==12.0
+xxhash==3.4.1
+yarl==1.9.4

semantic_seg_model.py

@@ -0,0 +1,317 @@
+import torch
+from transformers import pipeline, AutoImageProcessor, SegformerForSemanticSegmentation
+from typing import List
+from PIL import Image, ImageDraw, ImageFont, ImageChops, ImageMorph
+import numpy as np
+import datasets
+
+def find_center_of_non_black_pixels(image):
+    # Get image dimensions
+    width, height = image.size
+    
+    # Iterate over the pixels to find the center of the non-black pixels
+    total_x = 0
+    total_y = 0
+    num_non_black_pixels = 0
+    top, left, bottom, right = height, width, 0, 0
+    for y in range(height):
+        for x in range(width):
+            pixel = image.getpixel((x, y))
+            if pixel != (255, 255, 255):  # Non-black pixel
+                total_x += x
+                total_y += y
+                num_non_black_pixels += 1
+                top = min(top, y)
+                left = min(left, x)
+                bottom = max(bottom, y)
+                right = max(right, x)
+    
+    bbox_width = right - left
+    bbox_height = bottom - top
+    bbox_size = max(bbox_height, bbox_width)
+    # Calculate the center of the non-black pixels
+    if num_non_black_pixels == 0:
+        return None  # No non-black pixels found
+    center_x = total_x // num_non_black_pixels
+    center_y = total_y // num_non_black_pixels
+    return (center_x, center_y), bbox_size
+
+def create_centered_image(image, center, bbox_size):
+    # Get image dimensions
+    width, height = image.size
+    
+    # Calculate the offset to center the non-black pixels in the new image
+    offset_x = bbox_size // 2 - center[0]
+    offset_y = bbox_size // 2 - center[1]
+    
+    # Create a new image with the same size as the original image
+    new_image = Image.new("RGB", (bbox_size, bbox_size), color=(255, 255, 255))
+    
+    # Paste the non-black pixels onto the new image
+    new_image.paste(image, (offset_x, offset_y))
+
+    return new_image
+
+def ade_palette():
+    """ADE20K palette that maps each class to RGB values."""
+    return [
+        [180, 120, 20],
+        [180, 120, 120],
+        [6, 230, 230],
+        [80, 50, 50],
+        [4, 200, 3],
+        [120, 120, 80],
+        [140, 140, 140],
+        [204, 5, 255],
+        [230, 230, 230],
+        [4, 250, 7],
+        [224, 5, 255],
+        [235, 255, 7],
+        [150, 5, 61],
+        [120, 120, 70],
+        [8, 255, 51],
+        [255, 6, 82],
+        [143, 255, 140],
+        [204, 255, 4],
+        [255, 51, 7],
+        [204, 70, 3],
+        [0, 102, 200],
+        [61, 230, 250],
+        [255, 6, 51],
+        [11, 102, 255],
+        [255, 7, 71],
+        [255, 9, 224],
+        [9, 7, 230],
+        [220, 220, 220],
+        [255, 9, 92],
+        [112, 9, 255],
+        [8, 255, 214],
+        [7, 255, 224],
+        [255, 184, 6],
+        [10, 255, 71],
+        [255, 41, 10],
+        [7, 255, 255],
+        [224, 255, 8],
+        [102, 8, 255],
+        [255, 61, 6],
+        [255, 194, 7],
+        [255, 122, 8],
+        [0, 255, 20],
+        [255, 8, 41],
+        [255, 5, 153],
+        [6, 51, 255],
+        [235, 12, 255],
+        [160, 150, 20],
+        [0, 163, 255],
+        [140, 140, 140],
+        [250, 10, 15],
+        [20, 255, 0],
+        [31, 255, 0],
+        [255, 31, 0],
+        [255, 224, 0],
+        [153, 255, 0],
+        [0, 0, 255],
+        [255, 71, 0],
+        [0, 235, 255],
+        [0, 173, 255],
+        [31, 0, 255],
+        [11, 200, 200],
+        [255, 82, 0],
+        [0, 255, 245],
+        [0, 61, 255],
+        [0, 255, 112],
+        [0, 255, 133],
+        [255, 0, 0],
+        [255, 163, 0],
+        [255, 102, 0],
+        [194, 255, 0],
+        [0, 143, 255],
+        [51, 255, 0],
+        [0, 82, 255],
+        [0, 255, 41],
+        [0, 255, 173],
+        [10, 0, 255],
+        [173, 255, 0],
+        [0, 255, 153],
+        [255, 92, 0],
+        [255, 0, 255],
+        [255, 0, 245],
+        [255, 0, 102],
+        [255, 173, 0],
+        [255, 0, 20],
+        [255, 184, 184],
+        [0, 31, 255],
+        [0, 255, 61],
+        [0, 71, 255],
+        [255, 0, 204],
+        [0, 255, 194],
+        [0, 255, 82],
+        [0, 10, 255],
+        [0, 112, 255],
+        [51, 0, 255],
+        [0, 194, 255],
+        [0, 122, 255],
+        [0, 255, 163],
+        [255, 153, 0],
+        [0, 255, 10],
+        [255, 112, 0],
+        [143, 255, 0],
+        [82, 0, 255],
+        [163, 255, 0],
+        [255, 235, 0],
+        [8, 184, 170],
+        [133, 0, 255],
+        [0, 255, 92],
+        [184, 0, 255],
+        [255, 0, 31],
+        [0, 184, 255],
+        [0, 214, 255],
+        [255, 0, 112],
+        [92, 255, 0],
+        [0, 224, 255],
+        [112, 224, 255],
+        [70, 184, 160],
+        [163, 0, 255],
+        [153, 0, 255],
+        [71, 255, 0],
+        [255, 0, 163],
+        [255, 204, 0],
+        [255, 0, 143],
+        [0, 255, 235],
+        [133, 255, 0],
+        [255, 0, 235],
+        [245, 0, 255],
+        [255, 0, 122],
+        [255, 245, 0],
+        [10, 190, 212],
+        [214, 255, 0],
+        [0, 204, 255],
+        [20, 0, 255],
+        [255, 255, 0],
+        [0, 153, 255],
+        [0, 41, 255],
+        [0, 255, 204],
+        [41, 0, 255],
+        [41, 255, 0],
+        [173, 0, 255],
+        [0, 245, 255],
+        [71, 0, 255],
+        [122, 0, 255],
+        [0, 255, 184],
+        [0, 92, 255],
+        [184, 255, 0],
+        [0, 133, 255],
+        [255, 214, 0],
+        [25, 194, 194],
+        [102, 255, 0],
+        [92, 0, 255],
+    ]
+
+def label_to_color_image(label, colormap):
+    if label.ndim != 2:
+        raise ValueError("Expect 2-D input label")
+
+    if np.max(label) >= len(colormap):
+        raise ValueError("label value too large.")
+
+    return colormap[label]
+
+labels_list = []
+
+with open(r'labels.txt', 'r') as fp:
+    for line in fp:
+        labels_list.append(line[:-1])
+
+colormap = np.asarray(ade_palette())
+LABEL_NAMES = np.asarray(labels_list)
+LABEL_TO_INDEX = {label: i for i, label in enumerate(labels_list)}
+FULL_LABEL_MAP = np.arange(len(LABEL_NAMES)).reshape(len(LABEL_NAMES), 1)
+FULL_COLOR_MAP = label_to_color_image(FULL_LABEL_MAP, colormap)
+FONT = ImageFont.truetype("Arial.ttf", 1000)
+
+def lift_black_value(image, lift_amount):
+    """
+    Increase the black values of an image by a specified amount.
+    
+    Parameters:
+        image (PIL.Image): The image to adjust.
+        lift_amount (int): The amount to increase the brightness of the darker pixels.
+        
+    Returns:
+        PIL.Image: The adjusted image with lifted black values.
+    """
+    # Ensure that we don't go out of the 0-255 range for any pixel value
+    def adjust_value(value):
+        return min(255, max(0, value + lift_amount))
+    
+    # Apply the point function to each channel
+    return image.point(adjust_value)
+
+torch.set_grad_enabled(False)
+
+DEVICE = 'cuda' if torch.cuda.is_available() else "cpu"
+# MIN_AREA_THRESHOLD = 0.01
+
+pipe = pipeline("image-segmentation", model="nvidia/segformer-b5-finetuned-ade-640-640")
+
+def segmentation_inference(
+        image_rgb_pil: Image.Image,
+        savepath: str
+):
+    outputs = pipe(image_rgb_pil, points_per_batch=32)
+    
+    for i, prediction in enumerate(outputs):
+        label = prediction['label']
+        if (label == "floor") | (label == "wall") | (label == "ceiling"): 
+            mask = prediction['mask']
+
+            ## Save mask
+            label_savepath = savepath + label + str(i) + '.png'
+            fill_image = Image.new("RGB", image_rgb_pil.size, color=(255,255,255))
+            cutout_image = Image.composite(image_rgb_pil, fill_image, mask)
+
+            # Crop mask
+            center, bbox_size = find_center_of_non_black_pixels(cutout_image)
+            if center is not None:
+                centered_image = create_centered_image(cutout_image, center, bbox_size)
+                centered_image.save(label_savepath)
+
+            ## Inspect masks
+            # inverted_mask = ImageChops.invert(mask)
+            # mask_adjusted = lift_black_value(inverted_mask, 100)
+            # color_index = LABEL_TO_INDEX[label]
+            # color = tuple(FULL_COLOR_MAP[color_index][0])
+            # fill_image = Image.new("RGB", image_rgb_pil.size, color=color)
+            # image_rgb_pil = Image.composite(image_rgb_pil, fill_image, mask_adjusted)
+
+    # Display the final image
+    # image_rgb_pil.show()
+
+def online_segmentation_inference(
+        image_rgb_pil: Image.Image
+):
+    outputs = pipe(image_rgb_pil, points_per_batch=32)
+    
+    # Create an image dictionary
+    image_dict = {"image": [], "label":[]}
+
+    for i, prediction in enumerate(outputs):
+        label = prediction['label']
+        if (label == "floor") | (label == "wall") | (label == "ceiling"): 
+            mask = prediction['mask']
+
+            fill_image = Image.new("RGB", image_rgb_pil.size, color=(255,255,255))
+            cutout_image = Image.composite(image_rgb_pil, fill_image, mask)
+
+            # Crop mask
+            center, bbox_size = find_center_of_non_black_pixels(cutout_image)
+            if center is not None:
+                centered_image = create_centered_image(cutout_image, center, bbox_size)
+
+                # Add image to image dictionary
+                image_dict["image"].append(centered_image)
+                image_dict["label"].append(label)
+
+    segmented_ds = datasets.Dataset.from_dict(image_dict).cast_column("image", datasets.Image())
+    return segmented_ds
+                

similarity_inference.py

@@ -0,0 +1,54 @@
+from image_helpers import convert_images_to_grayscale, crop_center_largest_contour, fetch_similar
+import datasets as ds
+import re
+import torchvision.transforms as T
+from transformers import AutoModel, AutoFeatureExtractor
+import torch
+import random
+
+def similarity_inference(directory):
+    convert_images_to_grayscale(directory)
+    crop_center_largest_contour(directory)
+
+    # define processing variables needed for embedding calculation
+    root_directory = "data/" #"C:/Users/josie/OneDrive - Chalmers/Documents/Speckle hackathon/data/"
+    model_ckpt = "nateraw/vit-base-beans" ## FIND DIFFERENT MODEL
+    candidate_subset_emb = ds.load_dataset("canadianjosieharrison/2024hackathonembeddingdb")['train']
+    extractor = AutoFeatureExtractor.from_pretrained(model_ckpt)
+    model = AutoModel.from_pretrained(model_ckpt)
+    transformation_chain = T.Compose(
+        [
+            # We first resize the input image to 256x256 and then we take center crop.
+            T.Resize(int((256 / 224) * extractor.size["height"])),
+            T.CenterCrop(extractor.size["height"]),
+            T.ToTensor(),
+            T.Normalize(mean=extractor.image_mean, std=extractor.image_std),
+        ])
+    device = "cuda" if torch.cuda.is_available() else "cpu"
+    pt_directory = root_directory + "embedding_db.pt" #"materials/embedding_db.pt"
+    all_candidate_embeddings = torch.load(pt_directory, map_location=device, weights_only=True)
+    candidate_ids = []
+    for id in range(len(candidate_subset_emb)):
+        # Create a unique indentifier.
+        entry = str(id) + "_" + str(random.random()).split('.')[1]
+        candidate_ids.append(entry)
+
+    # load all components
+    test_ds = ds.load_dataset("imagefolder", data_dir=directory)
+    label_filenames = ds.load_dataset("imagefolder", data_dir=directory).cast_column("image", ds.Image(decode=False))
+
+    # loop through each component and return top 3 most similar
+    match_dict = {"ceiling": [], "floor": [], "wall": []}
+    for i, each_component in enumerate(test_ds['train']):
+        query_image = each_component["image"]
+        component_label = label_filenames['train'][i]['image']['path'].split('_')[-1]
+        print(component_label)
+        match = re.search(r"([a-zA-Z]+)\d*\.png", component_label)
+        component_label = match.group(1)
+        sim_ids = fetch_similar(query_image, transformation_chain, device, model, all_candidate_embeddings, candidate_ids)
+        for each_match in sim_ids:
+            texture_filename = candidate_subset_emb[each_match]['filenames']
+            image_url = f'https://cdn.polyhaven.com/asset_img/thumbs/{texture_filename}?width=256&height=256'
+            match_dict[component_label].append(image_url)
+
+    return match_dict