Upload 6 files

config.py

@@ -0,0 +1,46 @@
+import requests
+from bs4 import BeautifulSoup
+import os
+import cv2
+import numpy as np
+from PIL import Image
+
+# Define the directories
+LINE_ART_DIR = "train_images/line_arts"
+COLORED_DIR = "train_images/colored"
+
+# Ensure directories exist
+os.makedirs(LINE_ART_DIR, exist_ok=True)
+os.makedirs(COLORED_DIR, exist_ok=True)
+
+# Function to download and process images
+def download_and_process_images(manga_title, url):
+    response = requests.get(url)
+    soup = BeautifulSoup(response.content, 'html.parser')
+
+    # Find image tags (this will depend on the structure of the webpage)
+    image_tags = soup.find_all('img')
+
+    for img in image_tags:
+        img_url = img['src']
+        img_data = requests.get(img_url).content
+        img_array = np.frombuffer(img_data, np.uint8)
+        img = cv2.imdecode(img_array, cv2.IMREAD_COLOR)
+
+        # Check if the image is colored or line art
+        if len(img.shape) == 3 and img.shape[2] == 3:
+            # Colored image
+            colored_path = os.path.join(COLORED_DIR, f"{manga_title}_colored.png")
+            cv2.imwrite(colored_path, img)
+        else:
+            # Line art image
+            line_art_path = os.path.join(LINE_ART_DIR, f"{manga_title}_line_art.png")
+            cv2.imwrite(line_art_path, img)
+
+# Example usage
+manga_title = "example_manga"
+nhentai_url = "https://nhentai.net/g/your_manga_id/"
+hitomi_url = "https://hitomi.la/galleries/your_manga_id.html"
+
+download_and_process_images(manga_title, nhentai_url)
+download_and_process_images(manga_title, hitomi_url)

dataset.py

@@ -0,0 +1,51 @@
+import tensorflow as tf
+import os
+from config import config
+
+class MangaDataset:
+    def __init__(self):
+        self.line_art_dir = config.LINE_ART_DIR
+        self.colored_dir = config.COLORED_DIR
+        
+    def load_data(self):
+        """โหลดและเตรียมข้อมูล"""
+        line_art_paths = sorted([os.path.join(self.line_art_dir, f) 
+                               for f in os.listdir(self.line_art_dir) 
+                               if f.endswith(('.png', '.jpg'))])
+        
+        colored_paths = sorted([os.path.join(self.colored_dir, f) 
+                              for f in os.listdir(self.colored_dir) 
+                              if f.endswith(('.png', '.jpg'))])
+        
+        # สร้าง dataset
+        dataset = tf.data.Dataset.from_tensor_slices((line_art_paths, colored_paths))
+        dataset = dataset.map(self.process_paths, num_parallel_calls=tf.data.AUTOTUNE)
+        dataset = dataset.batch(config.BATCH_SIZE)
+        dataset = dataset.prefetch(buffer_size=tf.data.AUTOTUNE)
+        
+        return dataset
+    
+    def process_paths(self, line_art_path, colored_path):
+        """ประมวลผลภาพคู่"""
+        # โหลดภาพเส้น
+        line_art = self.load_image(line_art_path, is_line_art=True)
+        
+        # โหลดภาพสี
+        colored = self.load_image(colored_path, is_line_art=False)
+        
+        return line_art, colored
+    
+    def load_image(self, image_path, is_line_art=False):
+        """โหลดภาพเดียว"""
+        image = tf.io.read_file(image_path)
+        image = tf.image.decode_image(image, channels=3)
+        image = tf.image.resize(image, [config.IMAGE_SIZE[0], config.IMAGE_SIZE[1]])
+        image = tf.cast(image, tf.float32) / 255.0
+        
+        if is_line_art:
+            # แปลงเป็น grayscale และทำให้เส้นคมชัด
+            image = tf.image.rgb_to_grayscale(image)
+            # ทำให้เส้นดำสนิท พื้นขาว
+            image = tf.where(image < 0.5, 0.0, 1.0)
+        
+        return image

inference.py

@@ -0,0 +1,126 @@
+import tensorflow as tf
+import cv2
+import numpy as np
+from PIL import Image
+import argparse
+import os
+
+class MangaColorizerInference:
+    def __init__(self, model_path):
+        """โหลดโมเดลที่ฝึกไว้แล้ว"""
+        try:
+            if not os.path.exists(model_path):
+                raise FileNotFoundError(f"ไม่พบไฟล์โมเดล: {model_path}")
+            
+            self.model = tf.keras.models.load_model(model_path)
+            print(f"✅ โหลดโมเดลสำเร็จจาก: {model_path}")
+            
+        except Exception as e:
+            print(f"❌ เกิดข้อผิดพลาดในการโหลดโมเดล: {e}")
+            raise
+    
+    def load_and_preprocess(self, image_path):
+        """โหลดและเตรียมภาพสำหรับโมเดล"""
+        try:
+            # โหลดภาพ
+            image = cv2.imread(image_path)
+            if image is None:
+                raise ValueError(f"ไม่สามารถโหลดภาพจาก: {image_path}")
+            
+            image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
+            
+            # บันทึกขนาดเดิม
+            original_size = image.shape[:2]
+            
+            # ปรับขนาด
+            image_resized = cv2.resize(image, (256, 256))
+            
+            # แปลงเป็น grayscale
+            gray = cv2.cvtColor(image_resized, cv2.COLOR_RGB2GRAY)
+            
+            # ทำให้เส้นคมชัด
+            _, binary = cv2.threshold(gray, 127, 255, cv2.THRESH_BINARY_INV)
+            binary = cv2.bitwise_not(binary)
+            
+            # Normalize
+            binary = binary.astype(np.float32) / 255.0
+            binary = np.expand_dims(binary, axis=-1)
+            
+            return binary, original_size, image_resized
+            
+        except Exception as e:
+            print(f"❌ ข้อผิดพลาดในการประมวลผลภาพ: {e}")
+            raise
+    
+    def colorize(self, image_path, output_path, save_comparison=False):
+        """ลงสีภาพเส้น"""
+        try:
+            # โหลดและประมวลผลภาพ
+            image, original_size, original_resized = self.load_and_preprocess(image_path)
+            
+            # ทำนายสี
+            print("🎨 กำลังลงสี...")
+            prediction = self.model.predict(image[np.newaxis, ...], verbose=0)[0]
+            
+            # แปลงกลับเป็นภาพและปรับขนาดกลับ
+            colored_image = (prediction * 255).astype(np.uint8)
+            colored_image_original_size = cv2.resize(colored_image, (original_size[1], original_size[0]))
+            
+            # บันทึกผลลัพธ์
+            Image.fromarray(colored_image_original_size).save(output_path)
+            print(f"💾 บันทึกภาพที่: {output_path}")
+            
+            # บันทึกภาพเปรียบเทียบ (optional)
+            if save_comparison:
+                comparison = self.create_comparison(original_resized, colored_image)
+                comparison_path = output_path.replace('.png', '_comparison.png')
+                comparison.save(comparison_path)
+                print(f"📊 บันทึกภาพเปรียบเทียบที่: {comparison_path}")
+            
+            return colored_image_original_size
+            
+        except Exception as e:
+            print(f"❌ ข้อผิดพลาดในการลงสี: {e}")
+            return None
+    
+    def create_comparison(self, original, colored):
+        """สร้างภาพเปรียบเทียบก่อน-หลัง"""
+        # แปลงภาพต้นฉบับเป็น RGB สำหรับแสดง
+        if len(original.shape) == 3 and original.shape[2] == 3:
+            original_rgb = original
+        else:
+            original_rgb = cv2.cvtColor(original, cv2.COLOR_GRAY2RGB)
+        
+        # รวมภาพ
+        comparison = np.hstack([original_rgb, colored])
+        return Image.fromarray(comparison)
+
+def main():
+    parser = argparse.ArgumentParser(description='AI Manga Colorizer - Inference')
+    parser.add_argument('--input', type=str, required=True, help='Path to input line art')
+    parser.add_argument('--output', type=str, required=True, help='Path to save colored image')
+    parser.add_argument('--model', type=str, default='output/manga_colorizer.h5', help='Path to trained model')
+    parser.add_argument('--compare', action='store_true', help='Save comparison image')
+    
+    args = parser.parse_args()
+    
+    # ตรวจสอบไฟล์ input
+    if not os.path.exists(args.input):
+        print(f"❌ ไม่พบไฟล์ input: {args.input}")
+        return
+    
+    # ใช้งานโมเดล
+    try:
+        colorizer = MangaColorizerInference(args.model)
+        result = colorizer.colorize(args.input, args.output, save_comparison=args.compare)
+        
+        if result is not None:
+            print("✅ เสร็จสิ้น!")
+        else:
+            print("❌ การลงสีล้มเหลว")
+        
+    except Exception as e:
+        print(f"❌ การทำงานล้มเหลว: {e}")
+
+if __name__ == "__main__":
+    main()

model.py

@@ -0,0 +1,195 @@
+import tensorflow as tf
+from tensorflow.keras import layers, Model
+from config import config
+
+def downsample(filters, size, apply_batchnorm=True):
+    """Downsampling block"""
+    initializer = tf.random_normal_initializer(0., 0.02)
+    
+    result = tf.keras.Sequential()
+    result.add(
+        layers.Conv2D(filters, size, strides=2, padding='same',
+                     kernel_initializer=initializer, use_bias=False)
+    )
+    
+    if apply_batchnorm:
+        result.add(layers.BatchNormalization())
+    
+    result.add(layers.LeakyReLU())
+    
+    return result
+
+def upsample(filters, size, apply_dropout=False):
+    """Upsampling block"""
+    initializer = tf.random_normal_initializer(0., 0.02)
+    
+    result = tf.keras.Sequential()
+    result.add(
+        layers.Conv2DTranspose(filters, size, strides=2,
+                              padding='same',
+                              kernel_initializer=initializer,
+                              use_bias=False)
+    )
+    
+    result.add(layers.BatchNormalization())
+    
+    if apply_dropout:
+        result.add(layers.Dropout(0.5))
+    
+    result.add(layers.ReLU())
+    
+    return result
+
+def build_generator():
+    """สร้าง Generator แบบ U-Net"""
+    inputs = layers.Input(shape=[256, 256, 1])
+    
+    # Encoder
+    down_stack = [
+        downsample(64, 4, apply_batchnorm=False),  # (bs, 128, 128, 64)
+        downsample(128, 4),  # (bs, 64, 64, 128)
+        downsample(256, 4),  # (bs, 32, 32, 256)
+        downsample(512, 4),  # (bs, 16, 16, 512)
+        downsample(512, 4),  # (bs, 8, 8, 512)
+        downsample(512, 4),  # (bs, 4, 4, 512)
+        downsample(512, 4),  # (bs, 2, 2, 512)
+        downsample(512, 4),  # (bs, 1, 1, 512)
+    ]
+    
+    # Decoder
+    up_stack = [
+        upsample(512, 4, apply_dropout=True),  # (bs, 2, 2, 1024)
+        upsample(512, 4, apply_dropout=True),  # (bs, 4, 4, 1024)
+        upsample(512, 4, apply_dropout=True),  # (bs, 8, 8, 1024)
+        upsample(512, 4),  # (bs, 16, 16, 1024)
+        upsample(256, 4),  # (bs, 32, 32, 512)
+        upsample(128, 4),  # (bs, 64, 64, 256)
+        upsample(64, 4),   # (bs, 128, 128, 128)
+    ]
+    
+    initializer = tf.random_normal_initializer(0., 0.02)
+    last = layers.Conv2DTranspose(
+        config.OUTPUT_CHANNELS, 4, strides=2,
+        padding='same', kernel_initializer=initializer,
+        activation='sigmoid'
+    )  # (bs, 256, 256, 3)
+    
+    x = inputs
+    
+    # Downsampling และเก็บ skip connections
+    skips = []
+    for down in down_stack:
+        x = down(x)
+        skips.append(x)
+    
+    skips = reversed(skips[:-1])
+    
+    # Upsampling และเชื่อม skip connections
+    for up, skip in zip(up_stack, skips):
+        x = up(x)
+        x = layers.Concatenate()([x, skip])
+    
+    x = last(x)
+    
+    return Model(inputs=inputs, outputs=x)
+
+def build_discriminator():
+    """สร้าง Discriminator"""
+    initializer = tf.random_normal_initializer(0., 0.02)
+    
+    inp = layers.Input(shape=[256, 256, 1], name='input_image')
+    tar = layers.Input(shape=[256, 256, 3], name='target_image')
+    
+    x = layers.concatenate([inp, tar])  # (bs, 256, 256, channels*2)
+    
+    down1 = downsample(64, 4, False)(x)  # (bs, 128, 128, 64)
+    down2 = downsample(128, 4)(down1)    # (bs, 64, 64, 128)
+    down3 = downsample(256, 4)(down2)    # (bs, 32, 32, 256)
+    
+    zero_pad1 = layers.ZeroPadding2D()(down3)  # (bs, 34, 34, 256)
+    conv = layers.Conv2D(
+        512, 4, strides=1,
+        kernel_initializer=initializer,
+        use_bias=False
+    )(zero_pad1)  # (bs, 31, 31, 512)
+    
+    batchnorm1 = layers.BatchNormalization()(conv)
+    leaky_relu = layers.LeakyReLU()(batchnorm1)
+    zero_pad2 = layers.ZeroPadding2D()(leaky_relu)  # (bs, 33, 33, 512)
+    
+    last = layers.Conv2D(
+        1, 4, strides=1,
+        kernel_initializer=initializer
+    )(zero_pad2)  # (bs, 30, 30, 1)
+    
+    return Model(inputs=[inp, tar], outputs=last)
+
+class MangaColorizer(Model):
+    """คลาสหลักสำหรับการลงสีมังงะ"""
+    def __init__(self):
+        super().__init__()
+        self.generator = build_generator()
+        self.discriminator = build_discriminator()
+        
+    def compile(self, g_optimizer, d_optimizer, loss_fn):
+        super().compile()
+        self.g_optimizer = g_optimizer
+        self.d_optimizer = d_optimizer
+        self.loss_fn = loss_fn
+        
+    def train_step(self, data):
+        input_image, target_image = data
+        
+        with tf.GradientTape() as gen_tape, tf.GradientTape() as disc_tape:
+            # Generator สร้างภาพ
+            gen_output = self.generator(input_image, training=True)
+            
+            # Discriminator ตรวจสอบ
+            disc_real_output = self.discriminator([input_image, target_image], training=True)
+            disc_generated_output = self.discriminator([input_image, gen_output], training=True)
+            
+            # คำนวณ loss
+            gen_total_loss, gen_gan_loss, gen_l1_loss = self.generator_loss(
+                disc_generated_output, gen_output, target_image
+            )
+            disc_loss = self.discriminator_loss(disc_real_output, disc_generated_output)
+        
+        # อัพเดท gradient
+        generator_gradients = gen_tape.gradient(
+            gen_total_loss, self.generator.trainable_variables
+        )
+        discriminator_gradients = disc_tape.gradient(
+            disc_loss, self.discriminator.trainable_variables
+        )
+        
+        self.g_optimizer.apply_gradients(
+            zip(generator_gradients, self.generator.trainable_variables)
+        )
+        self.d_optimizer.apply_gradients(
+            zip(discriminator_gradients, self.discriminator.trainable_variables)
+        )
+        
+        return {
+            "gen_total_loss": gen_total_loss,
+            "gen_gan_loss": gen_gan_loss,
+            "gen_l1_loss": gen_l1_loss,
+            "disc_loss": disc_loss
+        }
+    
+    def generator_loss(self, disc_generated_output, gen_output, target):
+        gan_loss = self.loss_fn(tf.ones_like(disc_generated_output), disc_generated_output)
+        
+        # L1 loss - ทำให้สีใกล้เคียงกับภาพจริง
+        l1_loss = tf.reduce_mean(tf.abs(target - gen_output))
+        
+        total_gen_loss = gan_loss + (100 * l1_loss)  # L1 weight = 100
+        
+        return total_gen_loss, gan_loss, l1_loss
+    
+    def discriminator_loss(self, disc_real_output, disc_generated_output):
+        real_loss = self.loss_fn(tf.ones_like(disc_real_output), disc_real_output)
+        generated_loss = self.loss_fn(tf.zeros_like(disc_generated_output), disc_generated_output)
+        
+        total_disc_loss = real_loss + generated_loss
+        
+        return total_disc_loss

train.py

@@ -0,0 +1,112 @@
+import tensorflow as tf
+from model import MangaColorizer
+from dataset import MangaDataset
+from utils import save_comparison, prepare_directories, check_dataset_size
+from config import config
+import matplotlib.pyplot as plt
+import os
+
+class TrainingMonitor(tf.keras.callbacks.Callback):
+    """Callback สำหรับตรวจสอบการฝึก"""
+    def __init__(self, dataset):
+        super().__init__()
+        self.dataset = dataset
+        
+    def on_epoch_end(self, epoch, logs=None):
+        # ใช้ภาพตัวอย่างจาก batch แรก
+        for input_image, target_image in self.dataset.take(1):
+            prediction = self.model.generator(input_image, training=False)
+            save_comparison(input_image, prediction, epoch, 0)
+        
+        # พิมพ์ loss ทุก epoch
+        if logs:
+            print(f"📊 Epoch {epoch+1}: "
+                  f"Gen Loss: {logs.get('gen_total_loss', 0):.4f}, "
+                  f"Disc Loss: {logs.get('disc_loss', 0):.4f}")
+
+def main():
+    # เตรียม directory
+    prepare_directories()
+    
+    # ตรวจสอบ dataset
+    if not check_dataset_size(config.LINE_ART_DIR, config.COLORED_DIR):
+        print("❌ กรุณาตรวจสอบ dataset ก่อนเริ่มฝึก")
+        return
+    
+    # โหลดข้อมูล
+    print("🔄 กำลังโหลดข้อมูล...")
+    dataset = MangaDataset().load_data()
+    
+    # ตรวจสอบว่ามีข้อมูลหรือไม่
+    try:
+        sample_batch = next(iter(dataset))
+        print(f"✅ โหลดข้อมูลสำเร็จ: Batch size {sample_batch[0].shape}")
+    except StopIteration:
+        print("❌ ไม่มีข้อมูลใน dataset")
+        return
+    
+    # สร้างโมเดล
+    print("🔄 กำลังสร้างโมเดล...")
+    colorizer = MangaColorizer()
+    
+    # Compile โมเดล
+    generator_optimizer = tf.keras.optimizers.Adam(config.LEARNING_RATE, beta_1=0.5)
+    discriminator_optimizer = tf.keras.optimizers.Adam(config.LEARNING_RATE, beta_1=0.5)
+    loss_fn = tf.keras.losses.BinaryCrossentropy(from_logits=True)
+    
+    colorizer.compile(
+        g_optimizer=generator_optimizer,
+        d_optimizer=discriminator_optimizer,
+        loss_fn=loss_fn
+    )
+    
+    print(f"✅ สร้างโมเดลสำเร็จ")
+    print(f"📈 เริ่มฝึก {config.EPOCHS} epochs...")
+    
+    # ฝึกโมเดล
+    history = colorizer.fit(
+        dataset,
+        epochs=config.EPOCHS,
+        callbacks=[TrainingMonitor(dataset)],
+        verbose=1
+    )
+    
+    # บันทึกโมเดล
+    os.makedirs('output', exist_ok=True)
+    colorizer.generator.save('output/manga_colorizer.h5')
+    print("✅ บันทึกโมเดลเรียบร้อย: output/manga_colorizer.h5")
+    
+    # พล็อตกราฟ loss
+    try:
+        plt.figure(figsize=(12, 4))
+        
+        plt.subplot(1, 2, 1)
+        if 'gen_total_loss' in history.history:
+            plt.plot(history.history['gen_total_loss'], label='Generator Total Loss')
+        if 'gen_gan_loss' in history.history:
+            plt.plot(history.history['gen_gan_loss'], label='Generator GAN Loss', linestyle='--')
+        if 'gen_l1_loss' in history.history:
+            plt.plot(history.history['gen_l1_loss'], label='Generator L1 Loss', linestyle=':')
+        plt.title('Generator Loss')
+        plt.xlabel('Epoch')
+        plt.ylabel('Loss')
+        plt.legend()
+        
+        plt.subplot(1, 2, 2)
+        if 'disc_loss' in history.history:
+            plt.plot(history.history['disc_loss'], label='Discriminator Loss', color='red')
+        plt.title('Discriminator Loss')
+        plt.xlabel('Epoch')
+        plt.ylabel('Loss')
+        plt.legend()
+        
+        plt.tight_layout()
+        plt.savefig('output/training_loss.png', dpi=300, bbox_inches='tight')
+        plt.close()
+        print("✅ บันทึกกราฟ training loss: output/training_loss.png")
+        
+    except Exception as e:
+        print(f"❌ ไม่สามารถบันทึกกราฟ loss: {e}")
+
+if __name__ == "__main__":
+    main()

utils.py

@@ -0,0 +1,87 @@
+import cv2
+import numpy as np
+import tensorflow as tf
+from PIL import Image
+import os
+
+def load_image(image_path, is_line_art=False):
+    """โหลดภาพและประมวลผลเบื้องต้น"""
+    image = tf.io.read_file(image_path)
+    image = tf.image.decode_image(image, channels=3)
+    image = tf.image.resize(image, [256, 256])
+    image = tf.cast(image, tf.float32) / 255.0
+    
+    if is_line_art:
+        # แปลงเป็น grayscale และทำให้เส้นคมชัด
+        image = tf.image.rgb_to_grayscale(image)
+        # ทำให้เส้นดำสนิท พื้นขาว
+        image = tf.where(image < 0.5, 0.0, 1.0)
+    
+    return image
+
+def extract_line_art_from_colored(colored_image):
+    """สกัดเส้นจากภาพสี (ใช้สร้าง training data)"""
+    # แปลงเป็น grayscale
+    gray = cv2.cvtColor(colored_image, cv2.COLOR_RGB2GRAY)
+    
+    # ใช้ adaptive threshold เพื่อให้เส้นคมชัด
+    line_art = cv2.adaptiveThreshold(
+        gray, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, 
+        cv2.THRESH_BINARY_INV, 11, 2
+    )
+    
+    # ลบ noise
+    kernel = np.ones((2, 2), np.uint8)
+    line_art = cv2.morphologyEx(line_art, cv2.MORPH_OPEN, kernel)
+    
+    return line_art
+
+def save_comparison(image, prediction, epoch, step):
+    """บันทึกภาพเปรียบเทียบ - แก้ไขเวอร์ชัน"""
+    try:
+        # แปลง TensorFlow tensor เป็น numpy array
+        input_image = image[0].numpy()  # (256, 256, 1)
+        pred_image = prediction[0].numpy()  # (256, 256, 3)
+        
+        # แปลงภาพ input จาก grayscale เป็น RGB
+        if input_image.shape[-1] == 1:
+            input_image_rgb = np.repeat(input_image, 3, axis=-1)
+        else:
+            input_image_rgb = input_image
+        
+        # รวมภาพ input และ prediction ข้างกัน
+        combined = np.concatenate([input_image_rgb, pred_image], axis=1)
+        
+        # คลิปค่าและแปลงเป็น uint8
+        combined = np.clip(combined, 0, 1)
+        combined = (combined * 255).astype(np.uint8)
+        
+        # บันทึกภาพ
+        comparison = Image.fromarray(combined)
+        os.makedirs('output', exist_ok=True)
+        comparison.save(f'output/epoch_{epoch:03d}_step_{step:03d}.png')
+        print(f"💾 บันทึกภาพเปรียบเทียบ: output/epoch_{epoch:03d}_step_{step:03d}.png")
+        
+    except Exception as e:
+        print(f"❌ ข้อผิดพลาดในการบันทึกภาพเปรียบเทียบ: {e}")
+
+def prepare_directories():
+    """สร้าง directory ที่จำเป็น"""
+    os.makedirs('train_images/line_arts', exist_ok=True)
+    os.makedirs('train_images/colored', exist_ok=True)
+    os.makedirs('output', exist_ok=True)
+    print("✅ สร้าง directory เรียบร้อย")
+
+# ฟังก์ชันเพิ่มเติมสำหรับการตรวจสอบข้อมูล
+def check_dataset_size(line_art_dir, colored_dir):
+    """ตรวจสอบจำนวนไฟล์ใน dataset"""
+    line_art_files = [f for f in os.listdir(line_art_dir) if f.endswith(('.png', '.jpg'))]
+    colored_files = [f for f in os.listdir(colored_dir) if f.endswith(('.png', '.jpg'))]
+    
+    print(f"📁 ภาพเส้น: {len(line_art_files)} ไฟล์")
+    print(f"🎨 ภาพสี: {len(colored_files)} ไฟล์")
+    
+    if len(line_art_files) != len(colored_files):
+        print("⚠️  จำนวนภาพเส้นและภาพสีไม่เท่ากัน!")
+        return False
+    return True