Some Issue

[icsl-Jeon]

import numpy as np
from PIL import Image

def expand_box_until_condition(image, initial_box, allowed_values):
    """
    Expand a box in an image until a condition is met.

    Parameters:
    image (numpy.ndarray): The image as a NumPy array.
    initial_box (tuple): The initial box (x_min, y_min, x_max, y_max).
    allowed_values (list): List of allowed pixel values.

    Returns:
    tuple: The expanded box coordinates (x_min, y_min, x_max, y_max).
    """
    x_min, y_min, x_max, y_max = initial_box
    height, width = image.shape

    # Expand the box
    while True:
        # Check if we hit the image boundary
        if x_min <= 0 and y_min <= 0 and x_max >= width and y_max >= height:
            break

        # Check each side and expand if the condition is not met
        condition_met = False

        if x_min > 0 and not np.isin(image[y_min:y_max, x_min - 1], allowed_values).any():
            condition_met = True
        elif x_max < width and not np.isin(image[y_min:y_max, x_max], allowed_values).any():
            condition_met = True
        elif y_min > 0 and not np.isin(image[y_min - 1, x_min:x_max], allowed_values).any():
            condition_met = True
        elif y_max < height and not np.isin(image[y_max, x_min:x_max], allowed_values).any():
            condition_met = True

        if condition_met:
            break

        # Expand the box
        x_min = max(x_min - 1, 0)
        y_min = max(y_min - 1, 0)
        x_max = min(x_max + 1, width)
        y_max = min(y_max + 1, height)

    return (x_min, y_min, x_max, y_max)

# Example usage
image = np.array(Image.open('path_to_your_image.jpg').convert('L'))  # Convert to grayscale
initial_box = (50, 50, 100, 100)  # Example initial box coordinates
allowed_pixel_values = [0, 255]  # Example list of allowed pixel values

expanded_box = expand_box_until_condition(image, initial_box, allowed_pixel_values)
print("Expanded box:", expanded_box)

[icsl-Jeon]

from PIL import Image

def collage_images_in_row(images):
    # Calculate total width and max height
    total_width = sum(img.width for img in images)
    max_height = max(img.height for img in images)

    # Create a new image with the total width and max height
    collage = Image.new('RGB', (total_width, max_height))

    # Paste images into the collage
    x_offset = 0
    for img in images:
        collage.paste(img, (x_offset, 0))
        x_offset += img.width

    return collage

# Example usage:
# images = [Image.open('path/to/image1.jpg'), Image.open('path/to/image2.jpg')]
# collage = collage_images_in_row(images)
# collage.show()

[icsl-Jeon]

from PIL import Image

def collage_images_in_column(images):
    # Calculate total height and max width
    total_height = sum(img.height for img in images)
    max_width = max(img.width for img in images)

    # Create a new image with the max width and total height
    collage = Image.new('RGB', (max_width, total_height))

    # Paste images into the collage
    y_offset = 0
    for img in images:
        collage.paste(img, (0, y_offset))
        y_offset += img.height

    return collage

# Example usage:
# images = [Image.open('path/to/image1.jpg'), Image.open('path/to/image2.jpg')]
# collage = collage_images_in_column(images)
# collage.show()

[icsl-Jeon]

def read_file(file_path): with open(file_path, 'r') as file: return file.readlines()

def write_differences(file1_lines, file2_lines, output_file_path): with open(output_file_path, 'w') as file: for line in set(file1_lines).symmetric_difference(set(file2_lines)): file.write(line)

Paths to your files

file1_path = 'path/to/your/first_file.txt' file2_path = 'path/to/your/second_file.txt' output_file_path = 'path/to/your/differences_file.txt'

Read files

file1_lines = read_file(file1_path) file2_lines = read_file(file2_path)

Write differences

write_differences(file1_lines, file2_lines, output_file_path)

[icsl-Jeon]

import random

def get_random_region(box_width, box_height):

Select a random point inside the box

random_point = (random.uniform(0, box_width), random.uniform(0, box_height))

# The four regions are defined by the point
# Upper Left, Upper Right, Lower Left, Lower Right
regions = {
    "Upper Left": (0, random_point[0], random_point[1], box_height),
    "Upper Right": (random_point[0], box_width, random_point[1], box_height),
    "Lower Left": (0, random_point[0], 0, random_point[1]),
    "Lower Right": (random_point[0], box_width, 0, random_point[1])
}

# Randomly select one of the four regions
selected_region = random.choice(list(regions.values()))

return selected_region

Example usage

box_width = 10 box_height = 5 selected_region = get_random_region(box_width, box_height) print(f"Selected region coordinates (x1, x2, y1, y2): {selected_region}")

[icsl-Jeon]

!/bin/bash

Specify the directory to search in and the size limit (in kilobytes)

search_dir="/path/to/search" size_limit=1000 # Size limit in kilobytes

Find directories smaller than the specified size limit

find "$search_dir" -type d -exec du -sk {} + | while read size dir; do if [ $size -le $size_limit ]; then echo "Removing $dir of size $size KB" rm -rf "$dir" fi done

[icsl-Jeon]

!/bin/bash

directory="/path/to/your/directory"

Initialize an empty array

file_list=()

Use find to get file names and add them to the array

while IFS= read -r -d '' file; do file_list+=("$file") done < <(find "$directory" -type f -print0)

Now file_list contains all the files

You can iterate over file_list to access each file

for file in "${file_list[@]}"; do echo "$file" done

[icsl-Jeon]

!/bin/bash

directory="/path/to/your/directory"

Initialize an empty array

file_list=()

Use find to get file names and add them to the array

while IFS= read -r -d '' file; do file_list+=("$file") done < <(find "$directory" -type f -print0)

Sort the file list

IFS=$'\n' sorted_file_list=($(sort <<< "${file_list[*]}")) unset IFS

Now sorted_file_list contains all the files in sorted order

You can iterate over sorted_file_list to access each file

for file in "${sorted_file_list[@]}"; do echo "$file" done

[icsl-Jeon]

alias attachbfjeon='screen -r $(screen -ls | grep "bf.jeon" | awk '\''{print $1}'\'')'

[icsl-Jeon]

import cv2
import math

def create_collage(images, images_per_row):
  """
  Creates a collage image from a list of images.

  Args:
      images: A list of OpenCV image objects.
      images_per_row: The number of images per row in the collage.

  Returns:
      A new OpenCV image object representing the collage.
  """

  total_images = len(images)
  number_of_rows = math.ceil(total_images / images_per_row)

  # Get image dimensions (assuming all images have the same size)
  image_width, image_height = images[0].shape[:2]

  # Calculate collage dimensions
  collage_width = images_per_row * image_width
  collage_height = number_of_rows * image_height

  # Create a new image for the collage
  collage = cv2.createMat(collage_height, collage_width, cv2.CV_8UC3)
  collage.fill(255)  # Fill with white background

  # Place images in the collage
  i = 0
  for image in images:
    row_index = int(i / images_per_row)
    col_index = i % images_per_row
    x_position = col_index * image_width
    y_position = row_index * image_height

    collage[y_position:y_position + image_height, x_position:x_position + image_width] = image
    i += 1

  return collage

# Example usage
images = [cv2.imread("image1.jpg"), cv2.imread("image2.jpg"), cv2.imread("image3.jpg")]
images_per_row = 2

collage = create_collage(images, images_per_row)

# Save the collage image
cv2.imwrite("collage.jpg", collage)

cv2.imshow("Collage", collage)
cv2.waitKey(0)
cv2.destroyAllWindows()

[icsl-Jeon]

from PIL import Image

def create_collage(images, images_per_row):
  """
  Creates a collage image from a list of PIL image objects.

  Args:
      images: A list of PIL image objects.
      images_per_row: The number of images per row in the collage.

  Returns:
      A new PIL image object representing the collage.
  """

  total_images = len(images)
  number_of_rows = math.ceil(total_images / images_per_row)

  # Get image dimensions (assuming all images have the same size)
  image_width, image_height = images[0].size

  # Calculate collage dimensions
  collage_width = images_per_row * image_width
  collage_height = number_of_rows * image_height

  # Create a new image for the collage
  collage = Image.new('RGB', (collage_width, collage_height))

  # Place images in the collage
  i = 0
  for image in images:
    row_index = int(i / images_per_row)
    col_index = i % images_per_row
    x_position = col_index * image_width
    y_position = row_index * image_height

    collage.paste(image, (x_position, y_position))
    i += 1

  return collage

# Example usage
images = [Image.open("image1.jpg"), Image.open("image2.jpg"), Image.open("image3.jpg")]
images_per_row = 2

collage = create_collage(images, images_per_row)

# Save the collage image
collage.save("collage.jpg")

collage.show()

[icsl-Jeon]

import numpy as np

def create_spherical_structure(radius): """Create a 2D spherical (circular) structuring element with the given radius.""" diameter = 2 * radius + 1 x, y = np.indices((diameter, diameter)) distance = np.sqrt((x - radius)2 + (y - radius)2) return (distance <= radius).astype(int)

Example usage

radius = 2 structuring_element = create_spherical_structure(radius)

print(structuring_element)

[icsl-Jeon]

'''

ssh username@remote_host "echo 'alias attachtobf=\"screen -r \\$(screen -ls | grep \\"bf.jeon\\" | awk ''\''{print \\$1}'\''}'\"' >> ~/.bashrc"

'''

[icsl-Jeon]

ssh username@remote_host "echo 'alias attachtobf=\"screen_id=\\$(screen -ls | grep \\"bf.jeon\\" | awk \\"{print \\\\$1}\\" \); screen -r \\$screen_id\"' >> ~/.bashrc"

[icsl-Jeon]

from PIL import Image

def create_focused_image(image_path, pw, ph):

Load the image

image = Image.open(image_path)
W, H = image.size

# Calculate coordinates of the rectangle
left = W * pw
right = W * (1 - pw)
top = H * ph
bottom = H * (1 - ph)

# Create a black image of the same size
black_image = Image.new('RGBA', (W, H), (0, 0, 0, 255))

# Extract the desired rectangle from the original image
box = (int(left), int(top), int(right), int(bottom))
region = image.crop(box)

# Paste the region back onto the black image
black_image.paste(region, box)

# Optionally save or show the image
black_image.show()
# black_image.save('output_image.png')

Example usage

create_focused_image('path_to_your_image.jpg', 0.2, 0.2)

[icsl-Jeon]

from PIL import Image

# Load the RGB image
rgb_image = Image.open('rgb_image_path.jpg')  # Replace with your RGB image path

# Load the binary mask image
mask_image = Image.open('mask_image_path.jpg')  # Replace with your mask image path

# Convert the mask image to 'L' mode (grayscale)
mask_image = mask_image.convert('L')

# Create an RGBA version of the RGB image
rgba_image = rgb_image.convert('RGBA')

# Prepare the overlay mask with a color and transparency
# (0, 255, 0) is green, change it to your preferred overlay color
overlay_mask = Image.new('RGBA', rgba_image.size, (0, 255, 0, 0)) 
for x in range(rgba_image.width):
    for y in range(rgba_image.height):
        if mask_image.getpixel((x, y)) > 0:  # Mask pixel is not black
            overlay_mask.putpixel((x, y), (0, 255, 0, 128))  # Semi-transparent green

# Composite the images
combined = Image.alpha_composite(rgba_image, overlay_mask)

# Save or show the image
combined.save('combined_image.png')  # Save the combined image
# combined.show()  # Or display the combined image

[icsl-Jeon]

[icsl-Jeon]

Inpainting and outpainting has been one of the essential tasks for image editing, where users mask a spatial region and get the filled with plausible and coherent contents.

Generative Adversarial Networks (GANs) have approached this task by learning to fill masked regions, but the "regression-to-mean" limitation often results in blurry and non-diverse image generation.

Recently, diffusion-based inpainting has demonstrated more promising outcomes by producing images that are both diverse and realistic. Utilizing a text-conditioned inpainting framework, users can direct the content generation for each masked region.

However, this approach presents two challenges. First, it requires users to supply prompts for inpainting, which demands proficiency and an in-depth understanding of how the network functions. Second, the integration of a text encoder might not be feasible for on-device applications due to severe memory limitations.

This paper explores the delicate balance between enhancing controllability and minimizing computational demands and user expertise requirements.

In our framework, we train two distinct prompts: one to generate plausible objects within a designated mask, and another to fill the region with background elements. During the inference stage, these learned embeddings serve as conditions for a diffusion network that operates without a text encoder.

By modifying the relative significance of the two prompts and employing classifier-free guidance, users can adjust the intensity of removal, which effectively addresses the primary challenge of inpainting—filling empty spaces.

Furthermore, we introduce a method to spatially vary the intensity of guidance by assigning different scales to individual pixels. This enhancement enriches the editing process by eliminating the need for multiple inferences to achieve varied intensities.

[icsl-Jeon]

from transformers import BlipProcessor, BlipForConditionalGeneration
from PIL import Image
import requests

def load_image(image_url):
    """Load an image from a URL."""
    response = requests.get(image_url)
    image = Image.open(response.raw).convert("RGB")
    return image

def generate_caption(image_url):
    """Generate a caption for an image using the BLIP model."""
    # Load the image
    image = load_image(image_url)

    # Initialize the processor and model
    processor = BlipProcessor.from_pretrained("Salesforce/blip-image-captioning-base")
    model = BlipForConditionalGeneration.from_pretrained("Salesforce/blip-image-captioning-base")

    # Prepare the inputs
    inputs = processor(image, return_tensors="pt")

    # Generate captions
    output_ids = model.generate(**inputs, max_length=20, num_beams=3)
    caption = processor.decode(output_ids[0], skip_special_tokens=True)
    return caption

# Example usage:
image_url = "https://example.com/image.jpg"  # Replace with your image URL
caption = generate_caption(image_url)
print("Generated Caption:", caption)

[icsl-Jeon]

from transformers import BlipProcessor, BlipForConditionalGeneration
from accelerate import Accelerator
from PIL import Image
import os
import torch

def load_images_from_folder(folder_path, batch_size):
    """Load images in batches from the specified folder."""
    images, image_paths = [], []
    for img_name in os.listdir(folder_path):
        if img_name.lower().endswith(('.png', '.jpg', '.jpeg')):
            image_path = os.path.join(folder_path, img_name)
            images.append(Image.open(image_path).convert("RGB"))
            image_paths.append(image_path)
            if len(images) == batch_size:
                yield images, image_paths
                images, image_paths = []
    if images:
        yield images, image_paths

def generate_captions(folder_path, batch_size):
    """Generate captions for all images in the specified folder."""
    # Initialize the processor, model, and accelerator
    accelerator = Accelerator()
    processor = BlipProcessor.from_pretrained("Salesforce/blip-image-captioning-base")
    model = BlipForConditionalGeneration.from_pretrained("Salesforce/blip-image-captioning-base").to(accelerator.device)
    model = accelerator.prepare(model)

    # Process images in batches
    for images, image_paths in load_images_from_folder(folder_path, batch_size):
        inputs = processor(images, return_tensors="pt", padding=True).to(accelerator.device)
        output_ids = accelerator.unwrap_model(model).generate(**inputs, max_length=20, num_beams=3)
        captions = [processor.decode(ids, skip_special_tokens=True) for ids in output_ids]

        # Save captions to corresponding text files
        for img_path, caption in zip(image_paths, captions):
            base_name = os.path.splitext(os.path.basename(img_path))[0]
            with open(f"{os.path.dirname(img_path)}/{base_name}.txt", "w") as file:
                file.write(caption)

# Specify the folder path and batch size
folder_path = '/path/to/image/folder'  # Update this to your folder path
batch_size = 32  # Adjust the batch size according to your GPU capacity

# Generate captions
generate_captions(folder_path, batch_size)

[icsl-Jeon]

import os
from PIL import Image
from transformers import AutoModelForImageClassification, AutoFeatureExtractor
from accelerate import Accelerator
from tqdm import tqdm

def load_images_from_folder(folder_path):
    """Load images from the specified folder."""
    for img_name in os.listdir(folder_path):
        if img_name.lower().endswith(('.png', '.jpg', '.jpeg')):
            image_path = os.path.join(folder_path, img_name)
            image = Image.open(image_path).convert("RGB")
            yield img_name, image

def detect_nsfw(folder_path):
    """Detect NSFW content in images from the specified folder."""
    # Initialize the accelerator
    accelerator = Accelerator()

    # Load the model and feature extractor
    model_id = "mrm8488/ViT-clip-ViT-B-16-nsfw-detection"
    feature_extractor = AutoFeatureExtractor.from_pretrained(model_id)
    model = AutoModelForImageClassification.from_pretrained(model_id).to(accelerator.device)
    model = accelerator.prepare(model)

    # Process images in the folder
    for img_name, image in tqdm(load_images_from_folder(folder_path), desc="Processing Images"):
        # Preprocess the image
        inputs = feature_extractor(images=image, return_tensors="pt").to(accelerator.device)

        # Predict NSFW content
        outputs = accelerator.unwrap_model(model)(**inputs)
        prediction = outputs.logits.softmax(dim=-1)
        nsfw_score = prediction[:, 1].item()  # Index 1 for NSFW class

        # Output result
        print(f"{img_name}: {'NSFW' if nsfw_score > 0.5 else 'Safe'} (Score: {nsfw_score:.4f})")

folder_path = '/path/to/image/folder'  # Update this to your actual image folder path
detect_nsfw(folder_path)

[icsl-Jeon]

import tarfile
import numpy as np
from PIL import Image
import io

# Function to add a string to a tar file using an in-memory file
def add_string_to_tar(tar, name, data):
    with io.BytesIO(data.encode('utf-8')) as file_obj:
        tarinfo = tarfile.TarInfo(name=name)
        tarinfo.size = len(file_obj.getvalue())
        tar.addfile(tarinfo, file_obj)

# Function to add a numpy image to a tar file using an in-memory file
def add_numpy_image_to_tar(tar, name, image_array):
    image = Image.fromarray(image_array)
    with io.BytesIO() as img_buf:
        image.save(img_buf, format='PNG')
        img_buf.seek(0)
        tarinfo = tarfile.TarInfo(name=name)
        tarinfo.size = len(img_buf.getvalue())
        tar.addfile(tarinfo, img_buf)

# Open a new tar file for writing
with tarfile.open('example.tar', 'w') as tar:
    # Example string data
    example_string = "This is an example string for xxx.id"
    add_string_to_tar(tar, 'xxx.id', example_string)

    # Example numpy image (rgb)
    example_rgb = np.random.randint(0, 255, (100, 100, 3), dtype=np.uint8)
    add_numpy_image_to_tar(tar, 'xxx.rgb', example_rgb)

    # Example list of numpy images (fg_masks)
    example_fg_masks = [np.random.randint(0, 255, (100, 100, 3), dtype=np.uint8) for _ in range(5)]
    for idx, img in enumerate(example_fg_masks):
        add_numpy_image_to_tar(tar, f'xxx.fg_masks_{idx}.png', img)

    # Example gt_rgb image
    example_gt_rgb = np.random.randint(0, 255, (100, 100, 3), dtype=np.uint8)
    add_numpy_image_to_tar(tar, 'xxx.gt_rgb', example_gt_rgb)

[icsl-Jeon]

import subprocess

# Define the list of commands you want to run
commands = [
    ['python', 'first_script.py', 'arg1', 'arg2'],
    ['python', 'second_script.py', '--option', 'value'],
    ['python', 'third_script.py']
]

# Loop over the commands and run them one by one
for command in commands:
    try:
        # Run each command, capturing output and checking for errors
        result = subprocess.run(command, check=True, text=True, capture_output=True)
        print(f'Command {" ".join(command)} completed successfully.')
        print('Output:', result.stdout)
        print('Errors:', result.stderr)
    except subprocess.CalledProcessError as e:
        print(f'Error occurred while running command {" ".join(command)}:')
        print(e)

[icsl-Jeon]

import random
from PIL import Image, ImageEnhance, ImageOps

def random_augment(rgb_image, mask_image):
    # Convert to Pillow Image if not already (assuming input as PIL Images)
    rgb_image = Image.fromarray(rgb_image) if not isinstance(rgb_image, Image.Image) else rgb_image
    mask_image = Image.fromarray(mask_image) if not isinstance(mask_image, Image.Image) else mask_image

    # Original dimensions
    original_width, original_height = rgb_image.size

    # List of augmentations
    augmentations = [
        "flip_horizontal",
        "flip_vertical",
        "contrast",
        "color",
        "brightness",
        "grayscale",
        "random_crop"
    ]

    # Select a random augmentation
    augmentation = random.choice(augmentations)

    if augmentation == "flip_horizontal":
        rgb_image = ImageOps.mirror(rgb_image)
        mask_image = ImageOps.mirror(mask_image)
    elif augmentation == "flip_vertical":
        rgb_image = ImageOps.flip(rgb_image)
        mask_image = ImageOps.flip(mask_image)
    elif augmentation == "contrast":
        enhancer = ImageEnhance.Contrast(rgb_image)
        rgb_image = enhancer.enhance(2)  # Increase contrast
    elif augmentation == "color":
        enhancer = ImageEnhance.Color(rgb_image)
        rgb_image = enhancer.enhance(0.5)  # Adjust color balance
    elif augmentation == "brightness":
        enhancer = ImageEnhance.Brightness(rgb_image)
        rgb_image = enhancer.enhance(1.5)  # Brighten the image
    elif augmentation == "grayscale":
        rgb_image = ImageOps.grayscale(rgb_image)
        # Mask remains the same, assuming it is already grayscale or binary
    elif augmentation == "random_crop":
        # Crop dimensions
        crop_size = (original_width - 100, original_height - 100)  # Crop dimensions
        # Random position for the crop
        left = random.randint(0, 100)
        top = random.randint(0, 100)
        right = left + crop_size[0]
        bottom = top + crop_size[1]

        # Crop the images
        rgb_image = rgb_image.crop((left, top, right, bottom))
        mask_image = mask_image.crop((left, top, right, bottom))

        # Resize back to original dimensions
        rgb_image = rgb_image.resize((original_width, original_height), Image.LANCZOS)
        mask_image = mask_image.resize((original_width, original_height), Image.LANCZOS)

    return rgb_image, mask_image

# Example usage
if __name__ == "__main__":
    # Load an example RGB image and a mask image
    rgb_image = Image.open("path/to/your/rgb_image.jpg").convert("RGB")
    mask_image = Image.open("path/to/your/mask_image.png").convert("L")  # Assuming mask is grayscale

    # Perform random augmentation
    augmented_rgb, augmented_mask = random_augment(rgb_image, mask_image)

    # Display the augmented images
    augmented_rgb.show()
    augmented_mask.show()

[icsl-Jeon]

#!/bin/bash

# Specify the directory to check
directory="/path/to/directory"

# Check if the directory exists
if [ -d "$directory" ]; then
    echo "Directory exists: $directory"
else
    echo "Directory does not exist: $directory"
fi

[icsl-Jeon]

import numpy as np
from scipy.ndimage import convolve
from skimage.transform import resize

def find_neighbors(binary_matrix, downsample_size=None):
    # Optionally downsample the binary matrix for faster processing
    if downsample_size is not None:
        binary_matrix = resize(binary_matrix, downsample_size, order=0, preserve_range=True).astype(int)

    # Define a convolution kernel that identifies the 8-connectivity neighbors
    kernel = np.array([[1, 1, 1],
                       [1, 0, 1],
                       [1, 1, 1]])

    # Apply convolution to find all places with at least one neighbor
    neighbors = convolve(binary_matrix, kernel, mode='constant', cval=0)

    # Now neighbors will contain counts of neighboring '1's, but we want only where the original was 0
    neighbor_pixels = (neighbors > 0) & (binary_matrix == 0)

    # Get the indices of these neighbor pixels
    rows, cols = np.where(neighbor_pixels)
    return rows, cols

# Example usage:
binary_matrix = np.array([[0, 0, 1, 0],
                          [0, 1, 1, 1],
                          [1, 0, 0, 1],
                          [0, 0, 0, 0]])

# Example: downsample the matrix to a smaller size if needed (uncomment to use)
# rows, cols = find_neighbors(binary_matrix, downsample_size=(2, 2))

# No downsampling
rows, cols = find_neighbors(binary_matrix)

print("Neighbor pixel indices (rows, cols):")
for r, c in zip(rows, cols):
    print(r, c)

[icsl-Jeon]

import numpy as np

def indices_within_circle(array_shape, center, radius):
    # Extract the dimensions
    rows, cols = array_shape

    # Unpack the center coordinates
    center_row, center_col = center

    # Calculate the bounding box of the circle
    min_row = max(0, center_row - radius)
    max_row = min(rows, center_row + radius + 1)
    min_col = max(0, center_col - radius)
    max_col = min(cols, center_col + radius + 1)

    # Prepare output lists for row and column indices
    circle_rows = []
    circle_cols = []

    # Iterate only over the bounding box of the circle
    for row in range(min_row, max_row):
        for col in range(min_col, max_col):
            # Calculate the Euclidean distance from the center
            if (row - center_row)**2 + (col - center_col)**2 <= radius**2:
                circle_rows.append(row)
                circle_cols.append(col)

    return circle_rows, circle_cols

# Example usage
array_shape = (10, 10)  # Shape of the numpy array
center = (5, 5)         # Center of the circle
radius = 3              # Radius of the circle

# Get the row and column indices
rows, cols = indices_within_circle(array_shape, center, radius)

# Print results
print("Row indices:", rows)
print("Column indices:", cols)

[icsl-Jeon]

from PIL import Image
import numpy as np

def degrade_image(image_path, downscale_factor):
    # Load the image
    image = Image.open(image_path)
    image = image.convert('1')  # Ensure it's binary

    # Original dimensions
    original_size = image.size

    # Calculate new dimensions
    new_size = (int(original_size[0] / downscale_factor), int(original_size[1] / downscale_factor))

    # Downsample the image
    downsampled_image = image.resize(new_size, Image.NEAREST)

    # Upsample the image back to original size
    upsampled_image = downsampled_image.resize(original_size, Image.NEAREST)

    return upsampled_image

# Example usage
image_path = 'path_to_your_binary_image.png'
downscale_factor = 4  # Adjust based on how much degradation is desired

degraded_image = deg

[icsl-Jeon]

import numpy as np
from PIL import Image

def find_mask_center(mask):
    """ Find the centroid of the binary mask. """
    indices = np.where(mask == 1)
    center_y = int(np.mean(indices[0]))  # Mean of rows
    center_x = int(np.mean(indices[1]))  # Mean of columns
    return center_x, center_y

def compute_crop_bounds(center, img_dim, crop_dim, margin_ratio):
    """ Compute the bounds for cropping the image. """
    cx, cy = center
    w, h = img_dim
    wc, hc = crop_dim

    # Compute margin offsets
    margin_x = int(wc * margin_ratio)
    margin_y = int(hc * margin_ratio)

    # Determine the crop bounds ensuring the center is within the specified margin_ratio window
    left = max(min(cx - wc // 2, w - wc), 0)
    right = left + wc
    top = max(min(cy - hc // 2, h - hc), 0)
    bottom = top + hc

    # Adjust to keep within bounds
    left = max(min(left, w - wc), 0)
    top = max(min(top, h - hc), 0)

    return (left, top, right, bottom)

def crop_image(image_path, crop_dim, margin_ratio=0.2):
    """ Crop the image to include the center of the mask within a specified window. """
    # Load image and convert to binary array
    image = Image.open(image_path)
    mask = np.array(image) > 128  # Assume mask is binary based on a threshold

    # Find the center of the mask
    center = find_mask_center(mask)

    # Image dimensions
    img_dim = image.size

    # Compute crop bounds
    bounds = compute_crop_bounds(center, img_dim, crop_dim, margin_ratio)

    # Crop the image
    cropped_image = image.crop(bounds)
    return cropped_image

# Example usage
image_path = 'path_to_your_mask_image.png'
crop_dim = (500, 500)  # Desired dimensions of the crop
cropped_image = crop_image(image_path, crop_dim)
cropped_image.show()

[icsl-Jeon]

def compute_crop_bounds(center, img_dim, crop_dim, margin_ratio):
    """ Compute the bounds for cropping the image. """
    cx, cy = center
    img_width, img_height = img_dim
    crop_width, crop_height = crop_dim

    # Calculate the margin offsets within the crop dimensions
    margin_x = int(crop_width * margin_ratio)
    margin_y = int(crop_height * margin_ratio)

    # Calculate the central region within the crop where the mask center should ideally reside
    min_x = cx - crop_width // 2 + margin_x
    max_x = cx - crop_width // 2 + crop_width - margin_x
    min_y = cy - crop_height // 2 + margin_y
    max_y = cy - crop_height // 2 + crop_height - margin_y

    # Constrain these bounds to be within the image dimensions
    left = max(min(min_x, img_width - crop_width), 0)
    top = max(min(min_y, img_height - crop_height), 0)
    right = min(left + crop_width, img_width)
    bottom = min(top + crop_height, img_height)

    return (left, top, right, bottom)

# Example usage in the context
# Assume we've already loaded an image and determined the crop_dim and mask center as before
# The parameters would be passed like this:
bounds = compute_crop_bounds(center, image.size, (500, 500), 0.2)
cropped_image = image.crop(bounds)

[icsl-Jeon]

# Hook function to capture the output
def hook_fn(module, input, output):
    global intermediate_output
    intermediate_output = output

# Register the hook on the middle block (you might need to adjust the layer path)
hook_handle = model.mid_block.register_forward_hook(hook_fn)

[icsl-Jeon]

kmeans = KMeans(n_clusters=config.num_mask, init=config.init_algo, n_init=config.n_init, random_state = config.k_means_seed, algorithm=config.kmeans_algo).fit(mask_fet.numpy())

[icsl-Jeon]

    init_algo = "k-means++"
    kmeans_algo = "lloyd"

[icsl-Jeon]

import numpy as np
import matplotlib.pyplot as plt
from sklearn.cluster import DBSCAN
from sklearn.datasets import make_blobs
# Perform DBSCAN clustering
dbscan = DBSCAN(eps=0.3, min_samples=10)
dbscan.fit(X)

# Get the labels assigned by DBSCAN
labels = dbscan.labels_

[icsl-Jeon]

The "missing host" error often encountered with SSHFS (SSH File System) typically indicates that the command is not correctly specifying the remote host or the remote path. Here are steps to resolve this issue:

Common Causes and Solutions:
Incorrect Command Syntax: Ensure that the command correctly specifies the remote path. The correct syntax for SSHFS should include a colon (:) between the host and the remote path.

Incorrect: sshfs uname@xxx.xxx.xxx.xxx ~/Net\ Drive/
Correct: sshfs uname@xxx.xxx.xxx.xxx:/absolute/path/to/Net\ Drive/
This syntax explicitly indicates the remote directory you are trying to mount.

Missing Host Header in HTTPS: If you're encountering a "missing host" error in an HTTPS context, it's often due to a missing Host header. The Host header is crucial for HTTP/1.1 requests to specify the intended hostname.

To fix this, ensure your HTTP requests include a Host header, especially when dealing with virtual hosts. For example:
plaintext
코드 복사
Host: www.example.com
If using tools like curl, you can specify the host header directly:
sh
코드 복사
curl -H "Host: www.example.com" https://xxx.xxx.xxx.xxx
Configuration Issues: If using a load balancer or proxy, ensure it’s correctly configured to pass the Host header to the backend server. Sometimes, intermediate devices may strip necessary headers.

Detailed Steps for SSHFS:
Command Example:
sh
코드 복사
sshfs uname@xxx.xxx.xxx.xxx:/path/to/remote/dir /path/to/local/mount
Additional Tips:
Check Server Configuration: Ensure your SSH server is configured correctly and that SSH access works independently of SSHFS.
Debugging: Use verbose mode in SSHFS for more detailed error messages:
sh
코드 복사
sshfs -o debug uname@xxx.xxx.xxx.xxx:/path/to/remote/dir /path/to/local/mount
Documentation and Community: Refer to SSHFS and SSH documentation for more configuration options, or check community forums and issue trackers for specific troubleshooting steps.
References:
Detailed discussions on SSHFS issues can be found on platforms like GitHub and ServerFault, where community members share their experiences and solutions​ ([GitHub](https://github.com/osxfuse/osxfuse/issues/576))​​ ([Server Fault](https://serverfault.com/questions/1060208/is-the-host-header-required-over-ssl))​​ ([Host4Geeks LLC](https://host4geeks.com/blog/how-to-fix-the-hsts-missing-from-https-server-error/))​.
These steps should help you troubleshoot and resolve the "missing host" error for both SSHFS and HTTPS contexts. If the issue persists, reviewing specific configuration settings or consulting detailed logs may provide further insights.

[icsl-Jeon]

from PIL import Image
import numpy as np

# Load the RGBA image
rgba_image = Image.open('path_to_your_rgba_image.png')

# Convert RGBA to RGB
rgb_image = rgba_image.convert('RGB')

# Extract the alpha channel
alpha_channel = rgba_image.split()[-1]

# Create a binary mask based on the alpha channel
# Mask regions where alpha is zero
binary_mask = np.array(alpha_channel) > 0

# Convert binary mask to image
binary_mask_image = Image.fromarray(binary_mask.astype(np.uint8) * 255)

# Save the RGB image and binary mask image
rgb_image.save('rgb_image.png')
binary_mask_image.save('binary_mask_image.png')

# Display the images (optional)
rgb_image.show()
binary_mask_image.show()

[icsl-Jeon]

import itertools
import random

# Define the attributes
View = ["side view", "front view", "back view", "top view", "bottom view", "three-quarter view", "profile view"]
Action = ["holding hands", "running", "sitting", "jumping", "standing", "walking", "dancing", "reading", "writing", "cooking", 
          "playing", "sleeping", "laughing", "crying", "talking", "singing", "climbing", "swimming", "driving", "shopping"]
Facial = ["smile", "angry", "surprised", "sad", "happy", "neutral", "confused", "excited", "bored", "fearful"]
Image_status = ["high contrast", "shiny", "blurry", "nature", "urban", "sunny", "rainy", "nighttime", "indoors", "outdoors"]

# Generate all combinations
combinations = list(itertools.product(View, Action, Facial, Image_status))

# Function to yield a prompt
def generate_prompt():
    random.shuffle(combinations)  # Shuffle to ensure random order
    for combination in combinations:
        view, action, facial, image_status = combination
        prompt = f"{view}, {action}, {facial} face, {image_status} background"
        yield prompt

# Example usage
if __name__ == "__main__":
    prompt_generator = generate_prompt()
    for _ in range(10):  # Generate 10 prompts as an example
        print(next(prompt_generator))

[icsl-Jeon]

import itertools
import random

# Define the attributes
View = ["side view", "front view", "back view", "top view", "bottom view", "three-quarter view", "profile view"]
Action = ["holding hands", "running", "sitting", "jumping", "standing", "walking", "dancing", "reading", "writing", "cooking", 
          "playing", "sleeping", "laughing", "crying", "talking", "singing", "climbing", "swimming", "driving", "shopping"]
Facial = ["smile", "angry", "surprised", "sad", "happy", "neutral", "confused", "excited", "bored", "fearful"]
Image_status = ["high contrast", "shiny", "blurry", "nature", "urban", "sunny", "rainy", "nighttime", "indoors", "outdoors"]

# Generate all combinations
combinations = list(itertools.product(View, Action, Facial, Image_status))

# Function to generate a specified number of prompts and write to a file
def generate_prompts_to_file(filename, num_prompts):
    random.shuffle(combinations)  # Shuffle to ensure random order
    prompts = []
    for combination in combinations[:num_prompts]:
        view, action, facial, image_status = combination
        prompt = f"{view}, {action}, {facial} face, {image_status} background"
        prompts.append(prompt)

    # Write prompts to a text file
    with open(filename, 'w') as file:
        for prompt in prompts:
            file.write(f"{prompt}\n")

# Example usage
if __name__ == "__main__":
    filename = 'prompts.txt'
    num_prompts = 20  # Specify the number of prompts you want to generate
    generate_prompts_to_file(filename, num_prompts)
    print(f"{num_prompts} prompts have been written to {filename}.")

[icsl-Jeon]

import torch
from torch.utils.data import Dataset, DataLoader

class PromptsDataset(Dataset):
    def __init__(self, file_path):
        self.prompts = self.load_prompts(file_path)

    def load_prompts(self, file_path):
        with open(file_path, 'r') as file:
            prompts = file.readlines()
        return [prompt.strip() for prompt in prompts]

    def __len__(self):
        return len(self.prompts)

    def __getitem__(self, idx):
        return self.prompts[idx]

def create_dataloader(file_path, batch_size):
    dataset = PromptsDataset(file_path)
    dataloader = DataLoader(dataset, batch_size=batch_size, shuffle=True)
    return dataloader

# Example usage
if __name__ == "__main__":
    file_path = 'prompts.txt'  # Path to your text file containing prompts
    batch_size = 4  # Define your batch size

    dataloader = create_dataloader(file_path, batch_size)

    # Iterate through the dataloader
    for batch in dataloader:
        print(batch)

import torch
from torch.utils.data import Dataset, DataLoader
import itertools

class IdsPromptsDataset(Dataset):
    def __init__(self, ids, prompts):
        self.ids = ids
        self.prompts = prompts
        self.total_combinations = len(ids) * len(prompts)

    def __len__(self):
        return self.total_combinations

    def __getitem__(self, idx):
        id_idx = idx % len(self.ids)
        prompt_idx = idx // len(self.ids)

        id = self.ids[id_idx]
        prompt = self.prompts[prompt_idx]

        return id, prompt

def create_dataloader(ids, prompts, batch_size):
    dataset = IdsPromptsDataset(ids, prompts)
    dataloader = DataLoader(dataset, batch_size=batch_size, shuffle=True)
    return dataloader

# Example usage
if __name__ == "__main__":
    # Generate 30,000 unique IDs and 100 unique prompts
    ids = [f"id_{i}" for i in range(30000)]
    prompts = [f"prompt_{j}" for j in range(100)]

    batch_size = 4  # Define your batch size

    dataloader = create_dataloader(ids, prompts, batch_size)

    # Iterate through the dataloader
    for batch in dataloader:
        print(batch)

[icsl-Jeon]

import torch
from torch.utils.data import Dataset, DataLoader
from PIL import Image
import cv2
import numpy as np

class IdsPromptsDataset(Dataset):
    def __init__(self, ids, prompts, image_paths):
        self.ids = ids
        self.prompts = prompts
        self.image_paths = image_paths
        self.total_combinations = len(ids) * len(prompts)

    def __len__(self):
        return self.total_combinations

    def __getitem__(self, idx):
        id_idx = idx % len(self.ids)
        prompt_idx = idx // len(self.ids)

        id = self.ids[id_idx]
        prompt = self.prompts[prompt_idx]

        # Load an image using OpenCV
        image_path = self.image_paths[id_idx]
        image = cv2.imread(image_path)

        return id, prompt, image

def custom_collate_fn(batch):
    ids, prompts, images = zip(*batch)
    return ids, prompts, images

def create_dataloader(ids, prompts, image_paths, batch_size):
    dataset = IdsPromptsDataset(ids, prompts, image_paths)
    dataloader = DataLoader(dataset, batch_size=batch_size, shuffle=True, collate_fn=custom_collate_fn)
    return dataloader

# Example usage
if __name__ == "__main__":
    # Generate 30,000 unique IDs and 100 unique prompts
    ids = [f"id_{i}" for i in range(30000)]
    prompts = [f"prompt_{j}" for j in range(100)]

    # Assuming you have a list of image paths
    image_paths = [f"path/to/image_{i % 30000}.jpg" for i in range(30000)]

    batch_size = 4  # Define your batch size

    dataloader = create_dataloader(ids, prompts, image_paths, batch_size)

    # Iterate through the dataloader
    for batch in dataloader:
        ids_batch, prompts_batch, images_batch = batch
        print(ids_batch)
        print(prompts_batch)
        for image in images_batch:
            cv2.imshow("Image", image)
            cv2.waitKey(0)
            cv2.destroyAllWindows()

[icsl-Jeon]

def count_parameters(model):
    return sum(p.numel() for p in model.parameters() if p.requires_grad)

[icsl-Jeon]

import numpy as np
from sklearn.cluster import DBSCAN
import matplotlib.pyplot as plt

# Example binary matrix
binary_matrix = np.array([
    [0, 1, 0, 0, 0],
    [0, 1, 0, 1, 1],
    [1, 0, 0, 0, 0],
    [0, 1, 1, 1, 0],
    [0, 0, 0, 1, 0]
])

# Extract coordinates of true elements
true_coords = np.column_stack(np.where(binary_matrix))

# Perform DBSCAN clustering
db = DBSCAN(eps=1.5, min_samples=2).fit(true_coords)
labels = db.labels_

# Plot the results
unique_labels = set(labels)
colors = [plt.cm.Spectral(each) for each in np.linspace(0, 1, len(unique_labels))]

plt.figure(figsize=(8, 6))
for k, col in zip(unique_labels, colors):
    if k == -1:
        # Black used for noise.
        col = [0, 0, 0, 1]

    class_member_mask = (labels == k)
    xy = true_coords[class_member_mask]

    plt.plot(xy[:, 1], xy[:, 0], 'o', markerfacecolor=tuple(col), markeredgecolor='k', markersize=10)

plt.title('DBSCAN Clustering of True Elements in Binary Matrix')
plt.xlabel('Column Index')
plt.ylabel('Row Index')
plt.gca().invert_yaxis()  # Invert y axis to match matrix indexing
plt.show()

[icsl-Jeon]

import matplotlib.pyplot as plt
from PIL import Image

def draw_boxes(image_path, boxes, thickness=2):
  """
  This function draws a PIL image, rectangles on the image for each box in the list,
  and displays the result.

  Args:
      image_path: Path to the PIL image file.
      boxes: A list of boxes, where each box is a list of four integers representing
          (row_min, row_max, col_min, col_max).
      thickness: Thickness of the rectangle borders (default: 2).
  """

  # Load the image
  image = Image.open(image_path).convert('RGB')

  # Get image dimensions for normalization
  width, height = image.size

  # Create a colormap for distinct colors based on the number of boxes
  cmap = plt.cm.get_cmap('tab20')
  colors = [cmap(i / len(boxes))[:3] for i in range(len(boxes))]  # Get RGB triplets

  # Convert image to a NumPy array for plotting with pyplot
  image_arr = plt.asarray(image)

  # Display the image
  plt.imshow(image_arr)

  # Draw rectangles for each box with its corresponding color
  for i, box in enumerate(boxes):
    # Normalize box coordinates (0 to 1) based on image dimensions
    normalized_box = [b / (d - 1) for b, d in zip(box, [height, height, width, width])]

    # Draw rectangle using normalized coordinates and color
    plt.plot(*normalized_box, color=colors[i], linewidth=thickness, fill=False)

  # Remove axis labels and ticks for a cleaner visualization
  plt.axis('off')
  plt.show()

# Example usage
image_path = "path/to/your/image.jpg"  # Replace with your image path
boxes = [[100, 150, 50, 100], [200, 250, 150, 200]]  # Example list of boxes

draw_boxes(image_path, boxes)

[icsl-Jeon]

Diffusion models (DMs) [7, 24] learn the data distribution by reversing a Markov noising process, gaining significant attention recently due to their stability and superior performance in image synthesis compared to GANs. Starting with a clean image 𝑥 0 x 0 ​ , the diffusion process sequentially adds noise at each step 𝑡 t, producing a series of noisy latents 𝑥 𝑡 x t ​ . The model is then trained to reconstruct the clean image 𝑥 0 x 0 ​ from 𝑥 𝑡 x t ​ in the reverse process. DMs have demonstrated impressive results in various tasks, such as unconditional image generation [7, 8, 25, 26], text-to-image generation [18–21], video generation [6], image inpainting [1,2,14,16], image translation [15,27,29], and image editing [4, 5, 10]

[icsl-Jeon]

from PIL import Image
import numpy as np
import cv2
import matplotlib.pyplot as plt

def load_image_and_mask(image_path, mask_path):
    # Load the image and mask using PIL
    image = Image.open(image_path).convert('RGB')
    mask = Image.open(mask_path).convert('L')

    # Convert to numpy arrays
    image_np = np.array(image)
    mask_np = np.array(mask)

    return image_np, mask_np

def get_boundary_pixels(mask, thickness):
    # Ensure the mask is binary (0 or 255)
    _, binary_mask = cv2.threshold(mask, 128, 255, cv2.THRESH_BINARY)

    # Perform the distance transform
    dist_transform = cv2.distanceTransform(binary_mask, cv2.DIST_L2, 5)

    # Create a mask for the boundary region with the given thickness
    boundary_mask = (dist_transform <= thickness) & (dist_transform > 0)

    return boundary_mask

def visualize_boundary(image, boundary_mask):
    # Create an overlay to visualize the boundary
    overlay = image.copy()
    overlay[boundary_mask] = [255, 0, 0]  # Red color for the boundary

    # Display the image with the boundary overlay
    plt.figure(figsize=(10, 10))
    plt.imshow(overlay)
    plt.title('Image with Boundary Overlay')
    plt.axis('off')
    plt.show()

# Example usage
image_path = 'path_to_image.jpg'
mask_path = 'path_to_mask.png'
thickness = 5

image, mask = load_image_and_mask(image_path, mask_path)
boundary_mask = get_boundary_pixels(mask, thickness)
visualize_boundary(image, boundary_mask)

[icsl-Jeon]

import numpy as np
import cv2
from PIL import Image
import matplotlib.pyplot as plt
from sklearn.cluster import DBSCAN

def load_image_and_mask(image_path, mask_path):
    # Load the image and mask using PIL
    image = Image.open(image_path).convert('RGB')
    mask = Image.open(mask_path).convert('L')

    # Convert to numpy arrays
    image_np = np.array(image)
    mask_np = np.array(mask)

    return image_np, mask_np

def get_boundary_pixels(mask, thickness):
    # Ensure the mask is binary (0 or 255)
    _, binary_mask = cv2.threshold(mask, 128, 255, cv2.THRESH_BINARY)

    # Invert the binary mask
    inverted_mask = cv2.bitwise_not(binary_mask)

    # Perform the distance transform on the inverted mask
    dist_transform = cv2.distanceTransform(inverted_mask, cv2.DIST_L2, 5)

    # Create a mask for the boundary region with the given thickness
    boundary_mask = (dist_transform <= thickness) & (dist_transform > 0)

    return boundary_mask

def segment_boundary_pixels_with_dbscan(image, boundary_mask, eps=0.3, min_samples=10):
    # Get the coordinates of the boundary pixels
    boundary_coords = np.column_stack(np.where(boundary_mask))

    # Get the color values of the boundary pixels
    boundary_colors = image[boundary_mask]

    # Combine color and spatial information
    features = np.hstack((boundary_colors, boundary_coords))

    # Normalize spatial information to the same range as color information
    features[:, 3] /= image.shape[1]  # Normalize x
    features[:, 4] /= image.shape[0]  # Normalize y

    # Apply DBSCAN clustering
    db = DBSCAN(eps=eps, min_samples=min_samples, metric='euclidean').fit(features)
    labels = db.labels_

    return labels, boundary_coords

def visualize_boundary_segmentation(image, boundary_coords, labels):
    # Create an output image with all pixels set to black
    segmented_image = np.zeros_like(image)

    # Map boundary pixels to their cluster colors
    unique_labels = np.unique(labels)
    for label in unique_labels:
        if label == -1:  # Noise
            color = [255, 255, 255]  # White color for noise
        else:
            color = np.random.randint(0, 255, 3)  # Random color for each cluster
        segmented_image[boundary_coords[labels == label, 0], boundary_coords[labels == label, 1]] = color

    # Display the segmented boundary pixels
    plt.figure(figsize=(10, 10))
    plt.imshow(segmented_image)
    plt.title('Segmented Boundary Pixels with DBSCAN')
    plt.axis('off')
    plt.show()

# Example usage
image_path = 'path_to_image.jpg'
mask_path = 'path_to_mask.png'
thickness = 5
eps = 0.3
min_samples = 10

# Load the image and mask
image, mask = load_image_and_mask(image_path, mask_path)

# Get the boundary pixels
boundary_mask = get_boundary_pixels(mask, thickness)

# Perform segmentation on the boundary pixels
labels, boundary_coords = segment_boundary_pixels_with_dbscan(image, boundary_mask, eps, min_samples)

# Visualize the segmentation result
visualize_boundary_segmentation(image, boundary_coords, labels)

[icsl-Jeon]

import numpy as np
import cv2
from PIL import Image
import matplotlib.pyplot as plt

def load_image(image_path):
    # Load the image using PIL
    image = Image.open(image_path).convert('RGB')

    # Convert to numpy array
    image_np = np.array(image)

    return image_np

def edge_detection_rgb(image, low_threshold=50, high_threshold=150):
    # Convert the image to grayscale
    gray_image = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY)

    # Apply Canny edge detector
    edges = cv2.Canny(gray_image, low_threshold, high_threshold)

    return edges

def visualize_edges(image, edges):
    # Create an overlay of the edges on the image
    overlay = image.copy()
    overlay[edges != 0] = [255, 0, 0]  # Red color for the edges

    # Display the image with the edges overlay
    plt.figure(figsize=(10, 10))
    plt.imshow(overlay)
    plt.title('Image with Edge Pixels Overlay')
    plt.axis('off')
    plt.show()

# Example usage
image_path = 'path_to_image.jpg'

# Load the image
image = load_image(image_path)

# Perform edge detection on the RGB image
edges = edge_detection_rgb(image)

# Visualize the edge pixels
visualize_edges(image, edges)

[icsl-Jeon]

import numpy as np
import cv2
from PIL import Image
import matplotlib.pyplot as plt
from sklearn.cluster import DBSCAN

def load_image(image_path):
    # Load the image using PIL
    image = Image.open(image_path).convert('RGB')

    # Convert to numpy array
    image_np = np.array(image)

    return image_np

def contour_detection(image):
    # Convert the image to grayscale
    gray_image = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY)

    # Apply a binary threshold to get a binary image
    _, binary_image = cv2.threshold(gray_image, 128, 255, cv2.THRESH_BINARY)

    # Detect contours
    contours, _ = cv2.findContours(binary_image, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)

    return contours

def cluster_contours(contours, eps=5, min_samples=5):
    # Collect all contour points
    contour_points = np.vstack(contours).squeeze()

    # Apply DBSCAN clustering
    db = DBSCAN(eps=eps, min_samples=min_samples).fit(contour_points)
    labels = db.labels_

    return labels, contour_points

def visualize_clustered_contours(image, labels, contour_points):
    # Create an output image with all pixels set to black
    clustered_image = np.zeros_like(image)

    # Map contour points to their cluster colors
    unique_labels = np.unique(labels)
    for label in unique_labels:
        if label == -1:  # Noise
            color = [255, 255, 255]  # White color for noise
        else:
            color = np.random.randint(0, 255, 3)  # Random color for each cluster
        clustered_image[contour_points[labels == label, 1], contour_points[labels == label, 0]] = color

    # Display the clustered contours
    plt.figure(figsize=(10, 10))
    plt.imshow(clustered_image)
    plt.title('Clustered Contour Points')
    plt.axis('off')
    plt.show()

# Example usage
image_path = 'path_to_image.jpg'

# Load the image
image = load_image(image_path)

# Perform contour detection
contours = contour_detection(image)

# Cluster the contour points
labels, contour_points = cluster_contours(contours)

# Visualize the clustered contour points
visualize_clustered_contours(image, labels, contour_points)

[icsl-Jeon]

def visualize_contours(image, contours):
    # Create an output image by copying the original image
    output_image = image.copy()

    # Draw the contours on the image
    cv2.drawContours(output_image, contours, -1, (0, 255, 0), 2)  # Green color for contours

    # Display the image with the contours
    plt.figure(figsize=(10, 10))
    plt.imshow(output_image)
    plt.title('Image with Contours')
    plt.axis('off')
    plt.show()

[icsl-Jeon]

def visualize_contours(image, contours):
    # Create an output image by copying the original image
    output_image = image.copy()

    # Draw each contour with a different color
    for contour in contours:
        color = np.random.randint(0, 255, size=3).tolist()  # Generate a random color
        cv2.drawContours(output_image, [contour], -1, color, 2)

    # Display the image with the contours
    plt.figure(figsize=(10, 10))
    plt.imshow(output_image)
    plt.title('Image with Colored Contours')
    plt.axis('off')
    plt.show()

[icsl-Jeon]

def overlay_binary_image(image, binary_image, thickness=3):
    # Ensure the binary image is binary
    _, binary_image = cv2.threshold(binary_image, 128, 255, cv2.THRESH_BINARY)

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

    # Create an output image by copying the original image
    output_image = image.copy()

    # Draw the contours on the original image with specified thickness
    cv2.drawContours(output_image, contours, -1, (0, 255, 0), thickness)  # Green color for contours

    return output_image