Extract and refactor diamond crop img2img procedure.

experiments/diamond-crop-img2img.py

@@ -0,0 +1,35 @@
+from utils import filenames, images, wallpaper, pipes
+
+prompt = "seamless pattern of parrots. black and white, drawing, white background, seamless, ornament."
+generation_dir = "./generations/diamond_crop_img2img"
+
+sdxl_pipe = pipes.create_stable_diffusion_xl_pipeline()
+
+original_image = sdxl_pipe(prompt=prompt, num_inference_steps=20).images[0]
+original_image_filename = filenames.generate_filename(f"{generation_dir}/originals", prompt)
+original_image.save(original_image_filename)
+print("generated image generated", original_image_filename)
+
+inner_rotated_tile = images.extract_inner_rotated_tile_from_image(original_image)
+inner_rotated_tile_filename = filenames.generate_filename(f"{generation_dir}/inner_rotated_tiles", prompt,
+                                                          "-inner-rotated")
+inner_rotated_tile.save(inner_rotated_tile_filename)
+print("generated inner rotated tile", inner_rotated_tile_filename)
+
+sdxl_img2img_pipe = pipes.create_stable_diffusion_xl_img2img_pipe()
+
+tileable_image = sdxl_img2img_pipe(prompt, image=inner_rotated_tile.convert("RGB"), num_inference_steps=20).images[0]
+tileable_image_filename = filenames.generate_filename(f"{generation_dir}/tiles", prompt, "-tile")
+tileable_image.save(tileable_image_filename)
+print("generated tileable image", tileable_image_filename)
+
+half_drop = wallpaper.convert_tile_to_half_drop(tileable_image)
+half_drop_filename = filenames.generate_filename(f"{generation_dir}//half_drops", prompt, "_half-drop-tile")
+half_drop.save(half_drop_filename)
+print("generated half drop tile", tileable_image_filename)
+
+half_drop_tiled = wallpaper.generate_tile_test_arrangement(half_drop)
+half_drop_tiled_filename = filenames.generate_filename(f"{generation_dir}/half_drop_demo", prompt,
+                                                       "_half-drop-demo")
+half_drop_tiled.save(half_drop_tiled_filename)
+print("generated half drop tiled image", tileable_image_filename)

utils/pipes.py

@@ -0,0 +1,24 @@
+import torch
+from diffusers import StableDiffusionXLImg2ImgPipeline, StableDiffusionXLPipeline
+
+from utils import tiling
+
+
+def create_stable_diffusion_xl_pipeline():
+    pipe = StableDiffusionXLPipeline.from_pretrained(
+        "stabilityai/stable-diffusion-xl-base-1.0", torch_dtype=torch.float16, variant="fp16", use_safetensors=True
+    )
+    pipe = pipe.to("mps")
+    pipe.vae.disable_tiling()
+    tiling.enable_circular_tiling([pipe.vae, pipe.text_encoder, pipe.unet])
+    return pipe
+
+
+def create_stable_diffusion_xl_img2img_pipe():
+    pipe = StableDiffusionXLImg2ImgPipeline.from_pretrained(
+        "stabilityai/stable-diffusion-xl-refiner-1.0", torch_dtype=torch.float16, variant="fp16", use_safetensors=True
+    )
+    pipe = pipe.to("mps")
+    pipe.vae.disable_tiling()
+    tiling.enable_circular_tiling([pipe.vae, pipe.text_encoder_2, pipe.unet])
+    return pipe

utils/tiling.py

@@ -0,0 +1,61 @@
+from typing import Optional
+
+import diffusers
+import torch
+from torch import Tensor
+from torch.nn import functional as F
+from torch.nn.modules.utils import _pair
+
+
+def asymmetric_conv2d_conv_forward(self, input: Tensor, weight: Tensor, bias: Optional[Tensor]):
+    """
+    Perform a forward pass of a custom 2D convolution with asymmetric circular padding.
+
+    This method modifies the standard 2D convolution by applying asymmetric padding
+    to the input tensor before performing the convolution. The padding is circular,
+    meaning the input tensor wraps around itself.
+
+    Args:
+        self: An instance of the class containing convolution parameters.
+        input (Tensor): The input tensor to be convolved.
+        weight (Tensor): The weight tensor of the convolution kernel.
+        bias (Optional[Tensor]): An optional bias tensor for the convolution.
+
+    Returns:
+        Tensor: The output tensor after applying the asymmetric circular padding and 2D convolution.
+    """
+    self
+    self.paddingX = (self._reversed_padding_repeated_twice[0], self._reversed_padding_repeated_twice[1], 0, 0)
+    self.paddingY = (0, 0, self._reversed_padding_repeated_twice[2], self._reversed_padding_repeated_twice[3])
+    working = F.pad(input, self.paddingX, mode='circular')
+    working = F.pad(working, self.paddingY, mode='circular')
+    return F.conv2d(working, weight, bias, self.stride, _pair(0), self.dilation, self.groups)
+
+
+def enable_circular_tiling(targets):
+    """
+        Enable circular tiling on convolutional layers within the given targets.
+
+        This function iterates through the given targets (which are parts of a neural
+        network model) and modifies each convolutional layer to use a custom asymmetric
+        convolution with circular padding. It is specifically designed for use with
+        the StableDiffusionXLPipeline to modify its convolution layers for circular tiling.
+
+        Args:
+            targets (list): A list of neural network components (e.g., layers or entire models)
+                            from which to find and modify Conv2d layers.
+
+        Returns:
+            None: The function modifies the convolutional layers in-place.
+        """
+    conv_layers = []
+    for target in targets:
+        for module in target.modules():
+            if isinstance(module, torch.nn.Conv2d):
+                conv_layers.append(module)
+
+    for cl in conv_layers:
+        if isinstance(cl, diffusers.models.lora.LoRACompatibleConv) and cl.lora_layer is None:
+            cl.lora_layer = lambda *x: 0
+
+        cl._conv_forward = asymmetric_conv2d_conv_forward.__get__(cl, torch.nn.Conv2d)