# ICLight

Ilumina de nuevo cualquier imagen con control de iluminación potenciado por IA.

{% hint style="success" %}
Todos los ejemplos se pueden ejecutar en servidores GPU alquilados a través de [CLORE.AI Marketplace](https://clore.ai/marketplace).
{% endhint %}

{% hint style="info" %}
Todos los ejemplos en esta guía se pueden ejecutar en servidores GPU alquilados a través de [CLORE.AI Marketplace](https://clore.ai/marketplace) marketplace.
{% endhint %}

## Alquilar en CLORE.AI

1. Visita [CLORE.AI Marketplace](https://clore.ai/marketplace)
2. Filtrar por tipo de GPU, VRAM y precio
3. Elegir **Bajo demanda** (tarifa fija) o **Spot** (precio de puja)
4. Configura tu pedido:
   * Selecciona imagen Docker
   * Establece puertos (TCP para SSH, HTTP para interfaces web)
   * Agrega variables de entorno si es necesario
   * Introduce el comando de inicio
5. Selecciona pago: **CLORE**, **BTC**, o **USDT/USDC**
6. Crea el pedido y espera el despliegue

### Accede a tu servidor

* Encuentra los detalles de conexión en **Mis Pedidos**
* Interfaces web: Usa la URL del puerto HTTP
* SSH: `ssh -p <port> root@<proxy-address>`

## ¿Qué es IC-Light?

IC-Light de lllyasviel permite:

* Reiluminar imágenes con descripciones de texto
* Cambiar la dirección y el color de la iluminación
* Agregar o eliminar sombras
* Crear efectos de iluminación de estudio
* Reiluminación de primer plano/fondo

## Recursos

* **GitHub:** [lllyasviel/IC-Light](https://github.com/lllyasviel/IC-Light)
* **HuggingFace:** [lllyasviel/IC-Light](https://huggingface.co/lllyasviel/IC-Light)
* **Demo:** [HuggingFace Space](https://huggingface.co/spaces/lllyasviel/IC-Light)
* **Paper:** Basado en la arquitectura ControlNet

## Hardware recomendado

| Componente     | Mínimo        | Recomendado   | Óptimo        |
| -------------- | ------------- | ------------- | ------------- |
| GPU            | RTX 3060 12GB | RTX 4080 16GB | RTX 4090 24GB |
| VRAM           | 8GB           | 12GB          | 16GB          |
| CPU            | 4 núcleos     | 8 núcleos     | 16 núcleos    |
| RAM            | 16GB          | 32GB          | 64GB          |
| Almacenamiento | 30GB SSD      | 50GB NVMe     | 100GB NVMe    |
| Internet       | 100 Mbps      | 500 Mbps      | 1 Gbps        |

## Despliegue rápido en CLORE.AI

**Imagen Docker:**

```
pytorch/pytorch:2.5.1-cuda12.4-cudnn9-devel
```

**Puertos:**

```
22/tcp
7860/http
```

**Comando:**

```bash
cd /workspace && \
git clone https://github.com/lllyasviel/IC-Light.git && \
cd IC-Light && \
pip install -r requirements.txt && \
python gradio_demo.py
```

## Accediendo a tu servicio

Después del despliegue, encuentra tu `http_pub` URL en **Mis Pedidos**:

1. Ir a **Mis Pedidos** página
2. Haz clic en tu pedido
3. Encuentra la `http_pub` URL (por ejemplo, `abc123.clorecloud.net`)

Usa `https://TU_HTTP_PUB_URL` en lugar de `localhost` en los ejemplos abajo.

## Instalación

```bash
git clone https://github.com/lllyasviel/IC-Light.git
cd IC-Light
pip install -r requirements.txt

# Los modelos se descargan automáticamente en la primera ejecución
```

## Lo que puedes crear

### Fotografía de producto

* Iluminación perfecta para comercio electrónico
* Imágenes de catálogo consistentes
* Resultados con calidad de estudio sin estudio

### Mejora de retratos

* Arregla la mala iluminación en fotos
* Agrega efectos de iluminación dramáticos
* Crea fotos profesionales de cabeza (headshots)

### Proyectos creativos

* Transformación del ambiente
* Conversión de día a noche
* Efectos de iluminación artísticos

### Producción de video

* Iguala la iluminación entre escenas
* Crea metraje listo para VFX
* Soluciona problemas de iluminación en locación

### Materiales de marketing

* Creación de imágenes principales (hero image)
* Imágenes de marca consistentes
* Retoque rápido de fotografías

## Uso básico

### Reiluminación de primer plano (Modo FC)

Reilumina el sujeto manteniendo el fondo intacto:

```python
import torch
from PIL import Image
from diffusers import StableDiffusionPipeline
from ic_light import ICLightFC

# Cargar modelo
model = ICLightFC.from_pretrained("lllyasviel/IC-Light-FC")
model.to("cuda")

# Cargar imagen
image = Image.open("portrait.jpg")

# Reiluminar con prompt de texto
result = model.relight(
    image=image,
    prompt="luz dorada de la hora dorada desde la izquierda",
    num_inference_steps=25
)

result.save("relit_portrait.jpg")
```

### Condicionado por fondo (Modo FBC)

Reilumina el primer plano para coincidir con un nuevo fondo:

```python
from ic_light import ICLightFBC
from PIL import Image

model = ICLightFBC.from_pretrained("lllyasviel/IC-Light-FBC")
model.to("cuda")

# Cargar primer plano y nuevo fondo
foreground = Image.open("person.png")  # Con fondo transparente
background = Image.open("sunset_scene.jpg")

# Reiluminar para que coincida con el fondo
result = model.relight(
    foreground=foreground,
    background=background,
    prompt="iluminación cálida de atardecer",
    num_inference_steps=25
)

result.save("composited.jpg")
```

## Prompts de iluminación

### Iluminación basada en dirección

```python
prompts = [
    "luz brillante desde el lado izquierdo",
    "luz suave desde arriba",
    "contraluz dramático desde atrás",
    "luz de borde desde la derecha",
    "luz difusa frontal",
    "luz a baja altura desde abajo"
]
```

### Iluminación basada en color

```python
prompts = [
    "luz dorada cálida",
    "crepúsculo azul frío",
    "luz neón rosa",
    "luz ambiental verde",
    "resplandor anaranjado del atardecer",
    "iluminación de estudio blanca"
]
```

### Iluminación basada en entorno

```python
prompts = [
    "luz de día exterior, sol brillante",
    "luz de ventana interior, sombras suaves",
    "luces nocturnas de la ciudad, reflejos de neón",
    "luz de vela, parpadeo cálido",
    "día nublado, iluminación difusa",
    "softbox de estudio, profesional"
]
```

## Procesamiento por lotes

```python
import os
from PIL import Image
from ic_light import ICLightFC

model = ICLightFC.from_pretrained("lllyasviel/IC-Light-FC")
model.to("cuda")

input_dir = "./images"
output_dir = "./relit"
os.makedirs(output_dir, exist_ok=True)

lighting_prompt = "iluminación profesional de estudio, sombras suaves"

for filename in os.listdir(input_dir):
    if not filename.endswith(('.jpg', '.png')):
        continue

    image = Image.open(os.path.join(input_dir, filename))

    result = model.relight(
        image=image,
        prompt=lighting_prompt,
        num_inference_steps=25
    )

    result.save(os.path.join(output_dir, f"relit_{filename}"))
    print(f"Procesado: {filename}")
```

## Variaciones múltiples de iluminación

```python
from ic_light import ICLightFC
from PIL import Image
import os

model = ICLightFC.from_pretrained("lllyasviel/IC-Light-FC")
model.to("cuda")

image = Image.open("product.jpg")

lighting_variations = {
    "daylight": "luz natural brillante de día, fondo blanco limpio",
    "dramatic": "iluminación lateral dramática, sombras oscuras",
    "warm": "hora dorada cálida, suave resplandor naranja",
    "cool": "iluminación azul fría, estética moderna",
    "studio": "softbox profesional de estudio, iluminación uniforme"
}

os.makedirs("./variations", exist_ok=True)

for name, prompt in lighting_variations.items():
    result = model.relight(
        image=image,
        prompt=prompt,
        num_inference_steps=25
    )
    result.save(f"./variations/{name}.jpg")
    print(f"Generado: {name}")
```

## Interfaz Gradio

```python
import gradio as gr
from PIL import Image
from ic_light import ICLightFC

model = ICLightFC.from_pretrained("lllyasviel/IC-Light-FC")
model.to("cuda")

def relight_image(image, prompt, steps, seed):
    generator = torch.Generator("cuda").manual_seed(seed) if seed > 0 else None

    result = model.relight(
        image=image,
        prompt=prompt,
        num_inference_steps=steps,
        generator=generator
    )

    return result

demo = gr.Interface(
    fn=relight_image,
    inputs=[
        gr.Image(type="pil", label="Imagen de entrada"),
        gr.Textbox(
            label="Prompt de iluminación",
            value="iluminación profesional de estudio",
            placeholder="Describe la iluminación deseada..."
        ),
        gr.Slider(10, 50, value=25, step=5, label="Pasos"),
        gr.Number(value=-1, label="Semilla (-1 para aleatorio)")
    ],
    outputs=gr.Image(label="Imagen reiluminada"),
    title="IC-Light - Reiluminación de imágenes con IA",
    description="Cambia la iluminación en cualquier imagen con descripciones de texto. Ejecutándose en servidores GPU de CLORE.AI.",
    examples=[
        ["example.jpg", "luz de la hora dorada desde la izquierda", 25, -1],
        ["example.jpg", "iluminación de borde dramática, fondo oscuro", 25, -1],
        ["example.jpg", "luz suave de ventana, sombras suaves", 25, -1]
    ]
)

demo.launch(server_name="0.0.0.0", server_port=7860)
```

## Integración con ComfyUI

IC-Light está disponible como nodos de ComfyUI:

```bash
cd ComfyUI/custom_nodes
git clone https://github.com/kijai/ComfyUI-IC-Light.git
```

### Flujo de trabajo en ComfyUI

1. Carga tu imagen
2. Agrega el nodo IC-Light Loader
3. Conecta al nodo IC-Light Apply
4. Configura el prompt de iluminación
5. Conecta al KSampler
6. Salida a Guardar Imagen

## Con eliminación de fondo

```python
from ic_light import ICLightFBC
from rembg import remove
from PIL import Image

# Quitar fondo primero
original = Image.open("photo.jpg")
foreground = remove(original)

# Cargar nuevo fondo
background = Image.open("studio_bg.jpg")

# Reiluminar para que coincida
model = ICLightFBC.from_pretrained("lllyasviel/IC-Light-FBC")
model.to("cuda")

result = model.relight(
    foreground=foreground,
    background=background,
    prompt="iluminación de estudio que coincida con el fondo",
    num_inference_steps=25
)

result.save("composited.jpg")
```

## Rendimiento

| Modo              | Resolución | GPU      | Velocidad |
| ----------------- | ---------- | -------- | --------- |
| FC (primer plano) | 512x512    | RTX 3090 | 3s        |
| FC (primer plano) | 512x512    | RTX 4090 | 2s        |
| FBC (composición) | 512x512    | RTX 4090 | 3s        |
| FC (primer plano) | 1024x1024  | A100     | 4s        |

## Variantes de modelo

| Modelo       | Descripción                    | Caso de uso                        |
| ------------ | ------------------------------ | ---------------------------------- |
| IC-Light-FC  | Consistente en primer plano    | Reiluminación de imagen individual |
| IC-Light-FBC | Consistente primer plano-fondo | Composición con fondos             |

## Problemas comunes y soluciones

### La iluminación no cambia

**Problema:** La salida se parece a la entrada

**Soluciones:**

* Usa prompts de iluminación más descriptivos
* Aumenta los pasos de inferencia a 30-40
* Prueba diferentes valores de semilla
* Usa contraste más fuerte en el prompt (p. ej., "dramático" vs "suave")

```python

# Prompt más descriptivo
result = model.relight(
    image=image,
    prompt="foco dramático extremadamente brillante desde la esquina superior izquierda, sombras oscuras en el lado derecho",
    num_inference_steps=35
)
```

### Artefactos en la cara/detalles

**Problema:** La cara o los detalles se ven distorsionados

**Soluciones:**

* Reducir la intensidad/escala de guía
* Usa más pasos de inferencia
* Mantén los cambios de iluminación sutiles
* Posprocesa con restauración facial

### Problemas de cambio de color

**Problema:** Cambios de color no deseados

**Soluciones:**

* Sé específico sobre el color en el prompt
* Agrega "preservar los colores originales" al prompt
* Usa descripciones de iluminación neutrales en color
* Posprocesa con corrección de color

### Cambios en el fondo

**Problema:** El fondo cambia cuando solo debería el primer plano

**Soluciones:**

* Usa modo FC (consistente en primer plano)
* Preprocesa con eliminación de fondo
* Usa una máscara para aislar al sujeto

### Resultados inconsistentes

**Problema:** El mismo prompt da resultados muy diferentes

**Soluciones:**

* Establece una semilla fija para reproducibilidad
* Aumenta los pasos de inferencia para mayor estabilidad
* Usa prompts más simples y directos

```python

# Resultados consistentes con semilla fija
result = model.relight(
    image=image,
    prompt=prompt,
    num_inference_steps=30,
    generator=torch.Generator("cuda").manual_seed(42)
)
```

## Solución de problemas

### La reiluminación se ve poco natural

* Haz coincidir la dirección de la luz con la escena
* Usa intensidad de luz apropiada
* Considera las sombras en la imagen original

### Fondo afectado

* Usa correctamente la máscara de primer plano
* Segmenta el sujeto del fondo primero
* Ajusta la caída de la luz (light falloff)

### La salida está demasiado oscura/clara

* Ajusta los valores de intensidad de la luz
* Usa salida HDR si está disponible
* Posprocesa con curvas

### El modelo no carga

* Descarga todos los checkpoints requeridos
* Comprueba la integridad de los archivos
* Verifica la compatibilidad con CUDA

## Estimación de costos

Tarifas típicas del marketplace de CLORE.AI (a fecha de 2024):

| GPU       | Tarifa por hora | Tarifa diaria | Sesión de 4 horas |
| --------- | --------------- | ------------- | ----------------- |
| RTX 3060  | \~$0.03         | \~$0.70       | \~$0.12           |
| RTX 3090  | \~$0.06         | \~$1.50       | \~$0.25           |
| RTX 4090  | \~$0.10         | \~$2.30       | \~$0.40           |
| A100 40GB | \~$0.17         | \~$4.00       | \~$0.70           |
| A100 80GB | \~$0.25         | \~$6.00       | \~$1.00           |

*Los precios varían según el proveedor y la demanda. Consulta* [*CLORE.AI Marketplace*](https://clore.ai/marketplace) *para las tarifas actuales.*

**Ahorra dinero:**

* Usa **Spot** market para cargas de trabajo flexibles (a menudo 30-50% más barato)
* Paga con **CLORE** tokens
* Compara precios entre diferentes proveedores

## Próximos pasos

* [TripoSR](https://docs.clore.ai/guides/guides_v2-es/generacion-3d/triposr) - Convertir imágenes reiluminadas a 3D
* Stable Diffusion - Generar imágenes para reiluminar
* ComfyUI - Integración avanzada de flujos de trabajo
* [Fooocus](https://docs.clore.ai/guides/guides_v2-es/generacion-de-imagenes/fooocus-simple-sd) - Generación de imágenes simple