Qwen-Image-Edit-2509-tutorial: Studio-klare producthoeken genereren

Soloverkopers en kleine merken hebben zelden het budget voor een volledige productfotoshoot. In deze gids bouwen en draaien we een Gradio-app die één invoerafbeelding transformeert naar e-commerceklare productrenders met meerdere hoeken (wijd, macro, ±45°, top-down) met behulp van Qwen-Image-Edit-2509 met LoRA-gebaseerde virtuele camerabediening voor reproduceerbare AI-productfotografie.

Onder de motorkap gebruiken we:

• Basismodel: Qwen/Qwen-Image-Edit-2509 (Apache-2.0)
• Angle control LoRA: dx8152/Qwen-Edit-2509-Multiple-angles
• Optionele speed LoRA: lightx2v/Qwen-Image-Lightning

In deze tutorial leer je hoe je:

• de Qwen-editpipeline laadt en meerdere LoRA’s stapelt.
• camerabewegingen aanstuurt met robuuste angle-macro’s.
• een strakke Gradio-UI bouwt voor makers en ecommerceteams.
• alle resultaten als ZIP exporteert voor makkelijke overdracht.

Wil je meer leren over hoe beelddata wordt verwerkt in deep learning? Bekijk dan de Image Processing in Python skill track. 

Waarom Qwen Image Edit gebruiken met Multiple Angles LoRA?

Qwen-Image-Edit-2509 is de nieuwste iteratie van Qwen’s bewerkmodel voor afbeeldingen met verbeterde consistentie en multi-image editing. De Multiple-Angles LoRA voegt betrouwbare besturing voor een “virtuele camera” toe, zodat je kunt zeggen:

• 将镜头转为广角镜头 (schakel naar groothoek)
• 将镜头转为特写镜头 (schakel naar close-up)
• 将镜头向左旋转45度 (roteer 45° naar links)
• 将镜头转为俯视 (bovenaanzicht)

Deze commando’s kaderen hetzelfde product consequent opnieuw in zonder te hallucineren naar een ander product.

Qwen Image Edit stapsgewijze tutorial: een Product Shot Booster bouwen 

In deze gids bouwen we een app die één productafbeelding omzet in een studioklare set hoeken (inclusief wijd, close-up, 45° links/rechts en bovenaanzicht), met optionele lifestyle-presets en snelle previewmodus. Hij gebruikt het Qwen/Qwen-Image-Edit-2509-model en een Multiple-Angles LoRA, verpakt in een Gradio-UI.

We gaan van het inrichten van de omgeving naar het laden van het model, hulpfuncties voor generatie en een web-UI.

Stap 1: Vereisten

Installeer eerst alle runtime-afhankelijkheden. We gebruiken PyTorch met CUDA-wheels, tooling van Hugging Face, de Diffusers-bibliotheek, Gradio voor de UI en Pillow/OpenCV voor beeldverwerking.

pip install -q torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu121
pip install -q transformers>=4.44.0 accelerate>=0.33.0 safetensors>=0.4.3
pip install -q pillow>=10.2.0 huggingface_hub>=0.24.0 opencv-python-headless>=4.9.0.80
pip install -q numpy>=1.26.0 gradio>=4.0.0
pip install -q git+https://github.com/huggingface/diffusersMogelijk gemaakt door

Dit doet elke vereiste:

• CUDA-wheels: De PyTorch-regel wijst naar NVIDIA CUDA 12.1-wheels voor GPU-versnelling.
• Transformers en Diffusers: Transformers beheert configs en tokenizers terwijl Diffusers de QwenImageEditPlusPipeline levert.
• Safetensors: Biedt een veilig tensorformaat (sneller en veiliger dan Pickle).
• OpenCV-headless en Pillow: Voor robuuste image I/O en resizing bij pre-/post-processing.
• Gradio: Een snelle web-UI die lokaal en in Colab werkt.

Met de omgeving klaar kunnen we authenticeren bij Hugging Face (optioneel) en modellen laden.

Stap 2: Authenticatie bij Hugging Face

Sommige modellen of adapters vereisen authenticatie bij Hugging Face. Deze stap logt je één keer in voor de sessie.

from huggingface_hub import login
import os
HF_TOKEN = "Your_HF_Token"  # @param {type:"string"}
if HF_TOKEN:
    login(token=HF_TOKEN)
    print("Logged in to Hugging Face")
else:
    print("WARNING: No token provided. Continuing without authentication")Mogelijk gemaakt door

Log eerst in op je Hugging Face-account en zoek naar Access Tokens binnen je accountinstellingen. Klik op Create new token en genereer een nieuwe token met het type Read token. Selecteer de vereiste permissies en genereer een nieuwe token.

Gebruik in productie/Colab geen hardcoded tokens, maar omgevingsvariabelen of Colab “Secrets”.

Stap 3: Model laden en pipeline instellen

In deze sectie richten we de Qwen-Image-Edit-pipeline in, laden we de angles-LoRA en voegen we een Fast-toggle toe met GPU-bewuste instellingen. Let op: deze code draait efficiënt op een A100 GPU met veel RAM.

Stap 3.1:  Imports en GPU-config

Nu importeren we kernbibliotheken en detecteren we de GPU om precisie, attention slicing en VAE slicing automatisch in te stellen voor stabiliteit.

import io
import zipfile
from typing import List, Tuple, Optional
import gc
import torch
from PIL import Image
from diffusers import QwenImageEditPlusPipeline
import gradio as gr
def get_gpu_config():
    if not torch.cuda.is_available():
        return {
            'device': 'cpu',
            'dtype': torch.float32,
            'gpu_name': 'CPU',
            'vram_gb': 0,
            'max_batch': 1,
            'enable_attention_slicing': True,
            'enable_vae_slicing': True,
        }
    gpu_name = torch.cuda.get_device_name(0)
    vram_gb = torch.cuda.get_device_properties(0).total_memory / 1e9 
    if 'T4' in gpu_name or vram_gb < 20:
        return {
            'device': 'cuda',
            'dtype': torch.bfloat16,
            'gpu_name': gpu_name,
            'vram_gb': vram_gb,
            'max_batch': 1,
            'enable_attention_slicing': True,
            'enable_vae_slicing': True,
        }
    else:
        return {
            'device': 'cuda',
            'dtype': torch.bfloat16,
            'gpu_name': gpu_name,
            'vram_gb': vram_gb,
            'max_batch': 2,
            'enable_attention_slicing': False,
            'enable_vae_slicing': False,
        }
gpu_config = get_gpu_config()
HF_BASE_MODEL = "Qwen/Qwen-Image-Edit-2509"
LORA_ANGLES = "dx8152/Qwen-Edit-2509-Multiple-angles"
LORA_LIGHTNING = "lightx2v/Qwen-Image-Lightning"
ANGLE_MACROS = {
    "Wide-angle": "将镜头转为广角镜头",
    "Close-up": "将镜头转为特写镜头",
    "Forward": "将镜头向前移动",
    "Left": "将镜头向左移动",
    "Right": "将镜头向右移动",
    "Down": "将镜头向下移动",
    "Rotate 45° Left": "将镜头向左旋转45度",
    "Rotate 45° Right": "将镜头向右旋转45度",
    "Top-down": "将镜头转为俯视",
}
BACKGROUND_PRESETS = {
    "(None)": None,
    "Pure Studio (white seamless)": "in a professional studio with seamless white background, soft shadows, product centered",
    "Soft Gray Studio": "in a professional studio with seamless soft gray background, gentle vignette, softbox lighting",
    "Lifestyle (cozy desk)": "on a cozy wooden desk near a window, soft natural light, minimal props",
    "Lifestyle (marble)": "on a clean white marble surface, bright daylight, subtle reflections",
    "Lifestyle (outdoor)": "outdoors on a neutral table, soft shade, bokeh background",
}
ASPECT_RATIOS = {
    "1:1 (Square)": (1024, 1024),
    "4:3 (Standard)": (1024, 768),
    "3:4 (Portrait)": (768, 1024),
    "16:9 (Widescreen)": (1024, 576),
    "9:16 (Mobile)": (576, 1024),
    "3:2 (Photo)": (1024, 683),
    "2:3 (Portrait Photo)": (683, 1024),
}Mogelijk gemaakt door

Dit zijn de belangrijkste onderdelen van de bovenstaande codeblokken:

• GPU auto-config (functie get_gpu_config): We detecteren de beschikbare accelerator en geven een kleine config-dict terug die wordt gebruikt om het device (cpu/cuda), de dtype (zoals bfloat16 op GPU) en geheugengedrag te kiezen:
• Op CPU gebruiken we standaard float32 en schakelen we attention/VAE slicing in voor veiligheid.
• Op T4 / <20 GB VRAM houden we bfloat16 aan maar zetten we slicing aan om OOM’s te voorkomen.
• Op GPU’s met 20 GB+ (zoals A100) schakelen we slicing uit en staan we een grotere batch toe voor snelheid.
• Model-ID’s en adapters: We laden Qwen-Image-Edit-2509 als de kerneditor, samen met de Multiple-angles LoRA voor camerabediening, en mengen optioneel de Lightning LoRA wanneer je omschakelt naar Fast Mode.  
• HF_BASE_MODEL = "Qwen/Qwen-Image-Edit-2509" is de hoofdruggengraat voor image-editing.
• LORA_ANGLES = "dx8152/Qwen-Edit-2509-Multiple-angles" voegt “virtuele camera”-bediening toe.
• LORA_LIGHTNING = "lightx2v/Qwen-Image-Lightning" is een optionele speed-adapter voor snelle previews.

Opmerking: voor HQ Mode blijft alleen de angles-adapter actief.

• Angle-macro’s: ANGLE_MACROS koppelt labels zoals “Wide-angle” of “Top-down” aan equivalente Chinese commando’s die de angles-LoRA betrouwbaar begrijpt. Deze commando’s bewegen de virtuele camera consequent (move/rotate/zoom) zonder de identiteit te veranderen.
• Achtergrondpresets: BACKGROUND_PRESETS zijn korte Engelse fragmenten zoals “marble surface”, “soft gray studio”, die we samenvoegen in de uiteindelijke prompt. Ze staan los van de angle-macro’s en zijn verantwoordelijk voor de scenecontrole.
• Beeldverhoudingen (ASPECT_RATIOS): Hiermee genereren we een canvas (1:1, 4:3, 16:9, enz.) en passen we de invoer voorafgaand aan inference aan via resize of center-crop, zodat outputs geen croppostprocessing nodig hebben.

We hebben nu GPU en adapters ingesteld. Laten we de Diffusers-pipeline instantieren en de LoRA’s koppelen.

Stap 3.2: Pipeline

Vervolgens laden we de basis Qwen Edit-pipeline, schakelen we geheugenoptimalisaties in op basis van de GPU en stapelen we de Multiple-Angles LoRA. We implementeren ook een moduswissel om optioneel de Lightning LoRA toe te voegen voor snelle previews.

pipe = QwenImageEditPlusPipeline.from_pretrained(
    HF_BASE_MODEL,
    torch_dtype=gpu_config['dtype'],
)
pipe = pipe.to(gpu_config['device'])
if gpu_config['enable_attention_slicing']:
    pipe.enable_attention_slicing()
if gpu_config['enable_vae_slicing']:
    pipe.enable_vae_slicing()
pipe.load_lora_weights(LORA_ANGLES, adapter_name="angles")
current_mode = {"fast": False}
def set_pipeline_mode(use_lightning: bool):
    global current_mode  
    if use_lightning and not current_mode["fast"]:
        pipe.load_lora_weights(LORA_LIGHTNING, adapter_name="lightning")
        pipe.set_adapters(["angles", "lightning"], adapter_weights=[1.0, 1.0])
        current_mode["fast"] = True
    elif not use_lightning and current_mode["fast"]:
        pipe.set_adapters(["angles"], adapter_weights=[1.0])
        current_mode["fast"] = False
    elif not use_lightning and not current_mode["fast"]:
        pipe.set_adapters(["angles"], adapter_weights=[1.0])
set_pipeline_mode(False)Mogelijk gemaakt door

De bovenstaande code is de pipeline-setup voor de Product Shot Booster-app en voert het volgende uit:

• Pipeline-initialisatie: Instantieert de QwenImageEditPlusPipeline vanuit het basismodel (Qwen/Qwen-Image-Edit-2509), verplaatst deze naar het gedetecteerde device (CPU/GPU) en stelt de tensorprecisie (torch_dtype) in op basis van je hardware.
• Geheugenveiligheid: Op kleinere GPU’s schakelt hij attention- en VAE-slicing in om piek-VRAM te verlagen en out-of-memory-fouten te vermijden, met een kleine snelheidsruil voor stabiliteit.
• LoRA-compositie: Laadt de Multiple-Angles LoRA om herhaalbare “virtuele camera”-bediening (move/rotate/zoom) te bieden en mengt optioneel de Lightning LoRA voor snellere previews.
• Moduswissellogica: De helperfunctie set_pipeline_mode() en een current_mode-vlag beheren HQ versus Fast-states, voorkomen overbodige Lightning-reloads en laten je adapters omschakelen.

De pipeline is nu klaar. Laten we doorgaan met de generatiefuncties en de Gradio-UI.

Stap 4: Generatiefuncties

Generatiefuncties verzorgen de generatie door prompts te bouwen, te resizen naar de doelverhouding, de pipeline over geselecteerde hoeken te laten lopen en resultaten te verpakken als een zipbestand.

Stap 4.1: Prompt Composer en  hulpfuncties voor image resize

Voordat we het model aanroepen, normaliseren we invoer met twee stateless helpers:

• compose_prompt()-functie: Deze functie stelt één instructiestring samen uit camerahoek, achtergrondpreset, aangepaste scene en stijlaantekeningen. Bondige zinsdelen helpen Qwen’s instructieparsing stabiel te houden en voorkomen dat één onderdeel te zwaar weegt.
• resize_image()-functie: Past de bronafbeelding aan naar de doelverhouding met een scale-to-cover-strategie; Lanczos-resampling helpt bij hoogkwalitatief down-/upscalen, en een center-crop houdt het onderwerp in beeld.

def compose_prompt(angle_phrase: str,
                   bg_preset_text: Optional[str],
                   custom_scene: str,
                   extra_style: str) -> str:
    parts = [angle_phrase]
    if bg_preset_text:
        parts.append(f"{bg_preset_text}")
    if custom_scene.strip():
        parts.append(custom_scene.strip())
    if extra_style.strip():
        parts.append(extra_style.strip())
    return " | ".join(parts)
def resize_image(img: Image.Image, target_size: Tuple[int, int]) -> Image.Image:
    target_w, target_h = target_size
    orig_w, orig_h = img.size
    scale = max(target_w / orig_w, target_h / orig_h)
    new_w = int(orig_w * scale)
    new_h = int(orig_h * scale)
    img = img.resize((new_w, new_h), Image.Resampling.LANCZOS) 
    left = (new_w - target_w) // 2
    top = (new_h - target_h) // 2
    img = img.crop((left, top, left + target_w, top + target_h))    
    return imgMogelijk gemaakt door

De bovenstaande twee functies doen het volgende:

• Composebare prompt: We voegen onderdelen samen met " | " om zinsdelen visueel te scheiden, terwijl Qwen-Edit de interpunctie afhandelt en consistente parsing levert zonder voorkeur voor het laatste deel. We gebruiken ook .strip() bij gebruikers­tekst om lege fragmenten te vermijden.
• Scale-to-cover-wiskunde: Dit garandeert dat de geresize-de afbeelding het doelformaat in beide dimensies volledig bedekt.
• Lanczos-resampling: Een hoogwaardige filter die fijne details behoudt bij downsamplen en aliasing vermindert bij upscalen.
• Center-crop: Na het resizen croppen we exact het doelcanvas vanuit het midden om de compositie te behouden en onverwachte off-center trims te vermijden.

Met de helpers klaar kunnen we nu een generatie­lus met meerdere hoeken draaien en resultaten verpakken.

Stap 4.2: Afbeeldingen genereren 

Vervolgens valideren we invoer, passen we de afbeelding aan de gekozen verhouding aan, lopen we langs geselecteerde hoeken en draaien we de pipeline in inference_mode. Tot slot geven we een zipbestand terug met alle gegenereerde afbeeldingen.

def generate_images(
    source_img: Image.Image,
    angle_keys: List[str],
    bg_key: str,
    custom_scene: str,
    extra_style: str,
    aspect_ratio: str,
    use_lightning: bool,
    seed: int,
    steps: int,
    guidance_scale: float,
    true_cfg_scale: float,
    images_per_prompt: int,
    progress=gr.Progress()
) -> List[Image.Image]:   
    if source_img is None:
        return [], "WARNING: Please upload an image first!"    
    if not angle_keys:
        return [], "WARNING: Please select at least one angle!"  
    target_size = ASPECT_RATIOS[aspect_ratio]
    source_img = resize_image(source_img, target_size)  
    set_pipeline_mode(use_lightning)
    results = []
    generator = torch.manual_seed(seed)  
    bg_preset_text = BACKGROUND_PRESETS.get(bg_key)    
    total_angles = len(angle_keys)    
    for idx, angle_name in enumerate(angle_keys):
        progress((idx + 1) / total_angles, f"Generating {angle_name}...") 
        angle_phrase = ANGLE_MACROS[angle_name]
        full_prompt = compose_prompt(angle_phrase, bg_preset_text, custom_scene, extra_style)   
        inputs = {
            "image": [source_img],
            "prompt": full_prompt,
            "generator": generator,
            "true_cfg_scale": true_cfg_scale,
            "negative_prompt": " ",
            "num_inference_steps": steps,
            "guidance_scale": guidance_scale,
            "num_images_per_prompt": images_per_prompt,
            "height": target_size[1],
            "width": target_size[0],
        }     
        with torch.inference_mode():
            out = pipe(**inputs)   
        for img_idx, im in enumerate(out.images):
            results.append(im) 
        if 'T4' in gpu_config['gpu_name']:
            torch.cuda.empty_cache()
    return results
def create_zip(images: List[Image.Image]) -> Optional[str]:
    if not images:
        return None
    zip_path = "/content/product_shot_booster.zip"
    with zipfile.ZipFile(zip_path, mode="w", compression=zipfile.ZIP_DEFLATED) as zf:
        zf.writestr("manifest.txt", "Product Shot Booster Export\nGenerated angles exported as PNG files.\n")
        for idx, img in enumerate(images):
            buf = io.BytesIO()
            img.save(buf, format="PNG")
            zf.writestr(f"angle_{idx+1:03d}.png", buf.getvalue())
    return zip_pathMogelijk gemaakt door

De functie generate_images() implementeert generatie met meerdere hoeken en export door te:

• Valideren, normaliseren en configureren: Ze controleert of er een afbeelding is geüpload en hoeken zijn geselecteerd, past de afbeelding aan de gekozen verhouding aan (resize en center-crop) en schakelt HQ versus Fast om via set_pipeline_mode(use_lightning). 
• Efficiënte inference: Voor elke hoek bouwt ze één instructiestring met angle-macro, achtergrondpreset, scene en stijl. Daarna bereidt ze de Diffusers-invoer voor en voert uit onder torch.inference_mode() om geheugen te besparen. Op low-VRAM GPU’s (zoals een T4) helpen aanroepen zoals torch.cuda.empty_cache() per hoek fragmentatie te verminderen.
• Resultaten aggregeren met UI-feedback: Ze werkt de Gradio-voortgang bij zodra elke hoek voltooid is en verzamelt alle outputs in één lijst voor het zippen downstream.

De functie create_zip(images) levert een draagbare export die een zipbestand schrijft met een korte manifest.txt, codeert afbeeldingen via in-memory (BytesIO) voor lossless-bestanden en retourneert None als er geen afbeeldingen zijn.

Met generatie en verpakking rond kan de UI een multi-angle-run starten en een one-click download van het complete hoekpakket aanbieden.

Stap 5: Gradio-UI

Deze UI laat gebruikers een productafbeelding uploaden, hoeken en beeldverhoudingen kiezen, een achtergrondpreset selecteren, stijlaantekeningen instellen en on-the-fly afbeeldingen met meerdere hoeken genereren. 

with gr.Blocks(title="Product Shot Booster", theme=gr.themes.Soft()) as demo:
    gr.Markdown("<h1 style='text-align: center;font-weight: bold;'>Product Shot Booster</h1>")
    with gr.Row():
        with gr.Column(scale=1):
            input_image = gr.Image(
                label="Product Image",
                type="pil",
                height=300
            ) 
            angle_choices = gr.CheckboxGroup(
                choices=list(ANGLE_MACROS.keys()),
                value=["Wide-angle", "Close-up", "Rotate 45° Left", "Rotate 45° Right", "Top-down"],
                label="Camera Angles"
            ) 
            aspect_ratio = gr.Dropdown(
                choices=list(ASPECT_RATIOS.keys()),
                value="1:1 (Square)",
                label="Aspect Ratio"
            )
            bg_preset = gr.Dropdown(
                choices=list(BACKGROUND_PRESETS.keys()),
                value="(None)",
                label="Background"
            ) 
            custom_scene = gr.Textbox(
                label="Custom Scene",
                placeholder="e.g., 'on a matte black table with soft reflections'",
                lines=2
            )    
            extra_style = gr.Textbox(
                label="Style Notes",
                value="studio-grade lighting, high clarity, ecommerce-ready composition",
                lines=2
            )
        with gr.Column(scale=2):
            output_gallery = gr.Gallery(
                  label="Generated Images",
                  show_label=True,
                  columns=3,
                  height="auto",
                  object_fit="contain"
              )

            info_output = gr.Markdown("")
            zip_output = gr.File(label="Download ZIP")
    with gr.Accordion("Advanced Settings", open=False):
        with gr.Row():
            use_lightning = gr.Checkbox(
                label="Fast Mode (Lightning LoRA)",
                value=('T4' in gpu_config['gpu_name']),
                info="Enable for faster generation (recommended for T4)"
            )   
            seed = gr.Number(
                label="Seed",
                value=123,
                precision=0
            )  
            steps = gr.Slider(
                label="Inference Steps",
                minimum=10,
                maximum=60,
                value=28,
                step=1
            )
        with gr.Row():
            guidance_scale = gr.Slider(
                label="Guidance Scale",
                minimum=0.0,
                maximum=8.0,
                value=1.0,
                step=0.1
            )
            true_cfg_scale = gr.Slider(
                label="True CFG Scale",
                minimum=0.0,
                maximum=10.0,
                value=4.0,
                step=0.1
            ) 
            images_per_prompt = gr.Slider(
                label="Images per Angle",
                minimum=1,
                maximum=4,
                value=1,
                step=1
            )
    generate_btn = gr.Button("Generate", variant="primary", size="lg")
    def generate_and_zip(*args):
      images = generate_images(*args)
      zip_file = create_zip(images) if images else None
      return images, zip_file 
    generate_btn.click(
        fn=generate_and_zip,
        inputs=[
            input_image,
            angle_choices,
            bg_preset,
            custom_scene,
            extra_style,
            aspect_ratio,
            use_lightning,
            seed,
            steps,
            guidance_scale,
            true_cfg_scale,
            images_per_prompt
        ],
        outputs=[output_gallery, zip_output]
    )
demo.launch(share=True, debug=True, show_error=True)Mogelijk gemaakt door

De bovenstaande code bouwt een interactieve Gradio-app die één generate-actie aan inference koppelt en een deelbare web-UI aanbiedt, met:

• Inputs (linkerkolom): Het linkerpaneel verzamelt alles wat het model nodig heeft via een gr.Image om een productfoto te uploaden, een gr.CheckboxGroup voor camera­hoeken, twee gr.Dropdowns voor beeldverhouding en achtergrondpresets, en twee gr.Textbox-velden voor aangepaste scene en stijlaantekeningen om de look te fine-tunen.
• Outputs (rechterkolom): Een gr.Gallery-component toont alle gegenereerde hoeken in een grid zodat je composities in één oogopslag kunt vergelijken, en een gr.File-component biedt een ZIP met PNG’s voor snelle download.
• Geavanceerde instellingen: Een gr.Checkbox schakelt Fast Mode (Lightning LoRA) voor snelle previews op T4-klasse GPU’s, terwijl Seed en Steps reproduceerbaarheid en de quality/time trade-off bepalen. Guidance en True-CFG sturen de edit-sterkte versus identiteitsstabiliteit, en Images per Angle laat je meerdere varianten per cameramacro in één keer produceren.
• Interface-wiring (actie): Eén Generate-knop koppelt alle inputs aan de functie generate_images() (die Qwen Edit draait met de geselecteerde adapters) en daarna aan create_zip() (die outputs verpakt), en retourneert zowel de galerij als de ZIP naar de interface.
• App-start: Tot slot start demo.launch() de webapp en biedt een publieke deel-URL—perfect voor Colab-sessies, snelle demo’s of om stakeholders een link te sturen om de tool zelf te proberen.

Klik tenslotte op Generate en kijk hoe een volledig hoekpakket wordt gerenderd. 

Hier zijn de resultaten van mijn experimenten met dit model. Eerst zie je hoe de producten worden weergegeven op basis van de verschillende ingestelde parameters.