meyo_node_File.py

import os, re, io, base64, csv, torch, shutil, requests, chardet, pathlib
import openpyxl, folder_paths, node_helpers
import numpy as np
from PIL import Image, ImageOps, ImageSequence, ImageDraw, ImageFont
from pathlib import Path
from openpyxl.drawing.image import Image as OpenpyxlImage
from PIL import Image as PILImage
from io import BytesIO
from . import any_typ, note



#======全能加载图像
class GenericImageLoader:
    @classmethod
    def INPUT_TYPES(cls):
        return {
            "required": {
                "image_input": ("STRING", {"default": ""}),
            }
        }
    RETURN_TYPES = ("IMAGE", "MASK")
    FUNCTION = "load_image"
    OUTPUT_NODE = False
    CATEGORY = "Meeeyo/File"
    DESCRIPTION = note
    def IS_CHANGED(): return float("NaN")

    def load_image(self, image_input):
        path = image_input.strip()
        for ctrl in ['\u202a', '\u202b', '\u202c', '\u202d', '\u202e']:
            while path.startswith(ctrl):
                path = path.lstrip(ctrl)

        source = None
        lower = path.lower()
        if lower.startswith('http://') or lower.startswith('https://'):
            source = 'network'
        elif os.path.isfile(path):
            source = 'local'
        else:
            source = 'base64'
        if source == 'local':
            img = Image.open(path)
        elif source == 'network':
            resp = requests.get(path)
            resp.raise_for_status()
            img = Image.open(io.BytesIO(resp.content))
        else:  # 'base64'
            if ',' in path and path.startswith('data:'):
                _, data = path.split(',', 1)
            else:
                data = path
            decoded = base64.b64decode(data)
            img = Image.open(io.BytesIO(decoded))

        img = img.convert('RGBA')
        has_alpha = img.mode == 'RGBA'
        if has_alpha:
            alpha_channel = np.array(img)[:, :, 3]
            mask = (alpha_channel > 0).astype(np.float32)
            mask_tensor = torch.from_numpy(mask).unsqueeze(0).unsqueeze(0) 
        else:
            mask_tensor = torch.zeros((1, 1, img.size[1], img.size[0]), dtype=torch.float32) 
        np_img = np.array(img).astype(np.float32) / 255.0
        img_tensor = torch.from_numpy(np_img).unsqueeze(0)

        return img_tensor, mask_tensor 


#======加载重置图像
class LoadAndAdjustImage:
    @classmethod
    def INPUT_TYPES(s):
        input_dir = folder_paths.get_input_directory()
        files = [f.name for f in Path(input_dir).iterdir() if f.is_file()]
        return {
            "required": {
                "image": (sorted(files), {"image_upload": True}),
                "max_dimension": ("INT", {"default": 0, "min": 0, "max": 4096, "step": 8}),
                "size_option": (["No Change", "Custom", "Million Pixels", "Small", "Medium", "Large", 
                                 "480P-H(vid 4:3)", "480P-V(vid 3:4)", "720P-H(vid 16:9)", "720P-V(vid 9:16)", "832×480", "480×832"], 
                                {"default": "No Change"})
            }
        }

    RETURN_TYPES = ("IMAGE", "MASK", "STRING")
    RETURN_NAMES = ("image", "mask", "info")
    FUNCTION = "load_image"
    CATEGORY = "Meeeyo/File"
    DESCRIPTION = note
    def IS_CHANGED(): return float("NaN")

    def load_image(self, image, max_dimension, size_option):
        image_path = folder_paths.get_annotated_filepath(image)
        img = Image.open(image_path)
        W, H = img.size
        aspect_ratio = W / H

        def get_target_size():
            if size_option == "No Change":
                # No resizing or cropping, just return the original size
                return W, H
            elif size_option == "Million Pixels":
                return self._resize_to_million_pixels(W, H)
            elif size_option == "Custom":
                ratio = min(max_dimension / W, max_dimension / H)
                return round(W * ratio), round(H * ratio)
            
            size_options = {
                "Small": (
                    (768, 512) if aspect_ratio >= 1.23 else
                    (512, 768) if aspect_ratio <= 0.82 else
                    (768, 768)
                ),
                "Medium": (
                    (1216, 832) if aspect_ratio >= 1.23 else
                    (832, 1216) if aspect_ratio <= 0.82 else
                    (1216, 1216)
                ),
                "Large": (
                    (1600, 1120) if aspect_ratio >= 1.23 else
                    (1120, 1600) if aspect_ratio <= 0.82 else
                    (1600, 1600)
                ),
                "Million Pixels": self._resize_to_million_pixels(W, H),  # Million Pixels option
                "480P-H(vid 4:3)": (640, 480),  # 480P-H, 640x480
                "480P-V(vid 3:4)": (480, 640),  # 480P-V, 480x640
                "720P-H(vid 16:9)": (1280, 720),  # 720P-H, 1280x720
                "720P-V(vid 9:16)": (720, 1280),  # 720P-V, 720x1280
                "832×480": (832, 480),  # 832x480
                "480×832": (480, 832),  # 480x832
            }
            return size_options[size_option]
        
        target_width, target_height = get_target_size()
        output_images = []
        output_masks = []

        for frame in ImageSequence.Iterator(img):
            frame = ImageOps.exif_transpose(frame)
            if frame.mode == 'P':
                frame = frame.convert("RGBA")
            elif 'A' in frame.getbands():
                frame = frame.convert("RGBA")
            
            if size_option == "No Change":
                # No resizing, just use the original frame
                image_frame = frame.convert("RGB")
            else:
                if size_option == "Custom" or size_option == "Million Pixels":
                    ratio = min(target_width / W, target_height / H)
                    adjusted_width = round(W * ratio)
                    adjusted_height = round(H * ratio)
                    image_frame = frame.convert("RGB").resize((adjusted_width, adjusted_height), Image.Resampling.BILINEAR)
                else:
                    image_frame = frame.convert("RGB")
                    image_frame = ImageOps.fit(image_frame, (target_width, target_height), method=Image.Resampling.BILINEAR, centering=(0.5, 0.5))

            image_array = np.array(image_frame).astype(np.float32) / 255.0
            output_images.append(torch.from_numpy(image_array)[None,])

            # Process the mask if available
            if 'A' in frame.getbands():
                mask_frame = frame.getchannel('A')
                if size_option == "Custom" or size_option == "Million Pixels":
                    mask_frame = mask_frame.resize((adjusted_width, adjusted_height), Image.Resampling.BILINEAR)
                else:
                    mask_frame = ImageOps.fit(mask_frame, (target_width, target_height), method=Image.Resampling.BILINEAR, centering=(0.5, 0.5))
                mask = np.array(mask_frame).astype(np.float32) / 255.0
                mask = 1. - mask
            else:
                if size_option == "Custom" or size_option == "Million Pixels":
                    mask = np.zeros((adjusted_height, adjusted_width), dtype=np.float32)
                else:
                    mask = np.zeros((target_height, target_width), dtype=np.float32)
            output_masks.append(torch.from_numpy(mask).unsqueeze(0))
        
        output_image = torch.cat(output_images, dim=0) if len(output_images) > 1 else output_images[0]
        output_mask = torch.cat(output_masks, dim=0) if len(output_masks) > 1 else output_masks[0]
        info = f"Image Path: {image_path}\nOriginal Size: {W}x{H}\nAdjusted Size: {target_width}x{target_height}"
        return (output_image, output_mask, info)

    @classmethod
    def VALIDATE_INPUTS(s, image):
        if not folder_paths.exists_annotated_filepath(image):
            return f"Invalid image file: {image}"
        return True
    def _resize_to_million_pixels(self, W, H):
        aspect_ratio = W / H
        target_area = 1000000  # 1 million pixels
        if aspect_ratio > 1:  # Landscape
            width = int(np.sqrt(target_area * aspect_ratio))
            height = int(target_area / width)
        else:  # Portrait
            height = int(np.sqrt(target_area / aspect_ratio))
            width = int(target_area / height)
        width = (width + 7) // 8 * 8
        height = (height + 7) // 8 * 8
        return width, height


#======重置图像
class ImageAdjuster:
    @classmethod
    def INPUT_TYPES(s):
        return {
            "required": {
                "image": ("IMAGE",),
                "mask": ("MASK",),  # 添加遮罩输入
                "max_dimension": ("INT", {"default": 0, "min": 0, "max": 4096, "step": 8}),
                "size_option": ([
                    "Custom", "Million Pixels", "Small", "Medium", "Large", 
                    "480P-H(vid 4:3)", "480P-V(vid 3:4)", "720P-H(vid 16:9)", "720P-V(vid 9:16)", "832×480", "480×832"], 
                    {"default": "Million Pixels"}
                )
            }
        }

    RETURN_TYPES = ("IMAGE", "MASK", "INT", "INT")
    RETURN_NAMES = ("image", "mask", "width", "height")
    FUNCTION = "process_image"
    CATEGORY = "Meeeyo/File"
    DESCRIPTION = note
    def IS_CHANGED(): return float("NaN")

    def process_image(self, image, mask, max_dimension=1024, size_option="Custom"):
        batch_size = image.shape[0]
        processed_images = []
        processed_masks = []
        widths = []
        heights = []

        for i in range(batch_size):
            current_image = image[i]
            current_mask = mask[i]
            
            input_pil_image = Image.fromarray((current_image.numpy() * 255).astype(np.uint8))
            input_pil_mask = Image.fromarray((current_mask.numpy() * 255).astype(np.uint8))
            
            W, H = input_pil_image.size

            processed_image_pil = input_pil_image.copy()
            processed_image_pil = ImageOps.exif_transpose(processed_image_pil)

            processed_mask_pil = input_pil_mask.copy()
            processed_mask_pil = ImageOps.exif_transpose(processed_mask_pil)

            if processed_image_pil.mode == 'P':
                processed_image_pil = processed_image_pil.convert("RGBA")
            elif 'A' in processed_image_pil.getbands():
                processed_image_pil = processed_image_pil.convert("RGBA")

            if processed_mask_pil.mode != "L":
                processed_mask_pil = processed_mask_pil.convert("L")

            if size_option != "Custom":
                aspect_ratio = W / H

                size_options = {
                    "Small": (
                        (768, 512) if aspect_ratio >= 1.23 else
                        (512, 768) if aspect_ratio <= 0.82 else
                        (768, 768)
                    ),
                    "Medium": (
                        (1216, 832) if aspect_ratio >= 1.23 else
                        (832, 1216) if aspect_ratio <= 0.82 else
                        (1216, 1216)
                    ),
                    "Large": (
                        (1600, 1120) if aspect_ratio >= 1.23 else
                        (1120, 1600) if aspect_ratio <= 0.82 else
                        (1600, 1600)
                    ),
                    "Million Pixels": self._resize_to_million_pixels(W, H),
                    "480P-H(vid 4:3)": (640, 480),
                    "480P-V(vid 3:4)": (480, 640),
                    "720P-H(vid 16:9)": (1280, 720),
                    "720P-V(vid 9:16)": (720, 1280),
                    "832×480": (832, 480),
                    "480×832": (480, 832)
                }

                target_width, target_height = size_options[size_option]
                processed_image_pil = processed_image_pil.convert("RGB")
                processed_image_pil = ImageOps.fit(processed_image_pil, (target_width, target_height), method=Image.Resampling.BILINEAR, centering=(0.5, 0.5))
                
                processed_mask_pil = ImageOps.fit(processed_mask_pil, (target_width, target_height), method=Image.Resampling.BILINEAR, centering=(0.5, 0.5))
            else:
                ratio = min(max_dimension / W, max_dimension / H)
                adjusted_width = round(W * ratio)
                adjusted_height = round(H * ratio)

                processed_image_pil = processed_image_pil.convert("RGB")
                processed_image_pil = processed_image_pil.resize((adjusted_width, adjusted_height), Image.Resampling.BILINEAR)
                
                processed_mask_pil = processed_mask_pil.resize((adjusted_width, adjusted_height), Image.Resampling.BILINEAR)

            processed_image = np.array(processed_image_pil).astype(np.float32) / 255.0
            processed_image = torch.from_numpy(processed_image)
            processed_images.append(processed_image)

            processed_mask = np.array(processed_mask_pil).astype(np.float32) / 255.0
            processed_mask = torch.from_numpy(processed_mask)
            processed_masks.append(processed_mask)

            if size_option != "Custom":
                widths.append(target_width)
                heights.append(target_height)
            else:
                widths.append(adjusted_width)
                heights.append(adjusted_height)

        output_image = torch.stack(processed_images)
        output_mask = torch.stack(processed_masks)
        
        if all(w == widths[0] for w in widths) and all(h == heights[0] for h in heights):
            return (output_image, output_mask, widths[0], heights[0])
        else:
            return (output_image, output_mask, widths[0], heights[0])

    def _resize_to_million_pixels(self, W, H):
        aspect_ratio = W / H
        target_area = 1000000
        
        if aspect_ratio > 1:
            width = int(np.sqrt(target_area * aspect_ratio))
            height = int(target_area / width)
        else:
            height = int(np.sqrt(target_area / aspect_ratio))
            width = int(target_area / height)

        width = (width + 7) // 8 * 8
        height = (height + 7) // 8 * 8
        
        return width, height


#======裁剪图像
class CustomCrop:
    @classmethod
    def INPUT_TYPES(cls):
        return {
            "required": {
                "image": ("IMAGE",),
                "mask": ("MASK",),  # 新增遮罩输入
                "width": ("INT", {"default": 768, "min": 0, "max": 4096, "step": 8}),
                "height": ("INT", {"default": 768, "min": 0, "max": 4096, "step": 8}),
            }
        }

    RETURN_TYPES = ("IMAGE", "MASK", "INT", "INT")  # 新增遮罩输出
    RETURN_NAMES = ("image", "mask", "width", "height")
    FUNCTION = "process_image"
    CATEGORY = "Meeeyo/File"
    DESCRIPTION = note
    def IS_CHANGED(): return float("NaN")

    def process_image(self, image, mask, width=768, height=768):
        input_image = Image.fromarray((image.squeeze(0).numpy() * 255).astype(np.uint8))
        input_mask = Image.fromarray((mask.squeeze(0).numpy() * 255).astype(np.uint8))  # 转换遮罩为PIL图像
        
        W, H = input_image.size

        processed_images = []
        processed_masks = []  # 新增遮罩处理列表

        for frame in [input_image]:
            frame = ImageOps.exif_transpose(frame)

            if frame.mode == 'P':
                frame = frame.convert("RGBA")
            elif 'A' in frame.getbands():
                frame = frame.convert("RGBA")

            processed_image = frame.convert("RGB")
            processed_image = ImageOps.fit(processed_image, (width, height), method=Image.Resampling.BILINEAR, centering=(0.5, 0.5))

            processed_image = np.array(processed_image).astype(np.float32) / 255.0
            processed_image = torch.from_numpy(processed_image)[None,]
            processed_images.append(processed_image)

        # 处理遮罩
        input_mask = ImageOps.exif_transpose(input_mask)
        processed_mask = input_mask.convert("L")  # 确保遮罩是灰度图像
        processed_mask = ImageOps.fit(processed_mask, (width, height), method=Image.Resampling.BILINEAR, centering=(0.5, 0.5))
        processed_mask = np.array(processed_mask).astype(np.float32) / 255.0
        processed_mask = torch.from_numpy(processed_mask)[None,]
        processed_masks.append(processed_mask)

        output_image = torch.cat(processed_images, dim=0) if len(processed_images) > 1 else processed_images[0]
        output_mask = torch.cat(processed_masks, dim=0) if len(processed_masks) > 1 else processed_masks[0]

        return (output_image, output_mask, width, height)


#======保存图像
class SaveImagEX:
    def __init__(self):
        self.output_dir = folder_paths.get_output_directory()

    @classmethod
    def INPUT_TYPES(cls):
        return {
            "required": {
                "image": ("IMAGE",),
                "save_path": ("STRING", {"default": "./output"}),
                "image_name": ("STRING", {"default": "ComfyUI"}),
                "image_format": (["PNG", "JPG"], {"default": "JPG"})
            },
        }

    RETURN_TYPES = ("IMAGE",)
    RETURN_NAMES = ("image",)
    FUNCTION = "save_image"
    OUTPUT_NODE = True
    CATEGORY = "Meeeyo/File"
    DESCRIPTION = note
    def IS_CHANGED(): return float("NaN")

    def save_image(self, image, save_path, image_name, image_format):
        if not isinstance(image, torch.Tensor):
            raise ValueError("Invalid image tensor format")
        if save_path == "./output":
            save_path = self.output_dir
        elif not os.path.isabs(save_path):
            save_path = os.path.join(self.output_dir, save_path)
        os.makedirs(save_path, exist_ok=True)
        
        # 移除可能存在的扩展名，然后添加用户选择的格式对应的扩展名
        base_name = os.path.splitext(image_name)[0]
        
        batch_size = image.shape[0]
        channel_to_mode = {1: "L", 3: "RGB", 4: "RGBA"}

        for i in range(batch_size):
            if image_format == "PNG":
                filename = f"{base_name}.png" if batch_size == 1 else f"{base_name}_{i:05d}.png"
                save_format = "PNG"
                save_params = {"compress_level": 0}
            else:  # JPG
                filename = f"{base_name}.jpg" if batch_size == 1 else f"{base_name}_{i:05d}.jpg"
                save_format = "JPEG"
                save_params = {"quality": 100}
            
            full_path = os.path.join(save_path, filename)
            single_image = image[i].cpu().numpy()
            single_image = (single_image * 255).astype('uint8')
            channels = single_image.shape[2]
            if channels not in channel_to_mode:
                raise ValueError(f"Unsupported channel number: {channels}")
            mode = channel_to_mode[channels]
            if channels == 1:
                single_image = single_image[:, :, 0]
            pil_image = Image.fromarray(single_image, mode)
            
            if image_format == "JPG":
                pil_image = pil_image.convert("RGB")
            
            pil_image.save(full_path, format=save_format, **save_params)
        return (image,)


#======文件操作
class FileCopyCutNode:
    @classmethod
    def INPUT_TYPES(cls):
        return {
            "required": {
                "source_path": ("STRING", {"default": "", "multiline": False}),
                "destination_path": ("STRING", {"default": "", "multiline": False}),
                "operation": (["copy", "cut"], {"default": "copy"}),
            },
            "optional": {"any": (any_typ,)}  # 可以进一步简化成一行
        }

    RETURN_TYPES = ("STRING",)  # 返回操作结果字符串
    RETURN_NAMES = ("result",)
    FUNCTION = "copy_cut_file"
    CATEGORY = "Meeeyo/File"
    DESCRIPTION = note
    def IS_CHANGED(): return float("NaN")

    def copy_cut_file(self, source_path, destination_path, operation, any=None):
        result = "执行失败"
        try:
            if not os.path.isfile(source_path):
                raise FileNotFoundError(f"源文件未找到: {source_path}")

            os.makedirs(os.path.dirname(destination_path), exist_ok=True)

            if operation == "copy":
                shutil.copy2(source_path, destination_path)
                result = "执行成功: 文件已复制"
            elif operation == "cut":
                shutil.move(source_path, destination_path)
                result = "执行成功: 文件已剪切"
            else:
                raise ValueError("操作类型无效，仅支持 'copy' 或 'cut'。")
        except FileNotFoundError as e:
            result = f"执行失败: {str(e)}"
        except ValueError as e:
            result = f"执行失败: {str(e)}"
        except Exception as e:
            result = f"执行失败: {str(e)}"

        return (result,)


#======替换文件名
class FileNameReplacer:
    @classmethod
    def INPUT_TYPES(cls):
        return {
            "required": {
                "file_path": ("STRING", {"default": "path/to/your/file.jpg"}),
                "new_file_name": ("STRING", {"default": ""}),
            },
            "optional": {"any": (any_typ,)} 
        }

    RETURN_TYPES = ("STRING",)
    FUNCTION = "replace_file_name"
    CATEGORY = "Meeeyo/File"
    DESCRIPTION = note
    def IS_CHANGED(): return float("NaN")

    def replace_file_name(self, file_path, new_file_name, any=None):
        dir_name = os.path.dirname(file_path)
        _, file_ext = os.path.splitext(file_path)
        new_file_name = self.sanitize_file_name(new_file_name)
        new_file_path = os.path.join(dir_name, new_file_name + file_ext)
        return (new_file_path,)
    def sanitize_file_name(self, file_name):
        invalid_chars = r'[\/:*?"<>|]'
        return re.sub(invalid_chars, '_', file_name)


#======文本写入TXT
class WriteToTxtFile:
    @classmethod
    def INPUT_TYPES(cls):
        return {
            "required": {
                "text_content": ("STRING", {"default": "", "multiline": True}),
                "file_path": ("STRING", {"default": "path/to/your/file.txt"}),
            },
            "optional": {"any": (any_typ,)} 
        }

    RETURN_TYPES = ("STRING",)
    FUNCTION = "write_to_txt"
    CATEGORY = "Meeeyo/File"
    DESCRIPTION = note
    def IS_CHANGED(): return float("NaN")

    def write_to_txt(self, text_content, file_path, any=None):
        try:
            dir_path = os.path.dirname(file_path)
            if not os.path.exists(dir_path):
                os.makedirs(dir_path)
            file_exists = os.path.exists(file_path)
            mode = 'a' if file_exists else 'w'
            
            with open(file_path, mode, encoding='utf-8') as f:
                if file_exists:
                    f.write('\n\n') 
                f.write(text_content)
            return ("Write successful: " + text_content,)
        except Exception as e:
            return (f"Error: {str(e)}",)


#======清理文件
class FileDeleteNode:
    @classmethod
    def INPUT_TYPES(cls):
        return {
            "required": {
                "items_to_delete": ("STRING", {"default": "33.png\ncs1/01.png\ncs1", "multiline": True}),
            },
            "optional": {"any": (any_typ,)} 
        }
    
    RETURN_TYPES = ("STRING",)
    RETURN_NAMES = ("result",)
    FUNCTION = "delete_files"
    CATEGORY = "Meeeyo/File"
    DESCRIPTION = note
    def IS_CHANGED(): return float("NaN")

    def delete_files(self, items_to_delete, any=None):
        result = "执行成功: 所有指定项已从output目录删除"
        error_messages = []
        base_output_dir = Path.cwd() / COMFYUI_OUTPUT_DIR
        items = items_to_delete.strip().split('\n')

        for item in items:
            item = item.strip()
            if not item:
                continue
            if item == "[DeleteAll]":
                try:
                    for file_or_dir in base_output_dir.glob('*'):
                        if file_or_dir.is_file() or file_or_dir.is_symlink():
                            file_or_dir.unlink()
                        elif file_or_dir.is_dir():
                            shutil.rmtree(file_or_dir)
                    continue
                except Exception as e:
                    error_messages.append(f"从output目录删除全部失败: {str(e)}")
                    continue
            target_path = base_output_dir / item
            try:
                target_path.relative_to(base_output_dir)
            except ValueError:
                error_messages.append(f"{item} 不在output目录范围内，无法删除")
                continue
            if not target_path.exists():
                error_messages.append(f"在output目录下找不到 {item}")
                continue
            try:
                if target_path.is_file() or target_path.is_symlink():
                    target_path.unlink()
                elif target_path.is_dir():
                    shutil.rmtree(target_path)
            except Exception as e:
                error_messages.append(f"从output目录删除 {item} 失败: {str(e)}")
        if error_messages:
            result = "部分执行失败:\n" + "\n".join(error_messages)
        return (result,)


#======文件路径和后缀统计
class FileListAndSuffix:
    @classmethod
    def INPUT_TYPES(cls):
        return {
            "required": {
                "folder_path": ("STRING",),
                "file_extension": (["jpg", "png", "jpg&png", "txt", "csv", "all"], {"default": "jpg"}),
            },
            "optional": {"any": (any_typ,)} 
        }

    RETURN_TYPES = ("STRING", "INT", "LIST")
    FUNCTION = "file_list_and_suffix"
    CATEGORY = "Meeeyo/File"
    DESCRIPTION = note
    def IS_CHANGED(): return float("NaN")

    def file_list_and_suffix(self, folder_path, file_extension, any=None):
        try:
            if not os.path.isdir(folder_path):
                return ("", 0, [])

            if file_extension == "all":
                file_paths = [os.path.join(folder_path, f) for f in os.listdir(folder_path) if os.path.isfile(os.path.join(folder_path, f))]
            elif file_extension == "jpg&png":
                file_paths = [os.path.join(folder_path, f) for f in os.listdir(folder_path) if f.lower().endswith(('.jpg', '.png'))]
            else:
                file_paths = [os.path.join(folder_path, f) for f in os.listdir(folder_path) if f.lower().endswith('.' + file_extension)]

            return ('\n'.join(file_paths), len(file_paths), file_paths)
        except Exception as e:
            return ("", 0, [])


#======文字图像
class TextToImage:
    @classmethod
    def INPUT_TYPES(cls):
        fonts_dir = os.path.join(os.path.dirname(os.path.realpath(__file__)), "fonts")
        if not os.path.exists(fonts_dir):
            os.makedirs(fonts_dir)
            font_files = []
        else:
            font_files = [file for file in os.listdir(fonts_dir) if file.lower().endswith(('.ttf', '.otf'))]
        font_files = font_files or ["arial.ttf"]
        return {
            "required": {
                "text": ("STRING", {"default": "Hello, World!", "multiline": True}),
                "font": (font_files, ),
                "max_width": ("INT", {"default": 300, "min": 1, "max": 2048, "step": 1}),
                "font_properties": ("STRING", {"default": "#FFFFFF,1,1,C,1", "multiline": False}),
                "font_stroke": ("STRING", {"default": "#000000,2,1", "multiline": False}),
                "font_background": ("STRING", {"default": "#333333,5,10,1", "multiline": False})
            },
            "optional": {"any": (any_typ,)} 
        }
    RETURN_TYPES = ("IMAGE",)
    FUNCTION = "generate_text_image"
    CATEGORY = "Meeeyo/File"
    DESCRIPTION = note
    def IS_CHANGED(): return float("NaN")

    def generate_text_image(self, text, font, max_width, font_properties, font_stroke, font_background):
        fonts_dir = os.path.join(os.path.dirname(os.path.realpath(__file__)), "fonts")
        font_path = os.path.join(fonts_dir, font)
        try:
            font = ImageFont.truetype(font_path, 1)
        except Exception as e:
            return None

        draw = ImageDraw.Draw(Image.new('RGBA', (1, 1)))
        lines = text.split("\n")
        max_text_width = 0
        text_height = 0
        for line in lines:
            left, top, right, bottom = draw.textbbox((0, 0), line, font=font)
            line_width = right - left
            line_height = bottom - top
            max_text_width = max(max_text_width, line_width)
            text_height += line_height

        if max_text_width == 0:
            max_text_width = 1

        ratio = max_width / max_text_width
        new_font_size = int(1 * ratio)
        font = ImageFont.truetype(font_path, new_font_size)

        font_color = "#FFFFFF"
        letter_spacing_factor = 1.0
        line_spacing_factor = 1.0
        alignment = "C"
        opacity = 1.0
        stroke_color = "#000000"
        stroke_width = 0.0
        stroke_opacity = 1.0
        background_color = "#333333"
        expand_width = 5
        corner_radius = 10
        background_opacity = 0.9

        try:
            if font_properties.strip() == "":
                font_color = "#FFFFFF"
                letter_spacing_factor = 1.0
                line_spacing_factor = 1.0
                alignment = "C"
                opacity = 1.0
            else:
                props = font_properties.split(',')
                if len(props) >= 5:
                    font_color = props[0].strip()
                    letter_spacing_factor = float(props[1]) if props[1] else 1.0
                    line_spacing_factor = float(props[2]) if props[2] else 1.0
                    alignment = props[3].strip().upper()
                    opacity = float(props[4]) if props[4] else 1.0
                else:
                    font_color = "#FFFFFF"
                    letter_spacing_factor = 1.0
                    line_spacing_factor = 1.0
                    alignment = "C"
                    opacity = 1.0
        except:
            font_color = "#FFFFFF"
            letter_spacing_factor = 1.0
            line_spacing_factor = 1.0
            alignment = "C"
            opacity = 1.0

        try:
            if font_stroke.strip() == "":
                stroke_width = 0.0
            else:
                stroke_props = font_stroke.split(',')
                if len(stroke_props) >= 3:
                    stroke_color = stroke_props[0].strip()
                    stroke_width = float(stroke_props[1]) if stroke_props[1] else 1.0
                    stroke_opacity = float(stroke_props[2]) if stroke_props[2] else 1.0
                else:
                    stroke_width = 0.0
        except:
            stroke_width = 0.0

        try:
            if font_background.strip() == "":
                background_color = None
            else:
                bg_props = font_background.split(',')
                if len(bg_props) >= 4:
                    background_color = bg_props[0].strip()
                    expand_width = int(bg_props[1]) if bg_props[1] else 5
                    corner_radius = int(bg_props[2]) if bg_props[2] else 10
                    background_opacity = float(bg_props[3]) if bg_props[3] else 0.9
                else:
                    background_color = None
        except:
            background_color = None

        actual_max_width = 0
        for line in lines:
            line_width = 0
            for char in line:
                char_width = draw.textbbox((0, 0), char, font=font)[2]
                line_width += char_width + (font.size * (letter_spacing_factor - 1))
            actual_max_width = max(actual_max_width, line_width)

        if actual_max_width > max_width:
            ratio = max_width / actual_max_width
            new_font_size = int(new_font_size * ratio)
            font = ImageFont.truetype(font_path, new_font_size)

        font_ascent, font_descent = font.getmetrics()
        line_height = font_ascent + font_descent

        if len(lines) > 1:
            text_height = line_height * (len(lines) - 1) * line_spacing_factor + line_height
        else:
            text_height = line_height

        image_width = max_width
        image_height = int(text_height + new_font_size * 0.2)
        image = Image.new('RGBA', (image_width, image_height), (0, 0, 0, 0))
        draw = ImageDraw.Draw(image)

        if background_color is not None:
            try:
                background_color_tuple = (
                    int(background_color[1:3], 16),
                    int(background_color[3:5], 16),
                    int(background_color[5:7], 16),
                    int(background_opacity * 255)
                )
                draw.rounded_rectangle(
                    [0, 0, image_width, image_height],
                    fill=background_color_tuple,
                    radius=corner_radius
                )
            except:
                pass

        y_text = new_font_size * 0.1
        try:
            font_color_tuple = (
                int(font_color[1:3], 16),
                int(font_color[3:5], 16),
                int(font_color[5:7], 16),
                int(opacity * 255)
            )
            stroke_color_tuple = (
                int(stroke_color[1:3], 16),
                int(stroke_color[3:5], 16),
                int(stroke_color[5:7], 16),
                int(stroke_opacity * 255)
            )
        except:
            font_color_tuple = (255, 255, 255, 255)
            stroke_color_tuple = (0, 0, 0, 255)

        for i, line in enumerate(lines):
            line_width = 0
            for char in line:
                char_width = draw.textbbox((0, 0), char, font=font)[2]
                line_width += char_width + (font.size * (letter_spacing_factor - 1))
            line_width = max(line_width, 1)

            if alignment == "L":
                x = 0
            elif alignment == "R":
                x = max_width - line_width
            else:
                x = (max_width - line_width) / 2

            if stroke_width > 0:
                for sx in range(-int(stroke_width), int(stroke_width) + 1):
                    for sy in range(-int(stroke_width), int(stroke_width) + 1):
                        if sx == 0 and sy == 0:
                            continue
                        char_x = x + sx
                        char_y = y_text + sy
                        for char in line:
                            char_width = draw.textbbox((0, 0), char, font=font)[2]
                            draw.text((char_x, char_y), char, font=font, fill=stroke_color_tuple)
                            char_x += char_width + (font.size * (letter_spacing_factor - 1))

            char_x = x
            for char in line:
                char_width = draw.textbbox((0, 0), char, font=font)[2]
                draw.text((char_x, y_text), char, font=font, fill=font_color_tuple)
                char_x += char_width + (font.size * (letter_spacing_factor - 1))

            if i < len(lines) - 1:
                y_text += line_height * line_spacing_factor
            else:
                y_text += line_height

        image_data = np.array(image)
        alpha_channel = image_data[:, :, 3]
        non_zero_indices = np.where(alpha_channel > 0)
        if len(non_zero_indices[0]) > 0:
            min_y = np.min(non_zero_indices[0])
            max_y = np.max(non_zero_indices[0])
            min_x = np.min(non_zero_indices[1])
            max_x = np.max(non_zero_indices[1])
            image = image.crop((min_x, min_y, max_x + 1, max_y + 1))
        else:
            pass

        text_content_width = max_x - min_x + 1 if len(non_zero_indices[0]) > 0 else max_width

        image_width, image_height = image.size
        if text_content_width < max_width:
            new_image = Image.new('RGBA', (max_width, image_height), (0, 0, 0, 0))
            new_draw = ImageDraw.Draw(new_image)
            x_offset = (max_width - text_content_width) // 2
            new_image.paste(image, (x_offset, 0))
            image = new_image

        image_width, image_height = image.size
        if image_width > max_width:
            height_ratio = image_height / image_width
            image = image.resize((max_width, int(max_width * height_ratio)))

        image_np = np.array(image).astype(np.float32) / 255.0
        image_tensor = torch.from_numpy(image_np).unsqueeze(0)

        return (image_tensor,)


#======图像层叠加
class ImageOverlayAlignment:
    @classmethod
    def INPUT_TYPES(cls):
        return {
            "required": {
                "image1": ("IMAGE", {"forceInput": True}),
                "image2": ("IMAGE", {"forceInput": True}),
                "alignment": (["top_left", "top_center", "top_right", "bottom_left", "bottom_center", "bottom_right", "center"], ),
                "scale": ("FLOAT", {"default": 1.0, "min": 0.1, "max": 10.0, "step": 0.1}),
                "opacity": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 1.0, "step": 0.1}),
                "offset": ("STRING", {"default": "0,0,0,0", "multiline": False})
            }
        }

    RETURN_TYPES = ("IMAGE",)
    FUNCTION = "overlay_images"
    CATEGORY = "Meeeyo/File"
    DESCRIPTION = note
    def IS_CHANGED(): return float("NaN")

    def overlay_images(self, image1, image2, alignment, offset, scale, opacity):
        image1_np = image1.cpu().numpy().squeeze()
        image2_np = image2.cpu().numpy().squeeze()
        img1 = Image.fromarray((image1_np * 255).astype(np.uint8)).convert('RGBA')
        img2 = Image.fromarray((image2_np * 255).astype(np.uint8)).convert('RGBA')
        img1_width, img1_height = img1.size
        new_width = int(img1_width * scale)
        new_height = int(img1_height * scale)
        img1 = img1.resize((new_width, new_height), Image.LANCZOS)
        img1 = self.adjust_opacity(img1, opacity)
        img1_width, img1_height = img1.size
        img2_width, img2_height = img2.size
        max_width = max(img1_width, img2_width)
        max_height = max(img1_height, img2_height)
        canvas = Image.new('RGBA', (max_width, max_height), (0, 0, 0, 0))
        if alignment == "top_left":
            img2_x, img2_y = 0, 0
        elif alignment == "top_center":
            img2_x = (max_width - img2_width) // 2
            img2_y = 0
        elif alignment == "top_right":
            img2_x = max_width - img2_width
            img2_y = 0
        elif alignment == "bottom_left":
            img2_x = 0
            img2_y = max_height - img2_height
        elif alignment == "bottom_center":
            img2_x = (max_width - img2_width) // 2
            img2_y = max_height - img2_height
        elif alignment == "bottom_right":
            img2_x = max_width - img2_width
            img2_y = max_height - img2_height
        elif alignment == "center":
            img2_x = (max_width - img2_width) // 2
            img2_y = (max_height - img2_height) // 2

        right_offset, left_offset, down_offset, up_offset = 0, 0, 0, 0
        offset_list = offset.split(',')
        if len(offset_list) >= 4:
            try:
                right_offset = int(offset_list[0]) if offset_list[0] else 0
                left_offset = int(offset_list[1]) if offset_list[1] else 0
                down_offset = int(offset_list[2]) if offset_list[2] else 0
                up_offset = int(offset_list[3]) if offset_list[3] else 0
            except ValueError:
                pass
        if alignment == "top_left":
            img1_x, img1_y = 0, 0
        elif alignment == "top_center":
            img1_x = (max_width - img1_width) // 2
            img1_y = 0
        elif alignment == "top_right":
            img1_x = max_width - img1_width
            img1_y = 0
        elif alignment == "bottom_left":
            img1_x = 0
            img1_y = max_height - img1_height
        elif alignment == "bottom_center":
            img1_x = (max_width - img1_width) // 2
            img1_y = max_height - img1_height
        elif alignment == "bottom_right":
            img1_x = max_width - img1_width
            img1_y = max_height - img1_height
        elif alignment == "center":
            img1_x = (max_width - img1_width) // 2
            img1_y = (max_height - img1_height) // 2
        img1_x += right_offset - left_offset
        img1_y += down_offset - up_offset
        img1_x = max(0, min(img1_x, max_width - img1_width))
        img1_y = max(0, min(img1_y, max_height - img1_height))
        img2_x = max(0, min(img2_x, max_width - img2_width))
        img2_y = max(0, min(img2_y, max_height - img2_height))
        canvas.paste(img2, (img2_x, img2_y), img2.split()[-1])
        canvas.paste(img1, (img1_x, img1_y), img1.split()[-1])
        output_image = np.array(canvas).astype(np.float32) / 255.0
        output_tensor = torch.from_numpy(output_image).unsqueeze(0)
        return (output_tensor,)

    def adjust_opacity(self, img, opacity):
        if opacity < 1.0:
            img = img.copy() 
            alpha = np.array(img.split()[-1]) * opacity
            alpha = alpha.astype(np.uint8)
            img.putalpha(Image.fromarray(alpha))
        return img


#======读取表格数据
class ReadExcelData:
    @classmethod
    def INPUT_TYPES(cls):
        return {
            "required": {
                "excel_path": ("STRING", {"default": "path/to/your/file.xlsx"}),
                "sheet_name": ("STRING", {"default": "Sheet1"}),
                "row_range": ("STRING", {"default": "2-3"}),
                "col_range": ("STRING", {"default": "1-4"}),
            },
            "optional": {"any": (any_typ,)} 
        }

    RETURN_TYPES = ("STRING",)
    FUNCTION = "read_excel_data"
    CATEGORY = "Meeeyo/File"
    DESCRIPTION = note
    def IS_CHANGED(): return float("NaN")

    def read_excel_data(self, excel_path, sheet_name, row_range, col_range, any=None):
        try:
            if "-" in row_range:
                start_row, end_row = map(int, row_range.split("-"))
            else:
                start_row = end_row = int(row_range)

            if "-" in col_range:
                start_col, end_col = map(int, col_range.split("-"))
            else:
                start_col = end_col = int(col_range)

            start_row = max(1, start_row)
            start_col = max(1, start_col)

            workbook = openpyxl.load_workbook(excel_path, read_only=True, data_only=True)
            sheet = workbook[sheet_name]

            output_lines = []
            for row in range(start_row, end_row + 1):
                row_data = []
                for col in range(start_col, end_col + 1):
                    cell_value = sheet.cell(row=row, column=col).value
                    row_data.append(str(cell_value) if cell_value is not None else "")
                output_lines.append("|".join(row_data))

            workbook.close()
            del workbook

            return ("\n".join(output_lines),)

        except Exception as e:
            return (f"Error: {str(e)}",)


#======写入表格数据
class WriteExcelData:
    @classmethod
    def INPUT_TYPES(cls):
        return {
            "required": {
                "excel_path": ("STRING", {"default": "path/to/your/file.xlsx"}),
                "sheet_name": ("STRING", {"default": "Sheet1"}), 
                "row_range": ("STRING", {"default": "2-3"}),
                "col_range": ("STRING", {"default": "1-4"}),
                "data": ("STRING", {"default": "", "multiline": True}),
            },
            "optional": {"any": (any_typ,)} 
        }

    RETURN_TYPES = ("STRING",)
    FUNCTION = "write_excel_data"
    CATEGORY = "Meeeyo/File"
    DESCRIPTION = note
    def IS_CHANGED(): return float("NaN")

    def write_excel_data(self, excel_path, sheet_name, row_range, col_range, data, any=None):
        try:
            if not os.path.exists(excel_path):
                return (f"Error: File does not exist at path: {excel_path}",)

            if not os.access(excel_path, os.W_OK):
                return (f"Error: No write permission for file at path: {excel_path}",)

            if "-" in row_range:
                start_row, end_row = map(int, row_range.split("-"))
            else:
                start_row = end_row = int(row_range)

            if "-" in col_range:
                start_col, end_col = map(int, col_range.split("-"))
            else:
                start_col = end_col = int(col_range)

            start_row = max(1, start_row)
            start_col = max(1, start_col)

            workbook = openpyxl.load_workbook(excel_path, read_only=False, data_only=True)
            sheet = workbook[sheet_name]

            data_lines = data.strip().split("\n")

            for row_index, line in enumerate(data_lines, start=start_row):
                if row_index > end_row:
                    break

                cell_values = line.split("|")
                for col_index, cell_value in enumerate(cell_values, start=start_col):
                    if col_index > end_col:
                        break

                    if cell_value.strip():
                        sheet.cell(row=row_index, column=col_index).value = cell_value.strip()

            workbook.save(excel_path)

            workbook.close()
            del workbook

            return ("Data written successfully!",)

        except PermissionError as pe:
            return (f"Permission Error: {str(pe)}",)
        except Exception as e:
            return (f"Error: {str(e)}",)


#======图片插入表格
class WriteExcelImage:
    @classmethod
    def INPUT_TYPES(cls):
        return {
            "required": {
                "excel_path": ("STRING", {"default": "path/to/your/file.xlsx"}),
                "sheet_name": ("STRING", {"default": "Sheet1"}),
                "row_range": ("STRING", {"default": "1"}),
                "col_range": ("STRING", {"default": "1"}),
                "image_path": ("STRING", {"default": "path/to/your/image.png"}),
            },
            "optional": {"any": (any_typ,)} 
        }

    RETURN_TYPES = ("STRING",)
    FUNCTION = "write_image"
    CATEGORY = "Meeeyo/File"
    DESCRIPTION = note
    def IS_CHANGED(): return float("NaN")

    def write_image(self, excel_path, sheet_name, row_range, col_range, image_path, any=None):
        try:
            if not os.path.exists(excel_path):
                return (f"Error: Excel file does not exist at path: {excel_path}",)
            if not os.access(excel_path, os.W_OK):
                return (f"Error: No write permission for Excel file at path: {excel_path}",)
            if not os.path.exists(image_path):
                return (f"Error: Image file does not exist at path: {image_path}",)
            if not os.access(image_path, os.R_OK):
                return (f"Error: No read permission for image file at path: {image_path}",)
            if "-" in row_range:
                start_row, end_row = map(int, row_range.split("-"))
            else:
                start_row = end_row = int(row_range)
            if "-" in col_range:
                start_col, end_col = map(int, col_range.split("-"))
            else:
                start_col = end_col = int(col_range)
            start_row = max(1, start_row)
            start_col = max(1, start_col)
            workbook = openpyxl.load_workbook(excel_path, read_only=False, data_only=True)
            sheet = workbook[sheet_name]
            thumbnail_size = (128, 128)
            with PILImage.open(image_path) as img:
                img = img.resize(thumbnail_size)
                img_byte_array = BytesIO()
                img.save(img_byte_array, format='PNG')
                img_byte_array.seek(0)
                openpyxl_img = OpenpyxlImage(img_byte_array)
            cell_address = openpyxl.utils.get_column_letter(start_col) + str(start_row)
            sheet.add_image(openpyxl_img, cell_address)
            workbook.save(excel_path)
            workbook.close()
            return ("Image inserted successfully!",)
        except PermissionError as pe:
            return (f"Permission Error: {str(pe)}",)
        except Exception as e:
            return (f"Error: {str(e)}",)


#======查找表格数据
class FindExcelData:
    @classmethod
    def INPUT_TYPES(cls):
        return {
            "required": {
                "excel_path": ("STRING", {"default": "path/to/your/file.xlsx"}),
                "sheet_name": ("STRING", {"default": "Sheet1"}),
                "search_content": ("STRING", {"default": "查找内容"}),
                "search_mode": (["精确查找", "模糊查找"], {"default": "精确查找"}),
            },
            "optional": {"any": (any_typ,)} 
        }

    RETURN_TYPES = ("STRING", "INT", "INT")
    FUNCTION = "find_excel_data"
    CATEGORY = "Meeeyo/File"
    DESCRIPTION = note
    def IS_CHANGED(): return float("NaN")

    def find_excel_data(self, excel_path, sheet_name, search_content, search_mode, any=None):
        try:
            if not os.path.exists(excel_path):
                return (f"Error: File does not exist at path: {excel_path}", None, None)
            if not os.access(excel_path, os.R_OK):
                return (f"Error: No read permission for file at path: {excel_path}", None, None)
            workbook = openpyxl.load_workbook(excel_path, read_only=True, data_only=True)
            sheet = workbook[sheet_name]

            results = []
            found_row = None
            found_col = None
            for row in range(1, sheet.max_row + 1):
                for col in range(1, sheet.max_column + 1):
                    cell = sheet.cell(row=row, column=col)
                    cell_value = cell.value if cell.value is not None else ""
                    cell_value_str = str(cell_value)
                    if (search_mode == "精确查找" and cell_value_str == search_content) or \
                       (search_mode == "模糊查找" and search_content in cell_value_str):
                        results.append(f"{sheet_name}|{row}|{col}|{cell_value}")
                        found_row = row
                        found_col = col

            workbook.close()
            del workbook
            if not results:
                return ("No results found.", None, None)
            return ("\n".join(results), found_row, found_col)
        except Exception as e:
            return (f"Error: {str(e)}", None, None)


#======读取表格数量差
class ReadExcelRowOrColumnDiff:
    @classmethod
    def INPUT_TYPES(cls):
        return {
            "required": {
                "excel_path": ("STRING", {"default": "path/to/your/file.xlsx"}),
                "sheet_name": ("STRING", {"default": "Sheet1"}),
                "read_mode": (["读行", "读列"], {"default": "读行"}),
                "indices": ("STRING", {"default": "1,3"}),
            },
            "optional": {"any": (any_typ,)} 
        }

    RETURN_TYPES = ("INT",)
    FUNCTION = "read_excel_row_or_column_diff"
    CATEGORY = "Meeeyo/File"
    DESCRIPTION = note
    def IS_CHANGED(): return float("NaN")

    def read_excel_row_or_column_diff(self, excel_path, sheet_name, read_mode, indices, any=None):
        try:
            if not os.path.exists(excel_path):
                return (f"Error: File does not exist at path: {excel_path}",)

            if not os.access(excel_path, os.R_OK):
                return (f"Error: No read permission for file at path: {excel_path}",)

            workbook = openpyxl.load_workbook(excel_path, read_only=True, data_only=True)
            sheet = workbook[sheet_name]

            def count_cells(mode, index):
                count = 0
                if mode == "读行":
                    for col in range(1, sheet.max_column + 1):
                        cell_value = sheet.cell(row=index, column=col).value
                        if cell_value is not None:
                            count += 1
                        else:
                            break
                elif mode == "读列":
                    for row in range(1, sheet.max_row + 1):
                        cell_value = sheet.cell(row=row, column=index).value
                        if cell_value is not None:
                            count += 1
                        else:
                            break
                return count

            indices = indices.strip()
            if "," in indices:
                try:
                    index1, index2 = map(int, indices.split(","))
                except ValueError:
                    return (f"Error: Invalid indices format. Please use 'number,number' format.",)

                count1 = count_cells(read_mode, index1)
                count2 = count_cells(read_mode, index2)
                result = count1 - count2
            else:
                try:
                    index = int(indices)
                except ValueError:
                    return (f"Error: Invalid index format. Please enter a valid number.",)

                result = count_cells(read_mode, index)

            workbook.close()
            del workbook

            return (result,)

        except Exception as e:
            return (f"Error: {str(e)}",)