app.py

import gradio as gr
import numpy as np
from PIL import Image, ImageDraw, ImageFont, ImageColor, ImageFilter, ImageSequence
import os
import qrcode
from datetime import datetime
import pytz
import paramiko
import io
import re
import random
import zipfile
import math
import shutil

folder_path = "cache"  # 리덱토리/cache 경로
ips = os.getenv("hjip")
# 폴더가 존재하는지 확인
if os.path.exists(folder_path):
    print("Exist!")  # 폴더가 이미 존재할 경우 출력
else:
    os.makedirs(folder_path)  # 폴더가 없으면 폴더 생성
    print(f"폴더 '{folder_path}'를 생성했습니다.")


def zip_folder(folder_path, output_path):
    # 압축할 폴더 경로
    folder_path = os.path.abspath(folder_path)

    # 출력 파일 경로
    output_path = os.path.abspath(output_path)

    with zipfile.ZipFile(output_path, 'w', zipfile.ZIP_DEFLATED) as zipf:
        # 폴더 내 파일들을 순회하면서 압축
        for root, _, files in os.walk(folder_path):
            for file in files:
                absolute_path = os.path.join(root, file)
                relative_path = os.path.relpath(absolute_path, folder_path)
                zipf.write(absolute_path, relative_path)


def send_cache(zip_name):
    # 압축할 폴더 이름
    folder_to_zip = 'cache'

    # 압축 파일 이름
    output_zip = zip_name + '.zip'

    # 폴더 압축
    zip_folder(folder_to_zip, output_zip)

    # SFTP 연결 설정
    hostname = str(ips)
    port = 46834
    username = "hj6ch"
    password = "mine06^^"

    transport = paramiko.Transport((hostname, port))
    transport.connect(username=username, password=password)
    sftp = paramiko.SFTPClient.from_transport(transport)

    # 파일 전송
    local_path = output_zip
    remote_path = f'/home/hj6ch/outputs/{output_zip}'
    sftp.put(local_path, remote_path)

    # 연결 종료
    sftp.close()
    transport.close()

    # 압축 파일 삭제
    os.remove(output_zip)

    # 폴더 내 파일 삭제
    folder_path = folder_to_zip
    for root, dirs, files in os.walk(folder_path):
        for file in files:
            os.remove(os.path.join(root, file))


def water_big(text):
    font_size = 60
    fonts = "Pretendard-SemiBold.otf"
    image_size = (600, 100)
    # 이미지와 드로잉 객체 생성
    image = Image.new('RGBA', image_size, (255, 255, 255, 0))  # 투명한 배경
    draw = ImageDraw.Draw(image)

    # 글꼴 설정
    font = ImageFont.truetype(fonts, font_size)
    text_color = (255, 255, 255)
    # 텍스트 크기 계산
    text_bbox = draw.textbbox((0, 0), text, font=font)
    text_width = text_bbox[2] - text_bbox[0]
    text_height = text_bbox[3] - text_bbox[1]

    # 텍스트를 왼쪽으로 정렬하여 그리기
    text_x = 0  # 왼쪽 맞춤
    text_y = (image_size[1] - text_height) / 2
    draw.text((text_x, text_y), text, fill=text_color, font=font)

    # 이미지 회전
    rotated_image = image.rotate(313.4, expand=True)
    return rotated_image


def water_small(text):
    font_size = 10
    fonts = "Pretendard-SemiBold.otf"
    image_size = (100, 50)
    # 이미지와 드로잉 객체 생성
    image = Image.new('RGBA', image_size, (255, 255, 255, 0))  # 투명한 배경
    draw = ImageDraw.Draw(image)

    # 글꼴 설정
    font = ImageFont.truetype(fonts, font_size)
    text_color = (255, 255, 255)
    # 텍스트 크기 계산
    text_bbox = draw.textbbox((0, 0), text, font=font)
    text_width = text_bbox[2] - text_bbox[0]
    text_height = text_bbox[3] - text_bbox[1]

    # 텍스트를 왼쪽으로 정렬하여 그리기
    text_x = 0  # 왼쪽 맞춤
    text_y = (image_size[1] - text_height) / 2
    draw.text((text_x, text_y), text, fill=text_color, font=font)
    rotated_image = image.rotate(10.2, expand=True)
    return rotated_image


def gradient_replace_white(img):
    # 이미지 열기

    # 이미지 RGBA 모드로 변환
    img = img.convert("RGBA")

    # 이미지의 너비와 높이 구하기
    width, height = (1164, 1800)

    # 픽셀 데이터 가져오기
    pixels = img.load()

    # 흰색인 픽셀을 알록달록한 그라데이션으로 변경
    for y in range(height):
        for x in range(width):
            r, g, b, a = pixels[x, y]
            # 흰색인 부분만 처리
            if (r, g, b) == (255, 255, 255):
                # 알록달록한 그라데이션 계산
                new_r = x % 256  # x 좌표를 기반으로 빨간색 값 계산
                new_g = y % 256  # y 좌표를 기반으로 초록색 값 계산
                new_b = (x + y) % 256  # x, y 좌표 합을 기반으로 파란색 값 계산

                # 픽셀 값 변경
                pixels[x, y] = (new_r, new_g, new_b, a)
    return img
    # 변경된 이미지 저장


def get_text_end_coordinates(text, font_path, font_size, x, y, color):
    # 이미지 열기
    image_size = (1600, 136)
    image = Image.new('RGBA', image_size, (255, 255, 255, 0))  # 투명한 배경
    # 폰트 설정
    font = ImageFont.truetype(font_path, font_size)

    # 이미지에 텍스트 추가
    draw = ImageDraw.Draw(image)
    draw.text((x, y), text, font=font, fill=color)  # 이미지에 텍스트 그리기

    # 텍스트 크기 구하기
    text_width = draw.textlength(text, font=font)  # textsize 대신 textlength 사용
    text_height = font_size  # textsize 대신 font_size 사용

    # 텍스트 끝나는 좌표 계산
    end_x = x + text_width
    end_y = y + text_height

    return image, end_x, end_y  # image 객체 반환


def season_out(text_to_write, text_to_write2, color):
    font_path = 'Helvetica_Neue_LT_Std_65_Medium.otf'  # 사용할 폰트 파일 경로
    font_size = 130  # 폰트 크기
    x, y = 0, 0  # 텍스트 시작 좌표

    img, x1, y1 = get_text_end_coordinates(text_to_write, font_path, font_size, x, y, color)
    font_path = 'Helvetica_Neue_LT_Std_75_Bold_Outline.otf'  # 사용할 폰트 파일 경로
    font_size = 135
    img2, x, y = get_text_end_coordinates(text_to_write2, font_path, font_size, x, y, color)
    img.paste(img2, (int(x1 + 2), 0), img2)
    return img


def water_mark(text):
    # 이미지 저장
    img = Image.new(mode="RGBA", size=(1164, 1800))
    rotated_image = water_big(text)
    for i in range(4):
        for a in range(4):
            img.paste(rotated_image, (i * 300, a * 500), rotated_image)

    rotated_image = water_small(text)
    for i in range(12):
        for a in range(40):
            img.paste(rotated_image, (i * 100 + 20, a * 50), rotated_image)

    img = gradient_replace_white(img)
    return img


def get_kr_time():
    # 한국 시간대 설정
    korea_time_zone = pytz.timezone('Asia/Seoul')

    # 현재 시간을 한국 시간대로 변환
    current_time_in_korea = datetime.now(korea_time_zone)

    # 원하는 형식으로 시간 포맷팅
    return current_time_in_korea.strftime("%Y%m%d-%H%M%S")


def upload_sftp(image, name):
    host = str(ips)
    port = 46834
    username = "hj6ch"
    password = "mine06^^"
    remote_path = f"/home/hj6ch/outputs/{name}"

    # 이미지를 바이트 스트림으로 변환
    img_byte_arr = io.BytesIO()
    image.save(img_byte_arr, format='PNG')
    img_byte_arr.seek(0)

    try:
        # SFTP 세션 시작
        transport = paramiko.Transport((host, port))
        transport.connect(username=username, password=password)

        sftp = paramiko.SFTPClient.from_transport(transport)

        # 바이트 스트림을 사용하여 파일 업로드
        sftp.putfo(img_byte_arr, remote_path)
        print(f"Image uploaded to {remote_path}")

        # 연결 종료
        sftp.close()
        transport.close()
    except Exception as e:
        print(f"An error occurred: {e}")


def create_qr_with_icon(url, icon_path, resolution=(335, 335), border_reduction=2):
    # Generate QR code with a smaller border
    qr = qrcode.QRCode(
        version=1,
        error_correction=qrcode.constants.ERROR_CORRECT_H,
        box_size=10,
        border=4 - border_reduction,  # Reduce the border by the border_reduction amount
    )
    qr.add_data(url)
    qr.make(fit=True)

    # Create an image from the QR Code instance
    qr_img = qr.make_image(fill_color="black", back_color="white").convert('RGB')

    # Resize QR code to the specified resolution
    # Instead of using Image.ANTIALIAS, you should now use Image.Resampling.LANCZOS
    qr_img = qr_img.resize(resolution, Image.Resampling.LANCZOS)
    if icon_path == "tripleS Logo":
        # Open the icon file
        icon_img = Image.open('qr_icon.png')

        # Calculate the maximum size of the icon
        icon_size = min(resolution) // 4

        # Resize the icon, if it's too large
        icon_img.thumbnail((icon_size, icon_size), Image.Resampling.LANCZOS)

        # Calculate position for icon (center)
        icon_pos = ((resolution[0] - icon_img.size[0]) // 2, (resolution[1] - icon_img.size[1]) // 2)

        # Paste the icon image onto the QR code
        qr_img.paste(icon_img, icon_pos, icon_img)

    # Save the QR code with icon

    return qr_img


def gnames(text, r, g, b, font):
    # 이미지 크기와 글꼴 크기 설정
    image_size = (400, 100)  # 너비 x 높이
    font_size = font

    # 이미지와 드로잉 객체 생성
    image = Image.new('RGBA', image_size, (255, 255, 255, 0))  # 투명한 배경
    draw = ImageDraw.Draw(image)

    # 글꼴 설정
    font = ImageFont.truetype("Helvetica_Neue_LT_Std_75_Bold.otf", font_size)
    text_color = (r, g, b)

    # 텍스트 그리기
    text_bbox = draw.textbbox((0, 0), text, font=font)
    text_width = text_bbox[2] - text_bbox[0]
    text_height = text_bbox[3] - text_bbox[1]
    text_x = image_size[0] - text_width  # 오른쪽 정렬을 위해 수정
    text_y = (image_size[1] - text_height) / 2
    draw.text((text_x, text_y), text, fill=text_color, font=font)

    # 이미지 회전
    rotated_image = image.rotate(270, expand=True)
    return rotated_image


#from PIL import Image, ImageDraw, ImageFont


def shop(text, r, g, b, fs, fonts):
    # 이미지 크기와 글꼴 크기 설정
    image_size = (400, 100)  # 너비 x 높이
    font_size = fs
    spacing = 43  # 글자 간 간격

    # 이미지와 드로잉 객체 생성
    image = Image.new('RGBA', image_size, (255, 255, 255, 0))  # 투명한 배경
    draw = ImageDraw.Draw(image)

    # 글꼴 설정
    font = ImageFont.truetype(fonts, font_size)
    text_color = (r, g, b)

    # 텍스트 위치 초기화
    current_x = 0
    text_y = (image_size[1] - font_size) // 2  # 세로 중앙 정렬

    # 각 글자를 개별적으로 그리기
    for char in text:
        draw.text((current_x, text_y), char, fill=text_color, font=font)
        current_x += spacing

    # 이미지 회전
    rotated_image = image.rotate(270, expand=True)

    return rotated_image


def names(text, r, g, b, fs, fonts, rotate, tes):
    # 이미지 크기와 글꼴 크기 설정
    if tes == False:
        image_size = (400, 100)
    else:
        image_size = (800, 136)  # 너비 x 높이
    font_size = fs

    # 이미지와 드로잉 객체 생성
    image = Image.new('RGBA', image_size, (255, 255, 255, 0))  # 투명한 배경
    draw = ImageDraw.Draw(image)

    # 글꼴 설정
    font = ImageFont.truetype(fonts, font_size)
    text_color = (r, g, b)
    # 텍스트 크기 계산
    text_bbox = draw.textbbox((0, 0), text, font=font)
    text_width = text_bbox[2] - text_bbox[0]
    text_height = text_bbox[3] - text_bbox[1]

    # 텍스트를 왼쪽으로 정렬하여 그리기
    text_x = 0  # 왼쪽 맞춤
    text_y = (image_size[1] - text_height) / 2
    draw.text((text_x, text_y), text, fill=text_color, font=font)

    # 이미지 회전
    if rotate:
        rotated_image = image.rotate(270, expand=True)
    else:
        rotated_image = image.rotate(0, expand=True)
    return rotated_image


def create_text_image(text, r, g, b):
    """
    Create an image with the specified text.
    The text uses two different fonts: normal for letters and outline for numbers.
    The text color is defined by the RGB values (r, g, b).

    :param text: The text to be drawn.
    :param r: Red component of the color, range 0-255.
    :param g: Green component of the color, range 0-255.
    :param b: Blue component of the color, range 0-255.
    :return: An image object with the drawn text.
    """

    # Estimate the width of the image based on the text length
    estimated_width = sum(
        [ImageFont.ImageFont.getsize(font=normal_font if char.isalpha() else outline_font, text=char)[0] for char in
         text]) + 10 * len(text)
    # Create an image with a transparent background
    img = Image.new('RGBA', (estimated_width, 100), color=(255, 255, 255, 0))
    d = ImageDraw.Draw(img)

    # Current position for drawing text
    current_position = 10

    # Draw the text with the specified color
    for char in text:
        # Select the appropriate font
        used_font = outline_font if char.isdigit() else normal_font
        # Draw the character
        d.text((current_position, 10), char, font=used_font, fill=(r, g, b, 255))
        # Calculate width of the character and update position
        width, _ = ImageFont.ImageFont.getsize(font=used_font, text=char)
        current_position += width + 5  # Added a small space between characters

    return img


def hex_to_rgb(hex_color):
    # Remove the '#' character if it exists
    hex_color = hex_color.lstrip('#')

    # Convert the hex string to integers
    r, g, b = tuple(int(hex_color[i:i + 2], 16) for i in (0, 2, 4))
    return r, g, b


def load_image_as_pil(file_path):
    """Load an image from the specified file path and return it as a PIL Image object."""
    try:
        with Image.open(file_path) as img:
            return img.copy()
    except Exception as e:
        return str(e)


def resize_and_crop_image(image, target_width, target_height):
    # 이미지를 PIL Image 객체로 변환
    #img = Image.fromarray(image.astype('uint8'), 'RGB')
    img = image
    # 원본 이미지의 크기와 비율 계산
    original_width, original_height = img.size
    ratio = min(original_width / target_width, original_height / target_height)

    # 새로운 크기 계산
    new_width = int(target_width * ratio)
    new_height = int(target_height * ratio)

    # 이미지를 중앙에서 자름
    img = img.crop(((original_width - new_width) // 2,
                    (original_height - new_height) // 2,
                    (original_width + new_width) // 2,
                    (original_height + new_height) // 2))

    # 최종적으로 목표 해상도로 리사이즈
    img = img.resize((target_width, target_height), Image.Resampling.LANCZOS)

    return img


def change_color(objekt_color, nn):
    file_path = nn  # Adjust the path according to your setup
    icon = Image.open(file_path).convert("RGBA")
    image_np = np.array(icon)
    _, _, _, alpha = image_np.T
    mask = alpha > 0
    image_np[..., :-1][mask.T] = ImageColor.getcolor(objekt_color, "RGB")
    colored_icon = Image.fromarray(image_np)
    return colored_icon


def no_change_color():
    file_path = 'spe.png'  # Adjust the path according to your setup
    icon = Image.open(file_path).convert("RGBA")
    image_np = np.array(icon)
    _, _, _, alpha = image_np.T
    mask = alpha > 0
    colored_icon = Image.fromarray(image_np)
    return colored_icon


# Given: dropdown_name contains either a string number between 1-20 or just a string.
# Task: If dropdown_name is a number between 1-20, map it to a corresponding name from a predefined list.
#       If it's just a string, assign it directly to the variable name.

# The list of names
namesss = ["SeoYeon", "HyeRin", "JiWoo", "CheaYeon", "YooYeon", "SooMin", "NaKyoung", "YuBin", "DaHyun", "Kotone",
           "YeonJi", "Nien", "SoHyun", "Xinyu", "Mayu", "JooBin", "HaYeon", "ShiOn"]


# Function to process the dropdown_name
def process_dropdown(dropdown_name):
    # Check if dropdown_name is a digit and within the range 1-20
    if dropdown_name.isdigit():
        number = int(dropdown_name)
        if 1 <= number <= 20:
            # Map the number to a name in the list (subtract 1 for zero-based indexing)
            return namesss[number - 1]

    # If not a number in 1-20, return the string as it is
    return dropdown_name


# Example usage
dropdown_name_example = "5"  # Change this to test with different values
name = process_dropdown(dropdown_name_example)
name
ran = 0

frames = []


def find_smallest_n(x, y):
    # 97n > x 조건을 만족하는 최소 n 계산
    n_for_x = math.ceil(x / 97)

    # 150n > y 조건을 만족하는 최소 n 계산
    n_for_y = math.ceil(y / 150)

    # 두 조건을 모두 만족하는 최소 n
    n = max(n_for_x, n_for_y)

    return n

def intergif(gif, overlay, chk):
    # 결과 프레임들을 저장할 리스트
    frames = []
    durations = []
    x, y = gif.size
    n = find_smallest_n(x, y)
    target_width = 97 * n
    target_height = 150 * n
    print(n)
    overlay = overlay.resize((target_width,target_height), Image.Resampling.LANCZOS)
    if chk:

        remove_image_path = 'remove.png'  # Adjust the path according to your setup
        remove_img = Image.open(remove_image_path).convert("RGBA")
        remove_img = remove_img.resize((target_width, target_height), Image.Resampling.BOX)
        icon = remove_img
        image_np = np.array(icon)
        _, _, _, alpha = image_np.T
        mask = alpha > 0
        image_np[..., :-1][mask.T] = ImageColor.getcolor("#000", "RGB")
        colored_icon = Image.fromarray(image_np)
    # GIF의 각 프레임을 순회하며 처리합니다.

    for frame in ImageSequence.Iterator(gif):

        durations.append(frame.info['duration'])
        # PNG 이미지를 GIF 프레임과 같은 크기로 조정합니다.
        # 이 부분은 필요에 따라 조정할 수 있습니다





        resized_frame = frame.copy()
        img = resized_frame

        # 원본 이미지의 크기와 비율 계산
        original_width, original_height = img.size
        ratio = min(original_width / target_width, original_height / target_height)

        # 새로운 크기 계산
        new_width = int(target_width * ratio)
        new_height = int(target_height * ratio)

        # 이미지를 중앙에서 자름
        img = img.crop(((original_width - new_width) // 2,
                        (original_height - new_height) // 2,
                        (original_width + new_width) // 2,
                        (original_height + new_height) // 2))

        # 최종적으로 목표 해상도로 리사이즈
        img = img.resize((target_width, target_height), Image.Resampling.LANCZOS)
        img.paste(overlay, (0, 0), overlay)
        if chk:

            img.paste(colored_icon, (0, 0), colored_icon)

        frame = img.quantize(method=2)
        # 두 이미지를 합칩니다.
        #combined = Image.alpha_composite(frame.convert('RGBA'), overlay)

        # 결과 리스트에 추가합니다.
        frames.append(img)

    # 모든 프레임을 처리한 후, 새로운 GIF로 저장합니다.
    frames[1].save('output.gif', save_all=True, append_images=frames[1:], loop=0, duration=durations, disposal=0, optimize=True)


def sorting(img, integ, fileg, obj_color, obj_color_picker, obj_color_img, txt_color, txt_color_picker, dropdown_name, txt_name,
             radio_txt_group_name, txt_group_name, chk, obj_num, choose_z_a, choose_etc, obj_count, ran):
    if integ == "Image":
        outs = generate(img, integ, fileg, obj_color, obj_color_picker, obj_color_img, txt_color, txt_color_picker, dropdown_name, txt_name,
             radio_txt_group_name, txt_group_name, chk, obj_num, choose_z_a, choose_etc, obj_count, ran)
        return outs, outs, "blank.png"
    if integ == "Gif":
        img = Image.open('blank.png')
        mid = generate(img, integ, fileg, obj_color, obj_color_picker, obj_color_img, txt_color, txt_color_picker, dropdown_name, txt_name,
             radio_txt_group_name, txt_group_name, chk, obj_num, choose_z_a, choose_etc, obj_count, ran)
        gi = Image.open(fileg)

        intergif(gi, mid, chk)
        return "output.gif", "output.gif", "output.gif"

def generate(img, integ, fileg, obj_color, obj_color_picker, obj_color_img, txt_color, txt_color_picker, dropdown_name, txt_name,
             radio_txt_group_name, txt_group_name, chk, obj_num, choose_z_a, choose_etc, obj_count, ran):
    # Load and color 'cobj1.png'
    krtime = get_kr_time()

    global objekt_color
    objekt_color = ""
    if obj_color == "Atom01":
        objekt_color = "#ffdd00"
    if obj_color == "Binary01":
        objekt_color = "#00ff01"
    if obj_color == "Cream01":
        objekt_color = "#ff7477"
    if obj_color == "Other color":
        objekt_color = obj_color_picker

    if obj_color == None:
        raise gr.Error("Choose objekt color")

    if txt_color == "Other":
        txt_color = txt_color_picker
    elif txt_color == "White":
        txt_color = "#ffffff"
    elif txt_color == "Black":
        txt_color = "#000000"
    if dropdown_name:
        name = process_dropdown(dropdown_name)
    else:
        name = ""
    if radio_txt_group_name == "Other":
        group_name = txt_group_name
    else:
        group_name = radio_txt_group_name

    # Resize and crop the input image
    resized_image = resize_and_crop_image(img, 1164, 1800)

    if obj_color == "Special":
        colored_icon = no_change_color()
        resized_image.paste(colored_icon, (0, 0), colored_icon)
    else:
        if obj_color == "AI Color":

            remove_image_path = f'ai_remove.png'  # Adjust the path according to your setup
            remove_img = Image.open(remove_image_path).convert("RGBA")
            remove_np = np.array(remove_img)

            # remove.png에서 r 채널이 255이고 알파 채널이 있는 픽셀 위치 찾기
            r_channel = remove_np[:, :, 0]
            alpha_channel = remove_np[:, :, 3]
            mask = (r_channel == 255) & (alpha_channel > 0)

            grimg = Image.open(f'grad2/gradient_{ran}.png')
            # resized_image를 RGBA 형식으로 변환 (필요한 경우에만)
            grimg = grimg.convert("RGBA")
            grimg_np = np.array(grimg)

            # 해당 위치의 resized_image 픽셀을 투명하게 설정
            grimg_np[mask, :] = (0, 0, 0, 0)  # RGBA 형식에 맞게 조정

            grimg = Image.fromarray(grimg_np)
            resized_image.paste(grimg, (1038, 0), grimg)
        else:
            colored_icon = change_color(objekt_color, 'cobj1.png')
            resized_image.paste(colored_icon, (0, 0), colored_icon)
    # Overlay the colored icon on the resized image
    if txt_color:
        r, g, b = hex_to_rgb(txt_color)

        if group_name:
            if group_name == "ARTMS":
                colored_icon = change_color(txt_color, 'artms.png')
                paste_position = (1081, 1371)
                resized_image.paste(colored_icon, paste_position, colored_icon)
            else:
                rotated_image = gnames(str(group_name), r, g, b, 61)
                paste_position = (1050, 1240)
                resized_image.paste(rotated_image, paste_position, rotated_image)
        if not str(name) == "[]":
            name_rotated_image = names(str(name), r, g, b, 61, "Helvetica_Neue_LT_Std_75_Bold.otf", True, False)
            name_paste_position = (1050, 161)
            resized_image.paste(name_rotated_image, name_paste_position, name_rotated_image)
    else:
        raise gr.Error("Choose text color")

    if obj_num:
        if choose_z_a == "Other":
            alpa = choose_etc
        elif choose_z_a == "A":
            alpa = "A Real"
        else:
            if choose_z_a == False:
                alpa = ""
            else:
                alpa = choose_z_a

        if alpa != "A Real":
            objnum_img = gnames(str(obj_num) + str(alpa), r, g, b, 75)
            objnum_paste_position = (1050, 452)
            resized_image.paste(objnum_img, objnum_paste_position, objnum_img)
            objcount_img = shop("#" + str(obj_count), r, g, b, 75, "MatrixSSK Regular.ttf")
            objcount_paste_position = (1046, 871)
            resized_image.paste(objcount_img, objcount_paste_position, objcount_img)
        else:
            objnum_img = gnames(str(obj_num) + "A", r, g, b, 75)
            objnum_paste_position = (1050, 452)
            resized_image.paste(objnum_img, objnum_paste_position, objnum_img)
    if chk:
        remove_image_path = 'remove.png'  # Adjust the path according to your setup
        remove_img = Image.open(remove_image_path).convert("RGBA")
        remove_np = np.array(remove_img)

        # remove.png에서 r 채널이 255이고 알파 채널이 있는 픽셀 위치 찾기
        r_channel = remove_np[:, :, 0]
        alpha_channel = remove_np[:, :, 3]
        mask = (r_channel == 255) & (alpha_channel > 0)

        # resized_image를 RGBA 형식으로 변환 (필요한 경우에만)
        resized_image = resized_image.convert("RGBA")
        resized_np = np.array(resized_image)

        # 해당 위치의 resized_image 픽셀을 투명하게 설정
        resized_np[mask, :] = (0, 0, 0, 0)  # RGBA 형식에 맞게 조정

        resized_image = Image.fromarray(resized_np)
    print()
    print()
    print("Front Render")
    print(f"Objekt color is {objekt_color}")
    print(f"Name is {name}")
    print(f"Objekt number is {obj_num}")
    print(f"Group name is {group_name}")
    print(f"Round is {chk}")

    output_filename = f'{name}_{group_name}_{krtime}_front.jpg'
    rgb_img = resized_image.convert('RGB')
    rgb_img.save(f'cache/{output_filename}', quality=90)
    print(ran, krtime)

    return resized_image


def assign_url(qr_url):
    # 각 문자열에 대응하는 URL 매핑
    url_mapping = {
        "tripleS website": "https://triplescosmos.com/",
        "tripleS youtube": "https://youtube.com/@triplescosmos",
        "tripleS 𝕏": "https://x.com/triplescosmos",
        "tripleS discord": "https://discord.gg/triplescosmos"
    }

    # qr_url이 매핑된 문자열 중 하나라면 해당 URL을, 아니라면 qr_url 그대로를 반환
    return url_mapping.get(qr_url, qr_url)


sign_positions = {
    1: (31, 1068),
    2: (0, 1103),
    3: (34, 1101),
    4: (1, 1053),
    5: (79, 1100),
    6: (0, 1057),
    7: (0, 1116),
    8: (20, 1109),
    9: (26, 1109),
    10: (42, 1104),
    11: (31, 1105),
    12: (0, 1065),
    13: (58, 1108),
    14: (0, 1110),
    15: (0, 1105),
    16: (49, 1056),
    17: (61, 1105),
    18: (84, 1118),
    19: (39, 1167),
    20: (170, 1105),
    21: (38, 1148),
    22: (61, 1100),
    23: (52, 1113),
    24: (46, 1022),
    25: (62, 1131)
}


def generate_back(img, obj_color, obj_color_picker, obj_color_img, txt_color, txt_color_picker, dropdown_name, txt_name,
                  radio_txt_group_name, txt_group_name, chk, obj_num, choose_z_a, choose_etc, obj_count, radio_class,
                  txt_class, obj_color_outline, obj_color_outline_picker, radio_season, txt_season, cr, btn_logo,
                  qr_url, ran, qr_option1, sign, season_outline):
    # Load and color 'cobj1.png'
    krtime = get_kr_time()

    global objekt_color
    if obj_color == "Atom01":
        objekt_color = "#ffdd00"
    if obj_color == "Binary01":
        objekt_color = "#00ff01"
    if obj_color == "Cream01":
        objekt_color = "#ff7477"
    if obj_color == "Special":
        objekt_color = "Special"
    if obj_color == "Other color":
        objekt_color = obj_color_picker
    if obj_color == None:
        raise gr.Error("Choose objekt color")

    if obj_color_outline == "White":
        objekt_color_outline = "#ffffff"
    if obj_color_outline == "Black":
        objekt_color_outline = "#000000"
    if obj_color_outline == "Other":
        objekt_color_outline = obj_color_outline_picker

    if txt_color == "Other":
        txt_color = txt_color_picker
    elif txt_color == "White":
        txt_color = "#ffffff"
    elif txt_color == "Black":
        txt_color = "#000000"
    if dropdown_name:
        name = process_dropdown(dropdown_name)
    else:
        name = ""
    if radio_txt_group_name == "Other":
        group_name = txt_group_name
    else:
        group_name = radio_txt_group_name
    if radio_class == "Other":
        classes = txt_class
    else:
        classes = radio_class

    if radio_season == "Other":
        season = txt_season
    else:
        season = radio_season
    # Resize and crop the input image
    resized_image = load_image_as_pil('all.png')
    if obj_color == "Special":
        resized_image = Image.open('special_back.png')
    else:
        if obj_color == "AI Color":
            file_path = f'grad2/gradient_{ran}.png'

            # 이미지 열기
            img = Image.open(file_path)
            width, height = img.size

            # 잘라낼 부분 설정 (x < 126에 해당하는 부분)
            left = 125
            top = 0
            right = 1289  # x가 126보다 작은 부분까지
            bottom = height

            # 이미지 자르기
            cropped_img = img.crop((left, top, right, bottom))
            resized_image = cropped_img
        else:
            colored_icon = change_color(objekt_color, 'all.png')
            resized_image.paste(colored_icon, (0, 0), colored_icon)

    colored_icon = change_color(objekt_color_outline, 'outline.png')
    resized_image.paste(colored_icon, (0, 0), colored_icon)

    colored_icon = change_color(txt_color, 'back_ui.png')
    resized_image.paste(colored_icon, (0, 0), colored_icon)
    # Overlay the colored icon on the resized image
    if txt_color:
        r, g, b = hex_to_rgb(txt_color)
        if group_name:
            if group_name == "ARTMS":
                colored_icon = change_color(txt_color, 'artms.png')
                paste_position = (974, 1371)
                resized_image.paste(colored_icon, paste_position, colored_icon)
            else:
                rotated_image = gnames(str(group_name), r, g, b, 61)
                paste_position = (943, 1238)
                resized_image.paste(rotated_image, paste_position, rotated_image)
        if not str(name) == "[]":
            name_rotated_image = names(str(name), r, g, b, 130, "Helvetica_Neue_LT_Std_65_Medium.otf", False, True)
            name_paste_position = (54, 466)
            resized_image.paste(name_rotated_image, name_paste_position, name_rotated_image)

            name_rotated_image = names(str(name), r, g, b, 61, "Helvetica_Neue_LT_Std_75_Bold.otf", True, False)
            name_paste_position = (932, 159)
            resized_image.paste(name_rotated_image, name_paste_position, name_rotated_image)
        if not radio_class == None:
            name_rotated_image = names(str(classes), r, g, b, 130, "Helvetica_Neue_LT_Std_65_Medium.otf", False, True)
            name_paste_position = (54, 700)
            resized_image.paste(name_rotated_image, name_paste_position, name_rotated_image)

        if not season == None:
            # name_rotated_image = seas(str(season), r, g, b, 130, ["Helvetica_Neue_LT_Std_65_Medium.otf", "Helvetica_Neue_LT_Std_75_Bold_Outline.otf"], False, True)
            # name_rotated_image = names(str(season), r, g, b, 130, "Helvetica_Neue_LT_Std_65_Medium.otf", False, True)
            if season == "Atom01":
                name_rotated_image = season_out("Atom", "01", txt_color)
            elif season == "Binary01":
                name_rotated_image = season_out("Binary", "01", txt_color)
            elif season == "Cream01":
                name_rotated_image = season_out("Cream", "01", txt_color)
            else:
                name_rotated_image = season_out(str(season), str(season_outline), txt_color)
            # name_rotated_image = create_text_image(str(season), r,g,b)
            name_paste_position = (57, 954)
            resized_image.paste(name_rotated_image, name_paste_position, name_rotated_image)
    else:
        raise gr.Error("Choose text color")
    if obj_num:
        if choose_z_a == "Other":
            alpa = choose_etc
        else:
            if choose_z_a == False:
                alpa = ""
            else:
                alpa = choose_z_a
        objnum_img = gnames(str(obj_num) + str(alpa), r, g, b, 75)
        objnum_paste_position = (951, 448)
        resized_image.paste(objnum_img, objnum_paste_position, objnum_img)
        objcount_img = shop("#" + str(obj_count), r, g, b, 75, "MatrixSSK Regular.ttf")
        objcount_paste_position = (943, 867)
        resized_image.paste(objcount_img, objcount_paste_position, objcount_img)
    if btn_logo == "tripleS":
        colored_icon = change_color(txt_color, 'logo.png')
        resized_image.paste(colored_icon, (61, 162), colored_icon)
    if btn_logo == "ARTMS":
        colored_icon = change_color(txt_color, 'artms_big.png')
        resized_image.paste(colored_icon, (61, 162), colored_icon)
    if qr_url:
        url_txt = assign_url(qr_url)
        colored_icon = create_qr_with_icon(url_txt, qr_option1)
        # Ensure 'colored_icon' is in RGBA mode so that it has an alpha channel for transparency.
        if colored_icon.mode != 'RGBA':
            colored_icon = colored_icon.convert('RGBA')

        # When pasting, the third argument is the mask, which should be just the alpha channel of 'colored_icon'.
        # This assumes that 'colored_icon' is the image you want to paste, and its alpha channel is the mask.
        resized_image.paste(colored_icon, (555, 1098), colored_icon.split()[3])
    else:
        white_image = Image.new('RGBA', (335, 335), color='white')
        resized_image.paste(white_image, (555, 1098), white_image)
    if cr:
        colored_icon = change_color(txt_color, 'cr.png')
        resized_image.paste(colored_icon, (0, 0), colored_icon)
    if sign != None:
        sign = sign + 1
        colored_icon = change_color(txt_color, f'sign/{sign}.png')
        if sign in sign_positions:
            position = sign_positions[sign]
            resized_image.paste(colored_icon, position, colored_icon)

        print(f"HERRRRRRRRRRRRR {sign}")
    if chk:
        remove_image_path = 'remove.png'  # Adjust the path according to your setup
        remove_img = Image.open(remove_image_path).convert("RGBA")
        remove_np = np.array(remove_img)

        # remove.png에서 r 채널이 255이고 알파 채널이 있는 픽셀 위치 찾기
        r_channel = remove_np[:, :, 0]
        alpha_channel = remove_np[:, :, 3]
        mask = (r_channel == 255) & (alpha_channel > 0)

        # resized_image를 RGBA 형식으로 변환 (필요한 경우에만)
        resized_image = resized_image.convert("RGBA")
        resized_np = np.array(resized_image)

        # 해당 위치의 resized_image 픽셀을 투명하게 설정
        resized_np[mask, :] = (0, 0, 0, 0)  # RGBA 형식에 맞게 조정

        resized_image = Image.fromarray(resized_np)
    print()
    print()
    print("back Render")
    print(f"Objekt color is {obj_color}")
    print(f"Objekt outline color is {objekt_color_outline}")
    print(f"Name is {name}")
    print(f"CLASS is {classes}")
    print(f"SEASON is {season}")
    print(f"Objekt number is {obj_num}")
    print(f"Group name is {group_name}")
    print(f"Round is {chk}")
    img_rgb = resized_image.convert('RGB')
    output_filename = f'{name}_{group_name}_{krtime}_back.jpg'
    img_rgb.save(f'cache/{output_filename}', quality=90)
    print(ran, krtime)
    return resized_image, resized_image


def change_ran(a):
    if a == "AI Color":
        ran = random.randrange(1, 1000)
        return ran
    else:
        return 0


def update_obj_color_picker_visibility(obj_color):
    if obj_color == "Other color":
        return gr.ColorPicker(visible=True), gr.Slider(1, 1000, 0, visible=False), gr.Button(visible=False)
    elif obj_color == "AI Color":
        ran = random.randrange(1, 1000)
        return gr.ColorPicker(visible=False), gr.Slider(1, 1000, ran, visible=True), gr.Button(visible=True)
    else:
        return gr.ColorPicker(visible=False), gr.Slider(1, 1000, 0, visible=False), gr.Button(visible=False)


def update_obj_color_class_visibility(obj_color2):
    if "01" in obj_color2:
        return gr.ColorPicker(visible=True)
    else:
        return gr.ColorPicker(visible=False)


# The rest of your code remains the same
def update_obj_color_img_visibility(obj_color_img):
    if obj_color_img == "Other image":
        return gr.Image(visible=True)
    else:
        return gr.Image(visible=False)


def update_txt_color_picker_visibility(txt_color_picker):
    if txt_color_picker == "Other":
        return gr.Image(visible=True)
    else:
        return gr.Image(visible=False)


def update_txt_name_visibility(dropdown_group_name):
    if dropdown_group_name == "Other":
        return gr.Textbox(visible=True, interactive=True)
    else:
        return gr.Textbox(visible=False)


def update_txt_group_name_visibility(a):
    if a == "Other":
        return gr.Textbox(visible=True), gr.Dropdown([], label="Name", allow_custom_value=True)
    elif a == "tripleS":
        return gr.Textbox(visible=False), gr.Dropdown(
            ["SeoYeon", "HyeRin", "JiWoo", "ChaeYeon", "YooYeon", "SooMin", "NaKyoung", "YuBin", "Kaede", "DaHyun",
             "Kotone", "YeonJi", "Nien", "SoHyun", "Xinyu", "Mayu", "Lynn", "JooBin", "HaYeon", "ShiOn"], label="Name",
            allow_custom_value=True)
    elif a == "ARTMS":
        return gr.Textbox(visible=False), gr.Dropdown(["HeeJin", "JinSoul", "Kim Lip", "Choerry", "HaSeul"],
                                                      label="Name", allow_custom_value=True)


def update_alpa_visibiliy(a):
    if a == "Other":
        return gr.Textbox(visible=True)
    else:
        return gr.Textbox(visible=False)


def update_chk_num(a):
    if a == True:
        return gr.Textbox(visible=True), gr.Radio(visible=True), gr.Textbox(visible=True), gr.Button(visible=True)
    else:
        return gr.Textbox(visible=False), gr.Radio(visible=False), gr.Textbox(visible=False), gr.Button(visible=False)


def clear(a):
    return gr.Radio(value=None), gr.ColorPicker(value=None), gr.Image(value=None), gr.Radio(value=None), gr.ColorPicker(
        value="#ffffff"), gr.Dropdown(value=""), gr.Textbox(value=None), gr.Radio(value=None), gr.Textbox(
        value=None), gr.Checkbox(value=True), gr.Textbox(value=None), gr.Radio(value=None), gr.Textbox(
        value=None), gr.Textbox(value=None), gr.Checkbox(value=None)


def flip_back(a):
    return gr.Row(visible=False), gr.Row(visible=True), gr.Button(visible=False), gr.Button(visible=True), gr.Image


def flip_front(a):
    return gr.Row(visible=True), gr.Row(visible=False), gr.Button(visible=True), gr.Button(visible=False)


def txt_class_visibility(a):
    if a == "Other":
        return gr.Textbox(visible=True)
    else:
        return gr.Textbox(visible=False)


def chk_sync(a):
    return gr.Checkbox(value=a)


def obj_color_outline_picker_visibility(a):
    if a == "Other":
        return gr.ColorPicker(visible=True)
    else:
        return gr.ColorPicker(visible=False)


def txt_season_visibility(a):
    if a == "Other":
        return gr.Textbox(visible=True), gr.Textbox(visible=True)
    else:
        return gr.Textbox(visible=False), gr.Textbox(visible=False)


def gen_edit_fn(a, b):
    pil_image = Image.fromarray(a["background"])
    if b == "90":
        c = pil_image.rotate(90, expand=True)
        return c, c
    elif b == "270":
        c = pil_image.rotate(270, expand=True)
        return c, c
    else:
        return pil_image, pil_image


def create_image_from_dict(data):
    # Assuming data is a dictionary with pixel values and image size
    pixels = data.get('pixels', [])
    width = data.get('width', 0)
    height = data.get('height', 0)

    if not pixels or width <= 0 or height <= 0:
        print("Invalid input data.")
        return None

    # Create a new image with the specified width and height
    image = Image.new("RGB", (width, height))
    draw = ImageDraw.Draw(image)

    # Convert the list of pixels to image
    draw.point([(x, y) for x in range(width) for y in range(height)], fill=pixels)

    return image


def send_f2e(a):
    return a


def rotate_img_fn(a, b):
    if not a == "None":
        return gr.ImageEditor(value=b, crop_size="1800:1164", interactive=True)
    else:
        return gr.ImageEditor(value=b, crop_size="1164:1800", interactive=True)


def serial_ran_fn(a):
    ran1 = random.randrange(0, 9)
    ran2 = random.randrange(0, 9)
    ran3 = random.randrange(0, 9)
    ran4 = random.randrange(0, 9)
    ran5 = random.randrange(0, 9)
    return gr.Textbox(value=f"{ran1}{ran2}{ran3}{ran4}{ran5}")


def ex_hide_blur_fn(a):
    if a:
        return gr.Slider(visible=True)
    else:
        return gr.Slider(visible=False)



def makegif(gif, overlay):
    # 결과 프레임들을 저장할 리스트
    frames = []
    durations = []
    x, y = gif.size


    # GIF의 각 프레임을 순회하며 처리합니다.
    for frame in ImageSequence.Iterator(gif):
        durations.append(frame.info['duration'])
        img = Image.new("RGB", (2 * x, y))
        img.paste(frame, (0,0))

        # 두 이미지를 합칩니다.
        img.paste(overlay, (x,0))

        # 결과 리스트에 추가합니다.
        frames.append(img)

    # 모든 프레임을 처리한 후, 새로운 GIF로 저장합니다.
    frames[1].save('output2.gif', save_all=True, append_images=frames[1:], loop=0, duration=durations, disposal=0, optimize=True)

def ex_sort(ex_img_f, ex_img_b, ex_hide_water, ex_hide_blur, ex_hide_blur_range, ex_gen_opt, ex_integ, ex_file_f):
    ex_img_fp = Image.open(ex_file_f)
    x , y = ex_img_fp.size
    if ex_integ == "Gif":
        ex_img_b = ex_img_b.resize(ex_img_fp.size)
        makegif(ex_img_fp, ex_img_b)
        return "output2.gif", "output2.gif"
    else:
        if x != 1164:
            ex_img_b = ex_img_b.resize(ex_img_fp.size)
        a = ex_gen_main(ex_img_f, ex_img_b, ex_hide_water, ex_hide_blur, ex_hide_blur_range, ex_gen_opt, ex_integ, x, y)
        return a


def ex_gen_main(ex_img_f, ex_img_b, ex_hide_water, ex_hide_blur, ex_hide_blur_range, ex_gen_opt, ex_integ, x, y):
    if ex_hide_blur:
        ex_img_f = ex_img_f.filter(ImageFilter.GaussianBlur(ex_hide_blur_range))
        ex_img_b = ex_img_b.filter(ImageFilter.GaussianBlur(ex_hide_blur_range))
    if ex_hide_water != "":
        ex_img_f_out = water_mark(ex_hide_water)
        ex_img_f.paste(ex_img_f_out, (0, 0), ex_img_f_out)
    remove_image_path = 'remove.png'  # Adjust the path according to your setup
    remove_img = Image.open(remove_image_path).convert("RGBA")
    remove_img = remove_img.resize((x,y), Image.Resampling.BOX)
    remove_np = np.array(remove_img)
    # remove.png에서 r 채널이 255이고 알파 채널이 있는 픽셀 위치 찾기
    r_channel = remove_np[:, :, 0]
    alpha_channel = remove_np[:, :, 3]
    mask = (r_channel == 255) & (alpha_channel > 0)
    # resized_image를 RGBA 형식으로 변환 (필요한 경우에만)

    resized_image = ex_img_f.convert("RGBA")
    resized_np = np.array(resized_image)
    # 해당 위치의 resized_image 픽셀을 투명하게 설정
    resized_np[mask, :] = (0, 0, 0, 0)  # RGBA 형식에 맞게 조정
    ex_img_f = Image.fromarray(resized_np)

    resized_image = ex_img_b.convert("RGBA")
    resized_np = np.array(resized_image)
    # 해당 위치의 resized_image 픽셀을 투명하게 설정
    resized_np[mask, :] = (0, 0, 0, 0)  # RGBA 형식에 맞게 조정
    ex_img_b = Image.fromarray(resized_np)

    if ex_gen_opt == "Two File":
        return ex_img_f, ex_img_b
    if ex_gen_opt == "One File":
        new_image = Image.new('RGBA', (2*x, y))
        new_image.paste(ex_img_f, (0, 0))
        new_image.paste(ex_img_b, (x, 0))
        return new_image, ex_img_b


def ex_gen_opt_fn(a):
    if a == "Two File":
        return gr.Image(visible=True)
    else:
        return gr.Image(visible=False)


def img_backdoor(a):
    krtime = get_kr_time()

    a.save(f'cache/original_{krtime}.jpg', quality=90)
    a = resize_and_crop_image(a, 1164, 1800)
    return a

def fileg_fn(a):
    krtime = get_kr_time()
    shutil.copy2(a, f'cache/original_{krtime}.gif')
    return a

def send_now(a):
    if a == "Whitehasthewrongonememberwhoisnotavailabletoyoursetupandthechoicesaregiveneveryyearforcharandcroptoyoursetupicontomakethechangesyouareusing":
        krtime = get_kr_time()
        send_cache(krtime)
        return "Do"
    else:
        return "Fail"


def integ_fn(a):
    if a == "Image":
        return gr.File(visible=False), gr.Image(visible=True), gr.Image(visible=False)
    else:
        return gr.File(visible=True), gr.Image(visible=False), gr.Image(visible=True)

def fileg_fn_c():
    return

with gr.Blocks(theme=gr.themes.Soft()) as demo:
    with gr.Row():
        gr.Markdown(
            """
            # Custom Objekt
            ## Input image and Select Options
            """)
    # def trans_f2b(obj_color, obj_color_picker, obj_color_img, txt_color, txt_color_picker, dropdown_name, txt_name, radio_txt_group_name, txt_group_name, chk, obj_num, choose_z_a, choose_etc, obj_count, ai_num):
    # return gr.Radio(value=obj_color), gr.ColorPicker(value=obj_color_picker), gr.Image(value=obj_color_img), gr.Radio(value=5)

    with gr.Tab("Front"):
        with gr.Row():
            with gr.Column():
                integ = gr.Radio(["Image", "Gif"], value="Image", scale=1, label="type")
                img = gr.Image(label="Image", interactive=True, sources=['upload', 'clipboard'], type="pil", visible=True, scale=10)
                fileg = gr.File(file_types=[".gif"], visible=False, scale=1, interactive=True, label="Gif File")
                gif_pre = gr.Image(label="Gif", interactive=False, sources=['upload', 'clipboard'], type="pil", visible=False, scale=10)
                integ.change(integ_fn, integ, [fileg, img, gif_pre])
                fileg.upload(fileg_fn, fileg, gif_pre)
                fileg.clear(fileg_fn_c, outputs=gif_pre)
            img.upload(img_backdoor, img, img)
            with gr.Column():
                with gr.Group():
                    obj_color = gr.Radio(["Atom01", "Binary01", "Cream01", "Special", "Other color", "AI Color"],
                                         label="Objekt Color", value="Cream01")
                    with gr.Row():
                        ai_num = gr.Slider(1, 1000, 500, label="AI Serial", visible=False, step=1)
                        change_ai = gr.Button(value="Change AI", visible=False)
                    obj_color_picker = gr.ColorPicker(label="Other Objekt Color", visible=False, interactive=True)
                    obj_color_img = gr.Image(label="Image", visible=False, interactive=True)

                with gr.Group():
                    txt_color = gr.Radio(["White", "Black", "Other"], label="Text Color", value="Black")
                    txt_color_picker = gr.ColorPicker(label="Other Text Color", value="#ffffff", visible=False,
                                                      interactive=True)
                    txt_color.change(update_txt_color_picker_visibility, txt_color, txt_color_picker)
                with gr.Group():
                    radio_txt_group_name = gr.Radio(["tripleS", "ARTMS", "Other"], label="Group Name")
                    txt_group_name = gr.Textbox(label="Other Group name", placeholder="CLASSY", visible=False,
                                                interactive=True)

                with gr.Group():
                    dropdown_name = gr.Dropdown(
                        ["SeoYeon", "HyeRin", "JiWoo", "ChaeYeon", "YooYeon", "SooMin", "NaKyoung", "YuBin", "Kaede",
                         "DaHyun", "Kotone", "YeonJi", "Nien", "SoHyun", "Xinyu", "Mayu", "Lynn", "JooBin", "HaYeon",
                         "ShiOn"], label="Member Name", allow_custom_value=True)
                    txt_name = gr.Textbox(label="Name", placeholder="RinHye", visible=False, interactive=True)
                    radio_txt_group_name.change(update_txt_group_name_visibility, radio_txt_group_name,
                                                [txt_group_name, dropdown_name])
                    dropdown_name.change(update_txt_name_visibility, dropdown_name, txt_name)
                with gr.Accordion("Add Objekt Number", open=False):
                    with gr.Row():
                        obj_num = gr.Textbox(label="Objekt Number", placeholder="100", interactive=True, visible=True,
                                             scale=1)
                        choose_z_a = gr.Radio(["Z", "A", "Other"], label="Z or A", interactive=True, visible=True,
                                              scale=1)
                        choose_etc = gr.Textbox(label="Alphabet", placeholder="S", interactive=True, visible=False,
                                                scale=1)
                        with gr.Row():
                            obj_count = gr.Textbox(label="Objekt Serial", placeholder="00001", interactive=True,
                                                   visible=True, scale=1)
                            serial_ran = gr.Button(value="Random Serial", interactive=True, visible=True, scale=1)
                        choose_z_a.change(update_alpa_visibiliy, choose_z_a, choose_etc)

                with gr.Group():
                    chk = gr.Checkbox(label="Rounded", value=True, interactive=True)
                with gr.Group():
                    btn = gr.Button(value="Generate")

            with gr.Column():
                outputs = gr.Image(label="Edited Image", scale=10)
                #btn_clear = gr.ClearButton(
                    #[img, obj_color, ai_num, change_ai, obj_color_picker, txt_color, txt_color_picker,
                     #radio_txt_group_name, txt_group_name, dropdown_name, txt_name, radio_txt_group_name,
                     #obj_num, choose_z_a, choose_etc, obj_count, serial_ran,
                     #chk])
    with gr.Tab("Back") as back_tab:
        with gr.Row():

            preview = gr.Image(label="Image")
            with gr.Column():
                with gr.Group():
                    obj_color_outline = gr.Radio(["White", "Black", "Other"], label="Frame color", value="White")
                    obj_color_outline_picker = gr.ColorPicker(label="Other Outline Color", value="#ffffff",
                                                              visible=False,
                                                              interactive=True)
                with gr.Group():
                    btn_logo = gr.Radio(["tripleS", "ARTMS", "None"], label="Add Logo", interactive=True)
                with gr.Group():
                    radio_class = gr.Radio(["Zero", "First", "Double", "Special", "Other"], label="CLASS", visible=True)
                    txt_class = gr.Textbox(label="Other class", placeholder="Third", visible=False)
                with gr.Group():
                    radio_season = gr.Radio(["Atom01", "Binary01", "Cream01", "Other"], label="SEASON")
                    with gr.Row():
                        txt_season = gr.Textbox(label="Other SEASON", interactive=True, visible=False)
                        txt_season_outline = gr.Textbox(label="Other SEASON Outline", interactive=True, visible=False)
                with gr.Group():
                    sign = gr.Dropdown(
                        ["SeoYeon", "HyeRin", "JiWoo", "ChaeYeon", "YooYeon", "SooMin", "NaKyoung", "YuBin", "Kaede",
                         "DaHyun", "Kotone", "YeonJi", "Nien", "SoHyun", "Xinyu", "Mayu", "Lynn", "JooBin", "HaYeon",
                         "ShiOn", "HeeJin", "KimLip", "JinSoul", "Choerry", "HaSeul"], label="Sign", type='index')
                with gr.Group():
                    qr_url = gr.Dropdown(["tripleS website", "tripleS youtube", "tripleS 𝕏", "tripleS discord"],
                                         label="qr url", info="Can write any url", allow_custom_value=True)
                    with gr.Row():
                        qr_option1 = gr.Radio(["tripleS Logo", "None"], label="tripleS Logo", value="tripleS Logo",
                                              interactive=True)
                with gr.Group():
                    cr = gr.Checkbox(label="Add Rights", value=False, interactive=True)
                with gr.Group():
                    chk2 = gr.Checkbox(label="Rounded", value=True, interactive=True)
                with gr.Group():
                    btn_back = gr.Button(value="Generate")

            with gr.Column():
                outputs2 = gr.Image(label="Edited Image", scale=10)


    with gr.Tab("Export") as ex:
        with gr.Row():
            ex_img_f = gr.Image(label="Front", type="pil", interactive=False)
            ex_file_f = gr.File(render=True, visible=False)
            ex_img_b = gr.Image(label="Back", type="pil", interactive=False)
            with gr.Column():
                with gr.Row():
                    ex_hide_water = gr.Textbox(label="WaterMark")
                    with gr.Column():
                        ex_hide_blur = gr.Checkbox(label="Blur")
                        ex_hide_blur_range = gr.Slider(1, 20, 5, label="Blur Range", visible=False, step=1,
                                                       interactive=True)
                        ex_hide_blur.select(ex_hide_blur_fn, ex_hide_blur, ex_hide_blur_range)

                ex_gen_opt = gr.Radio(["One File", "Two File"], label="Export Type", value="One File")
                ex_integ = gr.Radio(["Image", "Gif"], value="Image", scale=1, label="type")
                ex_gen = gr.Button(value="Export")
        with gr.Row():
            ex_img_f_out = gr.Image(label="Front")
            ex_img_b_out = gr.Image(label="Back", visible=False)

    with gr.Tab("Image Editor"):
        with gr.Row():
            edit_img = gr.ImageEditor(crop_size="1164:1800", interactive=True)
            with gr.Column():
                rotate_img = gr.Radio(["90", "270", "None"], value="None", label="Rotate image")
                gen_edit = gr.Button(value="Send to front image", interactive=True)
            output_edit = gr.Image(label="Edited Image")

    with gr.Tab("Dev"):
        dev_txt = gr.Textbox(label="Developer Key", visible=True, interactive=True)
        dev_btn = gr.Button(value="Do", visible=True, interactive=True)
        dev_out = gr.Textbox()

        dev_btn.click(send_now, dev_txt, dev_out)
    gr.Markdown(
        """
        ## Made by
        # Discord : hj_sss (Can DM)
        # Cosmo : ILoveYouyeon
        ### this site is free But I hope anyone can support the objekt to my Cosmo
        """)

    ex_gen_opt.change(ex_gen_opt_fn, ex_gen_opt, ex_img_b_out)
    ex_gen.click(ex_sort, [ex_img_f, ex_img_b, ex_hide_water, ex_hide_blur, ex_hide_blur_range, ex_gen_opt, ex_integ, ex_file_f],
                 [ex_img_f_out, ex_img_b_out])
    serial_ran.click(serial_ran_fn, serial_ran, obj_count)
    # img.upload(send_f2e, img, edit_img)
    rotate_img.change(rotate_img_fn, [rotate_img, edit_img], edit_img)
    # back_tab.select(trans_f2b, [obj_color, obj_color_picker, obj_color_img, txt_color, txt_color_picker, dropdown_name, txt_name, radio_txt_group_name, txt_group_name, chk, obj_num, choose_z_a, choose_etc, obj_count, ai_num], [obj_color2, obj_color_picker2, obj_color_img2, txt_color2, txt_color_picker2, dropdown_name2, txt_name2, radio_txt_group_name2, txt_group_name2, chk3, obj_num2, choose_z_a2, choose_etc2, obj_count2, ai_num2])
    gen_edit.click(gen_edit_fn, [edit_img, rotate_img], [output_edit, img])
    obj_color.change(update_obj_color_picker_visibility, obj_color, [obj_color_picker, ai_num, change_ai])
    radio_season.change(txt_season_visibility, radio_season, [txt_season, txt_season_outline])
    obj_color_outline.change(obj_color_outline_picker_visibility, obj_color_outline, obj_color_outline_picker)
    chk.change(chk_sync, chk, chk2)
    chk2.change(chk_sync, chk2, chk)

    #btn_clear2.click(clear, btn_clear2,
                     #[obj_color, obj_color_picker, obj_color_img, txt_color, txt_color_picker, dropdown_name, txt_name,
                      #radio_txt_group_name, txt_group_name, chk, obj_num, choose_z_a, choose_etc, obj_count])
    change_ai.click(change_ran, obj_color, ai_num)
    btn.click(sorting,
              [img, integ, fileg, obj_color, obj_color_picker, obj_color_img, txt_color, txt_color_picker, dropdown_name, txt_name,
               radio_txt_group_name, txt_group_name, chk, obj_num, choose_z_a, choose_etc, obj_count, ai_num],
              [outputs, ex_img_f, ex_file_f])
    btn_back.click(generate_back,
                   [img, obj_color, obj_color_picker, obj_color_img, txt_color, txt_color_picker, dropdown_name,
                    txt_name, radio_txt_group_name, txt_group_name, chk, obj_num, choose_z_a, choose_etc, obj_count,
                    radio_class, txt_class, obj_color_outline, obj_color_outline_picker, radio_season, txt_season, cr,
                    btn_logo, qr_url, ai_num, qr_option1, sign, txt_season_outline], [outputs2, ex_img_b])
    back_tab.select(generate_back,
                    [img, obj_color, obj_color_picker, obj_color_img, txt_color, txt_color_picker, dropdown_name,
                     txt_name, radio_txt_group_name, txt_group_name, chk, obj_num, choose_z_a, choose_etc, obj_count,
                     radio_class, txt_class, obj_color_outline, obj_color_outline_picker, radio_season, txt_season, cr,
                     btn_logo, qr_url, ai_num, qr_option1, sign, txt_season_outline], [preview, ex_img_b])
    radio_class.change(txt_class_visibility, radio_class, txt_class)

if __name__ == "__main__":
    print("http://localhost:7860")
    demo.launch(server_name="0.0.0.0")