Update README.md

README.md

@@ -3,6 +3,115 @@ The idea is to unlock the full outpainting potential of Flux.1.Fill-dev model.
 The original model parameters have not been finetuned or modified.
 Rather, this simple hack unlocks the full potential of the Flux.1-Fill-dev model.
 
+`FLUX.1 Fill [dev]` is a 12 billion parameter rectified flow transformer capable of filling areas in existing images based on a text description.
+
+## Diffusers
+
+To use `FLUX.1 Fill [dev]` with the 🧨 diffusers python library, first install or upgrade diffusers
+
+```shell
+pip install -U diffusers
+```
+
+Then you can use `FluxFillPipeline` to run the model
 Here is a code snippet to use the code.
 
-TODO
+
+```python
+import torch
+from diffusers import FluxFillPipeline
+from diffusers.utils import load_image
+
+
+def get_mask_and_image(self, original_image, model_w=1024, model_h=1024):
+    orig_h, orig_w = original_image.size[0:2]
+    pil_image = original_image
+    np_image = np.asarray(pil_image)
+    np_input_image = np_image[:, :, :3]
+    np_input_mask = np_image[:, :, 3]
+    pure_fg_image = np.uint8(np_input_image)
+    np_input_mask = 255 - np_input_mask
+
+    alpha = 1 - (np.array(np_input_mask) / 255)
+    alpha = np.stack([alpha, alpha, alpha], -1)
+    input_image = Image.fromarray(pure_fg_image)
+
+    kernel = np.ones((3,3))
+    np_input_mask = cv2.erode(np_input_mask, kernel, iterations=1)
+    input_mask = Image.fromarray(np_input_mask)
+    return input_mask, alpha, input_image
+
+def prepare_masked_image(self, foreground, mask, alpha=0.001, blur=True):
+    # Creating kernel 
+    kernel = np.ones((3, 3), np.uint8)
+    mask_np= np.array(mask)
+    h, w, c = np.shape(foreground)
+
+    #print(h,w,c)
+    # Add random Gaussian noise
+    noise = np.random.rand(h, w)*255
+    noise = np.array(noise, dtype=np.uint8)
+    if(blur):
+        noise = cv2.GaussianBlur(noise, (5,5), 0)
+    noise = np.stack([noise, noise, noise], -1)
+
+    if(isinstance(foreground,PIL.Image.Image)):
+        foreground = np.array(foreground)
+
+    black_image = Image.fromarray(np.zeros_like(foreground))
+    background = np.array(black_image)
+
+    dilated_mask = np.array(cv2.dilate(np.array(mask), kernel, iterations=10))
+    center = (np.shape(foreground)[1]//2,np.shape(foreground)[0]//2)
+
+    black_image = cv2.seamlessClone(foreground, background, dilated_mask, center, cv2.MIXED_CLONE)
+    #black_image = cv2.seamlessClone(foreground, background, dilated_mask, center, cv2.NORMAL_CLONE)
+
+    noisy_background = np.array(alpha*np.array(black_image) + (1-alpha)*noise, dtype=np.uint8)
+    if(np.max(mask_np)>1.0):
+        mask_np = mask_np/255.0
+    if(mask_np.shape[-1]!=3):
+        mask_np = np.stack([mask_np]*3,-1)
+        
+    masked_image = Image.fromarray(np.array((1 - mask_np) * foreground + mask_np * noisy_background, dtype=np.uint8))
+
+    return masked_image
+
+
+image = load_image("https://huggingface.co/datasets/diffusers/diffusers-images-docs/resolve/main/cup.png")
+mask = load_image("https://huggingface.co/datasets/diffusers/diffusers-images-docs/resolve/main/cup_mask.png")
+
+fg_mask, alpha, input_img = self.get_mask_and_image()
+
+masked_image = self.prepare_masked_image(foreground=input_img_resized, mask=fg_mask_resized)
+
+pipe = FluxFillPipeline.from_pretrained("black-forest-labs/FLUX.1-Fill-dev", torch_dtype=torch.bfloat16).to("cuda")
+image = pipe(
+    prompt="a white paper cup",
+    image=masked_image,
+    mask_image=mask,
+    height=1632,
+    width=1232,
+    guidance_scale=30,
+    num_inference_steps=50,
+    max_sequence_length=512,
+    generator=torch.Generator("cpu").manual_seed(0)
+).images[0]
+
+image.save(f"flux-fill-dev.png")
+```
+
+To learn more check out the [diffusers](https://huggingface.co/docs/diffusers/main/en/api/pipelines/flux) documentation
+
+---
+language:
+- en
+license: other
+license_name: flux-1-dev-non-commercial-license
+license_link: LICENSE.md
+tags:
+- image-generation
+- flux
+- inpainting
+- diffusion-single-file
+---