Lichtverteilung innerhalb Softbox

Auch wenn es für den Einstieger abgefahren wirken mag - hier geht es zum Thema Lichtsetzung und Softboxen in die Abteilung „Fotonerd“.

Für das tiefergehende Verständnis von Lichtsetzung und Lichtverteilung. Was passiert in der Softbox? Wie sich das Licht in Softboxen verteilt.

Das Wissen hilft beim Verständnis von den Geschichten wie Feathering mit Lichtformern.

Zum Verständnis verschiedene Diagramme und Zeichnungen

Im ersten Schritt sehen wir uns den Strahlenverlauf in einer Softbox mit herkömmlichen Form:

In der Praxis führt diese Bauweise dazu, dass die Lichtausbeute in der Mitte etwa 30-40% höher ist als am äußersten Rand (90 cm Markierung). Oder im Klartext: Wir verlieren 1 Blendenstufe (sprich die Hälfte vom Licht) bereits 40 cm entfernt von der Mitte!

Die folgenden Python Programm sind nicht exakt und dienen zur Veranschaulichung! Die Problematik kommt auch noch, dass die Blitzröhren teilweise relativ unterschiedlich tief in der Softbox sitzen. Diese Angabe können Sie im Python Programm über focal_y = anpassen

    
import numpy as np
import matplotlib.pyplot as plt

def simulate_symmetric_softbox(diameter=90, depth=45):
    speedring = 20
    focal_y = 5
    
    fig, ax = plt.subplots(figsize=(10, 8))
    ax.set_facecolor('#1a1a1a')
    
    # 1. Geometrie (Trapez)
    # Wände
    left_wall = [[-speedring/2, -diameter/2], [0, depth]]
    right_wall = [[speedring/2, diameter/2], [0, depth]]
    ax.plot(left_wall[0], left_wall[1], color='silver', lw=4, label="Silberwand")
    ax.plot(right_wall[0], right_wall[1], color='silver', lw=4)
    
    # Diffusoren
    ax.hlines(depth*0.5, -diameter/3, diameter/3, colors='cyan', lw=2, label="Innendiffusor")
    ax.hlines(depth, -diameter/2, diameter/2, colors='white', lw=3, label="Außendiffusor")
    
    # 2. Symmetrische Strahlen (10 links, 10 rechts)
    # Wir erzeugen 10 Winkel für eine Seite und spiegeln diese
    half_rays = 10
    max_angle = np.pi / 2.3
    angles_right = np.linspace(0.05, max_angle, half_rays)
    angles_left = -angles_right
    all_angles = np.sort(np.concatenate([angles_left, angles_right]))

    # Wand-Steigung (m) und Achsenabschnitt (b) für x = m*y + b
    m = (diameter/2 - speedring/2) / depth
    
    for ang in all_angles:
        dx, dy = np.sin(ang), np.cos(ang)
        b = speedring/2 if dx > 0 else -speedring/2
        current_m = m if dx > 0 else -m
        
        # Schnittpunkt mit Wand: t*dx = current_m*(focal_y + t*dy) + b
        t_wall = (current_m * focal_y + b) / (dx - current_m * dy)
        t_diffuser = (depth - focal_y) / dy
        
        if 0 < t_wall < t_diffuser:
            # REFLEXIONS-STRAHL
            hx_w, hy_w = t_wall * dx, focal_y + t_wall * dy
            # 1. Teil: Quelle -> Wand
            ax.plot([0, hx_w], [focal_y, hy_w], color='orange', alpha=0.7, lw=1)
            
            # Reflexion berechnen (vereinfacht: Einfallswinkel an schräger Wand)
            # Der Strahl prallt ab und wandert zum Außendiffusor
            dist_to_top = depth - hy_w
            # Ein einfacher Abprall-Vektor (x-Richtung kehrt sich um)
            ax.plot([hx_w, hx_w - dx*dist_to_top*0.8], [hy_w, depth], color='yellow', alpha=0.5, lw=1)
        else:
            # DIREKT-STRAHL
            hx_d = t_diffuser * dx
            if abs(hx_d) <= diameter/2:
                ax.plot([0, hx_d], [focal_y, depth], color='white', alpha=0.4, lw=1)

    # 3. Details
    ax.scatter(0, focal_y, color='gold', s=120, zorder=10, label="Blitzröhre")
    ax.set_title("Symmetrischer Lichtverlauf (20 Strahlen) - Standard Softbox")
    ax.set_xlim(-60, 60)
    ax.set_ylim(-5, 55)
    ax.legend(loc='upper right')
    plt.grid(True, linestyle=':', alpha=0.2)
    plt.show()

if __name__ == "__main__":
    simulate_symmetric_softbox()  

Im zweiten Schritt sehen wir uns die Strahlenverläufe in einer Softbox mit parabolischer Form:

Durch die parabolische Hülle wird der Verlauf der von der Blitzröhre ausgesendeten Lichtstrahlen einigermaßen gleichmäßig auf die Austrittsfläche verteilt.

Viele direkte Lichtstrahlen werden durch die Wabe (Grid) abgefangen.

Sowohl der Innen- wie Außendiffusor ermöglichen einen gleichmäßigeren Lichtverlauf

Was in einer parabolischen runden Softbox passiert:

Und wer selber die Werte ändern möchte, das verwendete Python-programm für die Berechnung der Grafik und des Diagrams

  
import numpy as np
import matplotlib.pyplot as plt

def ray_trace_softbox(diameter=90, depth=65, num_rays=25, focal_point_y=1):
    """
    Simuliert den Lichtverlauf in einer parabolischen Beauty-Softbox.
    Parameter:
    - diameter: Durchmesser der Austrittsfläche
    - depth: Tiefe der Softbox
    - num_rays: Anzahl der zu simulierenden Lichtstrahlen
    - focal_point_y: Position der Blitzröhre auf der Y-Achse
    """
    # 1. Parabel-Parameter berechnen: y = a * x^2
    a = depth / (diameter / 2)**2
    x_vals = np.linspace(-diameter/2, diameter/2, 400)
    y_vals = a * x_vals**2

    fig, ax = plt.subplots(figsize=(10, 7))
    ax.plot(x_vals, y_vals, color='silver', linewidth=4, label='Parabolische Hülle (90cm)')
    
    # Lichtquelle (Blitzröhre) einzeichnen
    ax.scatter(0, focal_point_y, color='gold', s=200, zorder=5, label='Blitzröhre')
    
    # 2. Raytracing-Schleife
    # Wir senden Strahlen in verschiedenen Winkeln von der Lichtquelle aus
    angles = np.linspace(-np.pi/1.8, np.pi/1.8, num_rays)
    for angle in angles:
        # Richtungsvektor des Strahls
        dx, dy = np.sin(angle), np.cos(angle)
        
        # Schnittpunktberechnung mit der Parabel:
        # Wir suchen 't', sodass: a*(t*dx)^2 = focal_point_y + (t*dy)
        # Umgeformt zu: (a*dx^2)*t^2 - dy*t - focal_point_y = 0
        coeff_a = a * dx**2
        coeff_b = -dy
        coeff_c = -focal_point_y
        
        # Lösen der quadratischen Gleichung für t
        t_solutions = np.roots([coeff_a, coeff_b, coeff_c])
        t = max(t_solutions) # Der positive Wert ist der Weg zur Wand
        
        # Koordinaten des Treffpunkts an der Wand
        hit_x = t * dx
        hit_y = focal_point_y + t * dy
        
        # Zeichne Strahl: Quelle -> Wand
        ax.plot([0, hit_x], [focal_point_y, hit_y], color='orange', alpha=0.3, linestyle='--')
        
        # Zeichne reflektierten Strahl: Wand -> Austritt (idealisiert parallel)
        ax.arrow(hit_x, hit_y, 0, depth - hit_y + 5, color='yellow', 
                 head_width=1.5, length_includes_head=True, alpha=0.7)

    # 3. Zusätzliche Komponenten einzeichnen
    # Außendiffusor
    ax.hlines(depth, -diameter/2, diameter/2, colors='white', linestyles='solid', 
              linewidth=6, label='Außendiffusor', alpha=0.8)
    # Innendiffusor (versetzt)
    ax.hlines(depth-5, -diameter/2 + 5, diameter/2 - 5, colors='lightblue', 
              linestyles='dashed', linewidth=2, label='Innendiffusor')
    # Grid (Wabe) zur Streulichtbegrenzung
    grid_x = np.linspace(-diameter/2, diameter/2, 20)
    ax.vlines(grid_x, depth, depth+8, colors='black', linewidth=1, label='Grid (Wabe)')

    # Optik-Verschönerung
    ax.set_facecolor('#2c3e50')
    ax.set_xlim(-60, 60)
    ax.set_ylim(-5, 90)
    ax.set_aspect('equal')
    ax.legend(loc='upper right', bbox_to_anchor=(1.3, 1))
    ax.set_title("Lichtverlauf-Simulation: Ideale Beauty-Softbox")
    plt.show()

# Programm starten
if __name__ == "__main__":
    ray_trace_softbox()

Um das Python-Program Online ausführen zu lassen um sich die Installation von Python sich zu ersparen, hilft der Online-Dienst: https://matplotlib.codeutility.io/de

Sowohl der Innen- wie Außendiffusor ermöglichen einen gleichmäßigeren Lichtverlauf

Zusätzlich ein Diagramm mit der Lichtverteilung

Und wer selber die Werte ändern möchte, das verwendete Python-programm für die Berechnung der Grafik und des Diagrams

import numpy as np
import matplotlib.pyplot as plt

def simulate_no_deflector(diameter=90, depth=65, focal_point_y=15, num_rays=8000):
    """
    Simuliert eine parabolische Softbox OHNE Deflektor.
    Zeigt den Hotspot durch direktes Licht im Zentrum.
    """
    a = depth / (diameter / 2)**2
    hit_positions = []
    
    # Simulation von Strahlen in alle Richtungen (vorne und hinten)
    angles = np.linspace(-np.pi, np.pi, num_rays)
    
    for angle in angles:
        dx, dy = np.sin(angle), np.cos(angle)
        
        # 1. Fall: Licht strahlt nach hinten (Reflexion an Parabel)
        if dy < 0:
            coeff_a = a * dx**2
            coeff_b = -dy
            coeff_c = -focal_point_y
            t_sol = np.roots([coeff_a, coeff_b, coeff_c])
            t = max(t_sol)
            hit_x = t * dx
            if abs(hit_x) <= diameter / 2:
                hit_positions.append(hit_x)
        
        # 2. Fall: Licht strahlt direkt nach vorne (Direktlicht)
        else:
            # Weg bis zur Austrittsebene (y = depth)
            t_direct = (depth - focal_point_y) / dy if dy > 0 else 0
            hit_x_direct = t_direct * dx
            if abs(hit_x_direct) <= diameter / 2:
                # Direktes Licht ist intensiver (kürzerer Weg), 
                # wir gewichten es hier einfach durch mehrfaches Hinzufügen
                hit_positions.append(hit_x_direct)
                hit_positions.append(hit_x_direct) # Intensitäts-Bonus für Fokus

    # Visualisierung
    fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(15, 6))
    ax1.set_facecolor('#1a1a1a')
    
    # 1. Diagramm: Strahlengang
    x_p = np.linspace(-diameter/2, diameter/2, 400)
    y_p = a * x_p**2
    ax1.plot(x_p, y_p, color='silver', lw=3)
    ax1.scatter(0, focal_point_y, color='gold', s=150, zorder=5)
    
    # Zeichne einige direkte und reflektierte Strahlen
    for ang in np.linspace(-np.pi, np.pi, 30):
        dx, dy = np.sin(ang), np.cos(ang)
        if dy < 0: # Reflektiert
            t = max(np.roots([a*dx**2, -dy, -focal_point_y]))
            ax1.plot([0, t*dx], [focal_point_y, focal_point_y+t*dy], color='orange', alpha=0.2)
            ax1.arrow(t*dx, focal_point_y+t*dy, 0, depth-(focal_point_y+t*dy), color='yellow', alpha=0.3)
        elif dy > 0.3: # Direkt
            t = (depth-focal_point_y)/dy
            if abs(t*dx) <= diameter/2:
                ax1.plot([0, t*dx], [focal_point_y, depth], color='white', alpha=0.4, lw=1)

    ax1.set_title("Strahlengang OHNE Deflektor")

    # 2. Diagramm: Lichtverteilung
    counts, bins = np.histogram(hit_positions, bins=60, range=(-diameter/2, diameter/2))
    brightness = counts / np.max(counts)
    bin_centers = (bins[:-1] + bins[1:]) / 2
    
    ax2.fill_between(bin_centers, brightness, color='white', alpha=0.3)
    ax2.plot(bin_centers, brightness, color='gold', lw=2)
    ax2.set_title("Helligkeitsverteilung (Hotspot im Zentrum)")
    ax2.set_xlabel("Position (cm)")
    ax2.set_ylabel("Relative Helligkeit")
    ax2.set_ylim(0, 1.1)

    plt.tight_layout()
    plt.show()

if __name__ == "__main__":
    simulate_no_deflector()

Beim feathering werden herkömmlichen Softbox für das Ergebnis!

Der Strahlenverlauf bei der Technik feathering wird im folgenden Diagram verglichen zwischen einer herkömmlichen Softbox zu einer Softbox mit Parabolform.

Wichtig: Die Standardbox nutzt Streuung, die Parabolbox nutzt Bündelung.