Upload 4 files

conditioning_images.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0771a9ef980ac5e1ab05a635cdcb601194031d10ac74dec815df9667668c544b
+size 8441614671

depth_overlap_simple_shape.py

@@ -0,0 +1,101 @@
+import pandas as pd
+from huggingface_hub import hf_hub_url
+import datasets
+import os
+
+_VERSION = datasets.Version("0.0.1")
+
+_DESCRIPTION = "TODO"
+_HOMEPAGE = "TODO"
+_LICENSE = "TODO"
+_CITATION = "TODO"
+
+_FEATURES = datasets.Features(
+    {
+        "image": datasets.Image(),
+        "conditioning_image": datasets.Image(),
+        "text": datasets.Value("string"),
+    },
+)
+
+METADATA_URL = hf_hub_url(
+    "Yossh/depth_overlap_simple_shape",
+    filename="train.jsonl",
+    repo_type="dataset",
+)
+
+IMAGES_URL = hf_hub_url(
+    "Yossh/depth_overlap_simple_shape",
+    filename="images.zip",
+    repo_type="dataset",
+)
+
+CONDITIONING_IMAGES_URL = hf_hub_url(
+    "Yossh/depth_overlap_simple_shape",
+    filename="conditioning_images.zip",
+    repo_type="dataset",
+)
+
+_DEFAULT_CONFIG = datasets.BuilderConfig(name="default", version=_VERSION)
+
+
+class Fill50k(datasets.GeneratorBasedBuilder):
+    BUILDER_CONFIGS = [_DEFAULT_CONFIG]
+    DEFAULT_CONFIG_NAME = "default"
+
+    def _info(self):
+        return datasets.DatasetInfo(
+            description=_DESCRIPTION,
+            features=_FEATURES,
+            supervised_keys=None,
+            homepage=_HOMEPAGE,
+            license=_LICENSE,
+            citation=_CITATION,
+        )
+
+    def _split_generators(self, dl_manager):
+        metadata_path = dl_manager.download(METADATA_URL)
+        images_dir = dl_manager.download_and_extract(IMAGES_URL)
+        conditioning_images_dir = dl_manager.download_and_extract(
+            CONDITIONING_IMAGES_URL
+        )
+
+        return [
+            datasets.SplitGenerator(
+                name=datasets.Split.TRAIN,
+                # These kwargs will be passed to _generate_examples
+                gen_kwargs={
+                    "metadata_path": metadata_path,
+                    "images_dir": images_dir,
+                    "conditioning_images_dir": conditioning_images_dir,
+                },
+            ),
+        ]
+
+    def _generate_examples(self, metadata_path, images_dir, conditioning_images_dir):
+        metadata = pd.read_json(metadata_path, lines=True)
+
+        for _, row in metadata.iterrows():
+            text = row["text"]
+
+            image_path = row["image"]
+            image_path = os.path.join(images_dir, image_path)
+            image = open(image_path, "rb").read()
+
+            conditioning_image_path = row["conditioning_image"]
+            conditioning_image_path = os.path.join(
+                conditioning_images_dir, row["conditioning_image"]
+            )
+            conditioning_image = open(conditioning_image_path, "rb").read()
+
+            yield row["image"], {
+                "text": text,
+                "image": {
+                    "path": image_path,
+                    "bytes": image,
+                },
+                "conditioning_image": {
+                    "path": conditioning_image_path,
+                    "bytes": conditioning_image,
+                },
+            }

figure_generate.py

@@ -0,0 +1,160 @@
+from PIL import Image, ImageDraw, ImageFilter
+import numpy as np
+import random
+import math
+
+class SimplePolygon:
+    pow2 = None
+
+    def __init__(self, file_name, depth_name, tags_name,resolution=(512, 512), init_color=(255, 255, 255)):
+        self.file_name = file_name
+        self.depth_name = depth_name
+        self.tags_name = tags_name
+        self.width = resolution[0]
+        self.height = resolution[1]
+        self.components= [set([(wi, hi) for wi in range(512) for hi in range(512)])]
+        self.img1 = np.full((self.width, self.height, 3), np.random.randint(0, 256, size=(3,), dtype=np.uint8), dtype=np.uint8)
+        self.img2 = np.zeros([self.width, self.height, 3], dtype=np.uint8)
+        self.count = 0
+        if self.pow2 is None:
+            self.pow2 = [x**2 for x in range(max(resolution[0],resolution[1])+1)]
+    def component_check(self, comp):
+        retv = set()
+        for wi, hi in comp:
+            if 0<=wi<self.width and 0<=hi<self.height:
+                retv.add((wi, hi))
+        return retv
+    def components_check(self, components):
+        retv = []
+        for i in range(len(components)):
+            is_contain = False
+            for j in range(i+1, len(components)):
+                if components[i] <= components[j]:
+                    is_contain = True
+                    break
+            if not is_contain:
+                retv.append(self.components[i])
+        return retv
+    def generate(self):
+        # 別の図形に含まれている図形は削除
+        self.components = self.components_check(self.components)
+        # 画像外の座標は除去
+        for i in range(len(self.components)):
+            self.components[i]=self.component_check(self.components[i])
+
+        layer = np.zeros_like(self.components, dtype=np.uint16)
+        noise = np.zeros(3, dtype=np.int16)
+        if random.randint(1, 5)==1:
+            noise = np.random.randint(-10, 10, size=(3,), dtype=np.int16)
+        for i in range(len(self.components)):
+            # ↓に重なってる図形の層+1 のmax
+            for j in range(i-1, -1, -1):
+                if not self.components[i].isdisjoint(self.components[j]):
+                    layer[i]=max(layer[i], layer[j]+1)
+            # 色付ける
+            color = np.random.randint(0, 255, size=(3,), dtype=np.int16)
+            vec = np.random.randint(0, 255, size=(3,), dtype=np.int16)
+            ep = np.random.normal(0, 2, size=(2,))
+            for wi, hi in self.components[i]:
+                self.img1[wi][hi] = np.abs((color + vec * (ep[0] * wi / self.width + ep[1] * hi / self.height)+noise) % 512 - 256).astype(np.uint8)
+        # depth画像生成
+        self.layer_max = np.max(layer)
+        normalized_layer = ( (255 * layer) // self.layer_max).astype(np.uint8)
+        for wi in range(self.width):
+            for hi in range(self.height):
+                for i in range(len(self.components)-1, -1, -1):
+                    if (wi,hi) in self.components[i]:
+                        self.img2[wi][hi][0] = normalized_layer[i]          
+                        self.img2[wi][hi][1] = normalized_layer[i]          
+                        self.img2[wi][hi][2] = normalized_layer[i]          
+                        break
+
+    def add_rect(self):
+        left_top = [random.randint(0, self.width//10*9), random.randint(0, self.height//10*9)]
+        poly_width = random.randint(60, self.width//2)
+        poly_height = random.randint(60, self.height//2)
+        poly = set()
+        for wi in range(left_top[0], min(left_top[0]+poly_width, self.width)):
+            for hi in range(left_top[1], min(left_top[1]+poly_height, self.height)):
+                poly.add((wi, hi))
+        self.components.append(self.rotate_component(poly, random.uniform(-math.pi, math.pi)))
+        return poly
+
+    def add_ellipse(self):
+        center = [random.randint(self.width//10, self.width//10*9), random.randint(self.height//10, self.height//10*9)]
+        radius_width = random.randint(60, self.width//4)
+        radius_height = random.randint(60, self.height//4)
+        poly = set()
+        r = radius_width**2 * radius_height**2
+        h2 = radius_height**2
+        w2 = radius_width**2
+        for wi in range(self.width):
+            xx = h2 * self.pow2[abs(wi-center[0])]
+            if xx > r:
+                continue
+            for hi in range(self.height):
+                if xx + w2 * self.pow2[abs(hi-center[1])] <= r:
+                    poly.add((wi, hi))
+        self.components.append(self.rotate_component(poly, random.uniform(-math.pi, math.pi)))
+        return poly
+    def rotate_component(self, comp, rad):
+        retv = set()
+        for wi, hi in comp:
+            new_wi = math.cos(rad)*(wi-self.width/2)-math.sin(rad)*(hi-self.height/2)+self.width/2
+            new_hi = math.sin(rad)*(wi-self.width/2)+math.cos(rad)*(hi-self.height/2)+self.height/2
+            new_wi = round(new_wi)
+            new_hi = round(new_hi)
+            for i in range(-1, 2): # -1,0,1
+                for j in range(-1, 2):
+                    retv.add((new_wi+i, new_hi+j))
+        return retv
+    def save(self):
+        Image.fromarray(self.img1).filter(filter=ImageFilter.GaussianBlur(random.randint(0, 1))).save(self.file_name)
+        Image.fromarray(self.img2).save(self.depth_name)
+        with open(self.tags_name, "w") as file:
+            if self.layer_max is None:
+                file.write("")
+            else:
+                file.write(f"{self.layer_max+1}depth")
+
+    
+import uuid
+import concurrent.futures
+from tqdm import tqdm
+import os
+import threading
+
+
+
+def process_polygon():
+    random_uuid = str(uuid.uuid4())
+    polygon = SimplePolygon(f"conditioning_images/{random_uuid}.png", f"images/{random_uuid}.png", f"conditioning_images/{random_uuid}.txt")
+    for _ in range(random.randint(4, 20)):
+        if random.randint(0,1)==0:
+            polygon.add_ellipse()
+        else:
+            polygon.add_rect()
+    polygon.generate()
+    polygon.save()
+
+def main():
+    if not os.path.exists("conditioning_images"):
+        os.makedirs("conditioning_images")
+    if not os.path.exists("images"):
+        os.makedirs("images")
+    num_processes = 24 
+    total_runs = 21037
+
+    with tqdm(total=total_runs, ncols=80) as pbar:
+        with concurrent.futures.ProcessPoolExecutor(max_workers=num_processes) as executor:
+            futures = [executor.submit(process_polygon) for _ in range(total_runs)]
+            for future in concurrent.futures.as_completed(futures):
+                try:
+                    result = future.result()
+                    pbar.update(1)
+                except Exception as e:
+                    print(f"Error occurred: {e}")
+                    pbar.update(1)
+
+if __name__ == "__main__":
+    main()

images.zip

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:cf40915ae282673dbdae68b9251bd776bdecaa928c08612ee5e3a0a64c64ecca
-size 489238929
+oid sha256:0777317872179bca4f9ed73aa4d034fe01ee111943a7c44cfd934102985a911a
+size 613377917