# 설치
pip install rembg

# 기본 사용법
from rembg import remove
from PIL import Image
import io

# 이미지 파일 배경 제거
with open('input.jpg', 'rb') as f:
    input_data = f.read()

output_data = remove(input_data)

with open('output.png', 'wb') as f:
    f.write(output_data)

print("배경 제거 완료! 🎉")

import cv2
from rembg import remove
from PIL import Image
import numpy as np

def remove_bg_from_video(input_path, output_path, new_bg_path=None):
    """
    영상 배경 제거 자동화 함수
    """
    cap = cv2.VideoCapture(input_path)
    fps = cap.get(cv2.CAP_PROP_FPS)
    width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
    height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
    total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
    
    # 출력 영상 설정 (RGBA 지원을 위해 PNG 시퀀스 권장)
    fourcc = cv2.VideoWriter_fourcc(*'mp4v')
    out = cv2.VideoWriter(output_path, fourcc, fps, (width, height))
    
    # 새 배경 이미지 로드 (선택사항)
    if new_bg_path:
        new_bg = cv2.imread(new_bg_path)
        new_bg = cv2.resize(new_bg, (width, height))
    
    frame_count = 0
    while cap.isOpened():
        ret, frame = cap.read()
        if not ret:
            break
        
        # OpenCV BGR → PIL RGB 변환
        frame_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
        pil_img = Image.fromarray(frame_rgb)
        
        # 배경 제거 (RGBA 결과)
        result = remove(pil_img)
        
        if new_bg_path:
            # 새 배경과 합성
            bg_pil = Image.fromarray(cv2.cvtColor(new_bg, cv2.COLOR_BGR2RGB))
            bg_pil.paste(result, (0, 0), result)
            final_frame = cv2.cvtColor(np.array(bg_pil), cv2.COLOR_RGB2BGR)
        else:
            # 투명 배경 → 흰색 배경
            white_bg = Image.new('RGB', result.size, (255, 255, 255))
            white_bg.paste(result, (0, 0), result)
            final_frame = cv2.cvtColor(np.array(white_bg), cv2.COLOR_RGB2BGR)
        
        out.write(final_frame)
        frame_count += 1
        print(f"처리 중: {frame_count}/{total_frames} 프레임", end='\r')
    
    cap.release()
    out.release()
    print(f"\n완료! 총 {frame_count}개 프레임 처리됨 🎉")

# 실행
remove_bg_from_video('input_video.mp4', 'output_video.mp4', 'new_background.jpg')

# GPU 가속 rembg 사용
from rembg import remove, new_session

# GPU 세션 생성 (CUDA 필요)
session = new_session("u2net")  # 또는 "isnet-general-use"

# 배치 처리로 속도 향상
from rembg import remove
import onnxruntime as ort

# CUDA 사용 가능 여부 확인
providers = ort.get_available_providers()
print("사용 가능한 프로바이더:", providers)
# ['CUDAExecutionProvider', 'CPUExecutionProvider'] 이면 GPU 사용 가능!

import cv2
import numpy as np

def chroma_key_auto(frame, new_bg, 
                    lower_green=(35, 50, 50), 
                    upper_green=(85, 255, 255)):
    """
    OpenCV 기반 크로마키 자동화
    HSV 색상 공간에서 초록색 범위를 마스킹
    """
    # BGR → HSV 변환 (HSV가 색상 범위 지정에 유리)
    hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)
    
    # 초록색 마스크 생성
    mask = cv2.inRange(hsv, 
                       np.array(lower_green), 
                       np.array(upper_green))
    
    # 마스크 정제 (노이즈 제거)
    kernel = np.ones((5, 5), np.uint8)
    mask = cv2.morphologyEx(mask, cv2.MORPH_OPEN, kernel)   # 작은 노이즈 제거
    mask = cv2.morphologyEx(mask, cv2.MORPH_DILATE, kernel) # 경계 확장
    
    # 가우시안 블러로 경계 부드럽게
    mask_blur = cv2.GaussianBlur(mask, (7, 7), 0)
    
    # 마스크 반전 (피사체 부분)
    mask_inv = cv2.bitwise_not(mask_blur)
    
    # 피사체 추출
    fg = cv2.bitwise_and(frame, frame, mask=mask_inv)
    
    # 배경 적용
    bg_resized = cv2.resize(new_bg, (frame.shape[1], frame.shape[0]))
    bg = cv2.bitwise_and(bg_resized, bg_resized, mask=mask_blur)
    
    # 합성
    result = cv2.add(fg, bg)
    return result

# 영상 처리
cap = cv2.VideoCapture('green_screen_video.mp4')
new_bg = cv2.imread('new_background.jpg')

while cap.isOpened():
    ret, frame = cap.read()
    if not ret:
        break
    
    result = chroma_key_auto(frame, new_bg)
    cv2.imshow('크로마키 결과', result)
    
    if cv2.waitKey(1) & 0xFF == ord('q'):
        break

cap.release()
cv2.destroyAllWindows()

import cv2
import numpy as np

def suppress_green_spill(frame, mask, strength=0.8):
    """
    그린 스필 억제 함수
    마스크 경계 영역에서 초록 채널을 억제
    """
    # 경계 영역 추출 (마스크 팽창 - 마스크)
    kernel = np.ones((10, 10), np.uint8)
    dilated = cv2.dilate(mask, kernel, iterations=2)
    edge_region = cv2.subtract(dilated, mask)
    
    # 경계 영역에서 초록 채널 억제
    result = frame.copy().astype(np.float32)
    
    # 경계 영역 픽셀에서 G 채널을 R,B 채널 평균으로 대체
    edge_pixels = edge_region > 0
    r_channel = result[:, :, 2]  # BGR에서 R
    b_channel = result[:, :, 0]  # BGR에서 B
    g_channel = result[:, :, 1]  # BGR에서 G
    
    # 스필 억제: G = max(G, (R+B)/2) 반전
    avg_rb = (r_channel + b_channel) / 2
    spill_mask = (g_channel > avg_rb) & edge_pixels
    
    result[:, :, 1][spill_mask] = (
        avg_rb[spill_mask] * strength + 
        g_channel[spill_mask] * (1 - strength)
    )
    
    return result.astype(np.uint8)

# MediaPipe로 실시간 배경 제거
import cv2
import mediapipe as mp
import numpy as np

mp_selfie = mp.solutions.selfie_segmentation

cap = cv2.VideoCapture(0)  # 웹캠
new_bg = cv2.imread('background.jpg')

with mp_selfie.SelfieSegmentation(model_selection=1) as selfie_seg:
    while cap.isOpened():
        ret, frame = cap.read()
        if not ret:
            break
        
        # BGR → RGB
        rgb_frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
        results = selfie_seg.process(rgb_frame)
        
        # 세그멘테이션 마스크 (0~1 사이 값)
        mask = results.segmentation_mask
        condition = np.stack((mask,) * 3, axis=-1) > 0.5
        
        # 배경 리사이즈
        bg = cv2.resize(new_bg, (frame.shape[1], frame.shape[0]))
        
        # 합성
        output = np.where(condition, frame, bg)
        
        cv2.imshow('실시간 배경 제거 🎬', output)
        if cv2.waitKey(5) & 0xFF == 27:  # ESC 종료
            break

cap.release()
cv2.destroyAllWindows()