Prismes anamorphoseurs

De Wiki LOGre
Aller à : navigation, rechercher


Projet réalisé par fma38.

Abandonné

Présentation

Ce projet a pour but de réaliser (et/ou faire réaliser) des prismes anamorphoseurs, en vue de faire de la projection vidéo à hauteur constante, sur un écran au ratio 2.35:1 (cinémascope), comme ce qui se pratique au cinéma.

Dans cette configuration, lorsqu'on regarde un film en 16:9, on projette l'image sans modification ; et on alors a des bandes latérales noires. Lorsqu'on projette un film en cinémascope, on commence par étirer numériquement l'image dans le plan vertical, pour qu'elle remplisse toute la matrice du projecteur ; les bandes noires en haut et en bas sont ainsi supprimées, mais l'image est déformée (anamorphosée). On étire, optiquement cette fois, l'image dans le plan horizontal, pour remplir tout l'écran, et supprimer la déformation.

De telles optiques (lentilles ou prismes) existent dans le commerce, mais c'est un gros budget (800-2000€).

Il y a quelques années, une bande d'illuminés du forum homecinema.fr avait lancé l'idée de faire réaliser des prismes pour une somme beaucoup plus modique. Ces prismes étaient certes moins performants que ceux vendus dans le commerce, mais ne coûtaient que 80€ (achat groupé) ! Les gars avaient cogité pendant plusieurs semaines pour déterminer les formes des prismes, avaient trouvé une boîte pour la réalisation, et mis en place des commandes groupées.

Ces prismes sont encore dispos sur le site de la boîte en question (cf lien en bas de page). Le principal problème, c'est qu'ils ne sont pas compensés pour les aberrations chromatiques, et la dispersion du verre utilisé (BK7) est trop importante pour passer inaperçues !

L'idée est donc de renouveler l'expérience, en essayant de corriger ces aberrations.

Résultats de l'époque

Les prismes réalisés donnaient ceci :

Prismes epure-06-03-04.jpg

Comme on peut le voir, il est possible, suivant la position relative des prismes, d'avoir une configuration qui ne déforme pas l'image. Cette solution permet de pouvoir laisser en place les prismes, et de les faire tourner pour passer d'un mode à l'autre. C'est ce ce qui se fait sur certains prismes du commerce :

Prismes boitier prismasonic.png

Théorie

Simulation de l'ellipticité

Cet applet java, réalisé à l'époque, permet de simuler l'ellipticité du faisceau sortant :

Prismes simulation 1.png Prismes simulation 2.png Prismes simulation 3.png

Cette ellipticité est liée à l'étirement local de l'image autour de l'axe optique, mais ça ne dit pas comment le système se comporte en périphérie de champ (Edgar).

Simulation de la déviation

Voici un script gnuplot permettant de simuler la déviation des prismes en fonction de l'angle d'incidence (merci Edgar !) :

#!/usr/bin/gnuplot -persist
 
# Deviation of a pair of prisms.
# C.f. https://www.logre.eu/wiki/Fichier:Prismes_simulation_1.png
 
# Ideal deviation
ratio_start = 16/9.  # HD TV
ratio_end   = 2.35   # Cinemascope
goal(theta) = (ratio_end/ratio_start - 1) * theta
 
# Refraction index
# n = 1.4730  # glycerol, 25°C, 587.56 nm (Na D line)
a = 1.504435      # parameters for BK7 glass
b = 4226.4
n(lambda) = a + b / lambda**2  # BK7 index
 
# Snell-Descartes law for one diopter.
# Indices are n1, n2. The normal is oriented at angle a and
# the incoming ray is at angle theta.
diopter(a, n1, n2, theta) = a + asin(sin(theta - a) * n1 / n2)
 
# One prism is two diopters at angles (a1, a2).
prism(a1, a2, n, theta) = diopter(a2, n, 1, diopter(a1, 1, n, theta))
 
# Prism set.                                                                                                                                                             
a1 = pi/180 * (90 - 84.7)                                                                                                                                                
a2 = pi/180 * (90 - 84.7 + 20)                                                                                                                                           
a3 = pi/180 * (90 - 107.7)                                                                                                                                               
a4 = pi/180 * (90 - 107.7 - 20)                                                                                                                                          
prism1(lambda, theta) = prism(a1, a2, n(lambda), theta)                                                                                                                  
prism2(lambda, theta) = prism(a3, a4, n(lambda), theta)                                                                                                                  
deviation(lambda, theta) = prism2(lambda, prism1(lambda, theta)) - theta
deviation_deg(lambda, theta) = deviation(lambda, theta*pi/180)*180/pi
 
set xlabel "Incoming angle (°)"
set xrange [-20:20]
set ylabel "Deviation (°)"
set grid
set key top left Left reverse
set samples 1000
set dummy theta
 
plot goal(theta) linetype 2 linewidth 2 title "ideal", \
     deviation_deg(400, theta) linetype 3 title "400 nm", \
     deviation_deg(700, theta) linetype 1 title "700 nm"

Prismes deviation 2.png

Le script qui suit permet de visualiser la déformation (dérivée numérique de la déviation réelle comparée à la déviation attendue), en %, ainsi que l'aberration chromatique (re-merci Edgar !) :

#!/usr/bin/gnuplot -persist
 
# Deviation of a pair of prisms.
# C.f. https://www.logre.eu/wiki/Fichier:Prismes_simulation_1.png
 
# Ideal deviation
ratio_start = 16/9.  # HD TV
ratio_end   = 2.35   # Cinemascope
 
# Refraction index of BK7 glass
a = 1.504435
b = 4226.4
n(lambda) = a + b / lambda**2
 
# Snell-Descartes law for one diopter.
# Indices are n1, n2. The normal is oriented at angle a and
# the incoming ray is at angle theta.
diopter(a, n1, n2, theta) = a + asin(sin(theta - a) * n1 / n2)
 
# One prism is two diopters at angles (a1, a2).
prism(a1, a2, n, theta) = diopter(a2, n, 1, diopter(a1, 1, n, theta))
 
# Prism set.
a1 = pi/180 * (90 - 84.7)
a2 = pi/180 * (90 - 84.7 + 20)
a3 = pi/180 * (90 - 107.7)
a4 = pi/180 * (90 - 107.7 - 20)
prism1(lambda, theta) = prism(a1, a2, n(lambda), theta)
prism2(lambda, theta) = prism(a3, a4, n(lambda), theta)
prism_set(lambda, theta) = prism2(lambda, prism1(lambda, theta))
 
# Image stretch and chromatic aberration
epsilon = 0.01
f(theta) = prism_set(555, theta)
scale(theta) = (f(theta + epsilon) - f(theta - epsilon)) / (2*epsilon)
stretch(theta) = scale(theta) / (ratio_end / ratio_start) - 1
chroma(theta) = prism_set(700, theta) - prism_set(400, theta)
 
set xlabel "Incoming angle (°)"
set xrange [-20:20]
set ylabel "Stretch (%)"
set yrange [-20:45]
set y2label "Chromatic aberration (°)"
set y2range [-.20:.45]
set y2tics
set grid
set key top left Left reverse
set samples 1000
set dummy theta
 
plot stretch(theta*pi/180)*100 title "stretch", \
     chroma(theta*pi/180)*180/pi axes x1y2 lt 3 title "chroma"

Prismes deviation 3.png

On voit que si l'on veut minimiser l'aberration chromatique, il faudra se décaler de 6° sur la droite de l'axe des prismes ; cela pour effet d'augmenter la déformation sur ce bord, mais visuellement, c'est sous doute préférable. Tout ceci pourra s'ajuster lors de la mise en place des prismes.

Il ressort de tout ceci qu'on est loin d'avoir un système parfait, et que même avec des prismes de bonne qualité, ces défauts seront bien présents.

Nouveau prototype

Une première étape consiste à réaliser un prototype de prismes en utilisant de la glycérine enfermées entre 2 vitres traitées anti-reflet (plus les faces de fermeture opaques). Cela permet déjà de voir quelles sont les contraintes d'encombrement, et réfléchir à diverses petites choses.

L'impression 3D va permettre de prototyper ça très facilement :

Prismes glycerine 1.png

Les pièces du protos sont dispos sur Thingiverse.

Comme on pouvait s'y attendre, le résultat est moyen, à cause des aberrations chromatiques.

Double prisme

Pour corriger les aberrations chromatiques, l'étape suivante est de réaliser chaque prisme en combinant 2 milieux ayant des indices de dispersion différents. C'est le principe utilisé dans les doublets achromatiques.

Calculs

De nouveau grâce à Edgar, j'ai pu faire un petit script gnuplot qui permet d'optimiser les angles de chaque double-prisme :

#!/usr/bin/gnuplot -persist
 
# Deviation of a pair of prisms.
# C.f. https://www.logre.eu/wiki/Prismes_anamorphoseurs
 
# Half of the horizontal projection angle
# (adjust according to installation)
INPUT_ANGLE = 16
 
# Consts
EPSILON = 0.01
STRETCH_FACTOR = 2.35 / (16. / 9.)
 
WL_RED = 0.615
WL_GREEN = 0.555
WL_BLUE = 0.465
 
TITLE ="chroma SQRT-optimized - ethylene glycol/glycerol"
 
CHROMA_RB_WEIGHT = 5
CHROMA_RG_WEIGHT = 5
CHROMA_GB_WEIGHT = 5
 
SHIFT_WEIGHT = 1
STRETCH_WEIGHT = 5
CHROMA_WEIGHT = 10
 
# Helpers
radians(angle) = angle * pi / 180
degrees(angle) = angle * 180 / pi
min(x, y) = (x < y) ? x : y
max(x, y) = (x > y) ? x : y
 
# Refractive index
n_air = 1
n_air(lambda) = n_air
n_water(lambda) = 1.3264 + 0.1140 * exp(-4.8 * lambda)
 
n_poly_acrylate(lambda) = sqrt(2.364830 - 6.955268E-2 * lambda ** 2 - 1.356107E-1 / lambda ** 2 + 6.053900E-2 / lambda ** 4 - 1.166640E-2 / lambda ** 6 + 8.542615E-4 * lambda ** 8)
n_polycarbonate(lambda) = sqrt(2.633127 - 7.937823E-2 * lambda ** 2 - 1.734506E-1 / lambda ** 2 + 8.609268E-2 / lambda ** 4 - 1.617892E-2 / lambda ** 6 + 1.128933E-3 * lambda ** 8)
 
n_bk7(lambda) =             1.504435          + 0.0042264           / lambda ** 2
n_bk7_liquid(lambda) =      1.502787          + 0.004558724         / lambda ** 2 + 0.00009844856        / lambda ** 4
 
n_acetic_acid(lambda) =      1.340964         + 0.010708022         / lambda ** 2
n_ethanol(lambda) =          1.35265          + 0.00306             / lambda ** 2 + 0.00002              / lambda ** 4
n_ethylene_glycol(lambda) =  1.386820         + 0.017856021         / lambda ** 2
n_ethyl_salicylate(lambda) = 1.49376          + 0.00873             / lambda ** 2 + 0.00018              / lambda ** 4
n_propylene_glycol(lambda) = 1.42839967519385 + 0.00410786406906216 / lambda ** 2 - 0.000042396131510073 / lambda ** 4
n_glycerol(lambda) =         1.45797          + 0.00598             / lambda ** 2 - 0.00036              / lambda ** 4
 
n_mineral_oil(lambda) =      1.4425830751648  + 0.00760376328908832 / lambda ** 2 - 0.000343529770518462 / lambda ** 4  # Données ???
n_silicon_oil(lambda) =      1.60419069134243 - 0.0218913623052616  / lambda ** 2 + 0.00591296328110387  / lambda ** 4  # mesures faites avec Mike - huile 'usée'
 
# Choice
n1(lambda) = n_ethylene_glycol(lambda)
n2(lambda) = n_water(lambda)
 
# Snell-Descartes law for one diopter
# Indices are n1, n2
# The normal is oriented at angle 'alpha', in deg
# The incoming ray is at angle 'theta', in deg
diopter(alpha, n1, n2, theta) = degrees(radians(alpha) + asin(sin(radians(theta) - radians(alpha)) * n1 / n2))
 
# In following:
# - alpha is the angle of the prism (first face) normal
# - beta is the angle between 2 consecutive diopters in the prism
 
# Prism A initial values
alpha_A = 10
beta_A_1_2 = -10
beta_A_2_3 = 25
 
prism_A(lambda, theta) = diopter(alpha_A + beta_A_1_2 + beta_A_2_3, n2(lambda), n_air, \
                                 diopter(alpha_A + beta_A_1_2, n1(lambda), n2(lambda), \
                                         diopter(alpha_A, n_air, n1(lambda), theta)))
 
# Prism B initial values
alpha_B = -10
beta_B_1_2 = 10
beta_B_2_3 = -25
 
prism_B(lambda, theta) = diopter(alpha_B + beta_B_1_2 + beta_B_2_3, n2(lambda), n_air, \
                                 diopter(alpha_B + beta_B_1_2, n1(lambda), n2(lambda), \
                                         diopter(alpha_B, n_air, n1(lambda), theta)))
 
# Both prisms
prisms_transform(lambda, theta) = prism_B(lambda, prism_A(lambda, theta))
 
# Image error type 0 = image shift
ideal_deviation(theta) = degrees(atan(STRETCH_FACTOR * tan((radians(theta))))) - theta
shift(theta) = prisms_transform(WL_GREEN, theta) - theta - ideal_deviation(theta)
 
# Image error type 1 = image stretch
scale(theta) = (prisms_transform(WL_GREEN, theta + EPSILON / 2) - prisms_transform(WL_GREEN, theta - EPSILON / 2)) / EPSILON  # ~ derivate
# stretch(theta) = scale(theta) / STRETCH_FACTOR - 1
angle_stretch_factor(theta) = atan(STRETCH_FACTOR * tan(radians(theta))) / radians(theta)
stretch(theta) = scale(theta) / angle_stretch_factor(theta) - 1
 
stretch_factor_from_angles(a1, a2) = tan(radians(a2)) / tan(radians(a1))
# stretch(theta) = stretch_factor_from_angles(theta, prisms_transform(WL_GREEN, theta)) - STRETCH_FACTOR
 
# Image error type 2 = chromatic aberration
deviation(lambda, theta) = prisms_transform(lambda, theta) - theta
chroma_rb(theta) = deviation(WL_RED,   theta) - deviation(WL_BLUE,  theta)
chroma_rg(theta) = deviation(WL_RED,   theta) - deviation(WL_GREEN, theta)
chroma_gb(theta) = deviation(WL_GREEN, theta) - deviation(WL_BLUE,  theta)
 
chroma(theta) = sqrt(CHROMA_RB_WEIGHT * chroma_rb(theta)**2 + \
                     CHROMA_RG_WEIGHT * chroma_rg(theta)**2 + \
                     CHROMA_GB_WEIGHT * chroma_gb(theta)**2)
 
error(type, theta) = type==0 ? SHIFT_WEIGHT   * shift(theta) : \
                     type==1 ? STRETCH_WEIGHT * stretch(theta) : \
                     type==2 ? CHROMA_WEIGHT  * chroma(theta) : \
                     NaN
 
set xlabel "Incoming angle (°)"
set xrange [-INPUT_ANGLE:INPUT_ANGLE]
set grid
set key top left Left reverse
set samples 1000
set dummy theta, type
set ylabel "Déviation (°)"
set yrange [-6:6]
set y2label "Chromatic aberration (°)"
set y2range [-.06:.06]
set y2tics
set title TITLE
plot ideal_deviation(theta) linetype 7 linewidth 3 title "ideal", \
     deviation(WL_BLUE,  theta) linetype 3 linewidth 2 title "blue", \
     deviation(WL_GREEN, theta) linetype 2 linewidth 2 title "green", \
     deviation(WL_RED,   theta) linetype 1 linewidth 2 title "red", \
     chroma_rb(theta) axes x1y2 linetype 2 title "chroma R-B", \
     chroma_rg(theta) axes x1y2 linetype 3 title "chroma R-G", \
     chroma_gb(theta) axes x1y2 linetype 1 title "chroma B-G"
 
# pause -1 "Hit return to start the fit..."
 
fit error(type, theta) 'prismes_zeros_20.tsv' using 2:1:3:(1) via alpha_A, beta_A_1_2, beta_A_2_3, \
                                                                  alpha_B, beta_B_1_2, beta_B_2_3
# Print results
print ""
print "* Prisme A:"
print sprintf("** alpha_A = %+.1f°", alpha_A)
print sprintf("** beta_A_1_2  = %+.1f°", beta_A_1_2)
print sprintf("** beta_A_2_3  = %+.1f°", beta_A_2_3)
print "* Prisme B:"
print sprintf("** alpha_B = %+.1f°", alpha_B)
print sprintf("** beta_B_1_2  = %+.1f°", beta_B_1_2)
print sprintf("** beta_B_2_3  = %+.1f°", beta_B_2_3)
 
# Print beam deviations
print ""
 
b0 = INPUT_ANGLE
b1 = diopter(alpha_A, n_air, n1(WL_RED), b0)
b2 = diopter(alpha_A + beta_A_1_2, n1(WL_RED), n2(WL_RED), b1)
b3 = diopter(alpha_A + beta_A_1_2 + beta_A_2_3, n2(WL_RED), n_air, b2)
b4 = diopter(alpha_B, n_air, n1(WL_RED), b3)
b5 = diopter(alpha_B + beta_B_1_2, n1(WL_RED), n2(WL_RED), b4)
b6 = diopter(alpha_B + beta_B_1_2 + beta_B_2_3, n2(WL_RED), n_air, b5)
print sprintf("%dnm: %+.3f > %+.3f > %+.3f > %+.3f > %+.3f > %+.3f > %+.3f (%.2f)", \
    WL_RED*1000, b0, b1, b2, b3, b4, b5, b6, stretch_factor_from_angles(b0, b6))
 
b0 = INPUT_ANGLE
b1 = diopter(alpha_A, n_air, n1(WL_GREEN), b0)
b2 = diopter(alpha_A + beta_A_1_2, n1(WL_GREEN), n2(WL_GREEN), b1)
b3 = diopter(alpha_A + beta_A_1_2 + beta_A_2_3, n2(WL_GREEN), n_air, b2)
b4 = diopter(alpha_B, n_air, n1(WL_GREEN), b3)
b5 = diopter(alpha_B + beta_B_1_2, n1(WL_GREEN), n2(WL_GREEN), b4)
b6 = diopter(alpha_B + beta_B_1_2 + beta_B_2_3, n2(WL_GREEN), n_air, b5)
print sprintf("%dnm: %+.3f > %+.3f > %+.3f > %+.3f > %+.3f > %+.3f > %+.3f (%.2f)", \
    WL_GREEN*1000, b0, b1, b2, b3, b4, b5, b6, stretch_factor_from_angles(b0, b6))
 
b0 = INPUT_ANGLE
b1 = diopter(alpha_A, n_air, n1(WL_BLUE), b0)
b2 = diopter(alpha_A + beta_A_1_2, n1(WL_BLUE), n2(WL_BLUE), b1)
b3 = diopter(alpha_A + beta_A_1_2 + beta_A_2_3, n2(WL_BLUE), n_air, b2)
b4 = diopter(alpha_B, n_air, n1(WL_BLUE), b3)
b5 = diopter(alpha_B + beta_B_1_2, n1(WL_BLUE), n2(WL_BLUE), b4)
b6 = diopter(alpha_B + beta_B_1_2 + beta_B_2_3, n2(WL_BLUE), n_air, b5)
print sprintf("%dnm: %+.3f > %+.3f > %+.3f > %+.3f > %+.3f > %+.3f > %+.3f (%.2f)", \
    WL_BLUE*1000, b0, b1, b2, b3, b4, b5, b6, stretch_factor_from_angles(b0, b6))
 
print ""
 
b0 = -INPUT_ANGLE
b1 = diopter(alpha_A, n_air, n1(WL_BLUE), b0)
b2 = diopter(alpha_A + beta_A_1_2, n1(WL_BLUE), n2(WL_BLUE), b1)
b3 = diopter(alpha_A + beta_A_1_2 + beta_A_2_3, n2(WL_BLUE), n_air, b2)
b4 = diopter(alpha_B, n_air, n1(WL_BLUE), b3)
b5 = diopter(alpha_B + beta_B_1_2, n1(WL_BLUE), n2(WL_BLUE), b4)
b6 = diopter(alpha_B + beta_B_1_2 + beta_B_2_3, n2(WL_BLUE), n_air, b5)
print sprintf("%dnm: %+.3f > %+.3f > %+.3f > %+.3f > %+.3f > %+.3f > %+.3f (%.2f)", \
    WL_BLUE*1000,b0, b1, b2, b3, b4, b5, b6, stretch_factor_from_angles(b0, b6))
 
b0 = -INPUT_ANGLE
b1 = diopter(alpha_A, n_air, n1(WL_GREEN), b0)
b2 = diopter(alpha_A + beta_A_1_2, n1(WL_GREEN), n2(WL_GREEN), b1)
b3 = diopter(alpha_A + beta_A_1_2 + beta_A_2_3, n2(WL_GREEN), n_air, b2)
b4 = diopter(alpha_B, n_air, n1(WL_GREEN), b3)
b5 = diopter(alpha_B + beta_B_1_2, n1(WL_GREEN), n2(WL_GREEN), b4)
b6 = diopter(alpha_B + beta_B_1_2 + beta_B_2_3, n2(WL_GREEN), n_air, b5)
print sprintf("%dnm: %+.3f > %+.3f > %+.3f > %+.3f > %+.3f > %+.3f > %+.3f (%.2f)", \
    WL_GREEN*1000,b0, b1, b2, b3, b4, b5, b6, stretch_factor_from_angles(b0, b6))
 
b0 = -INPUT_ANGLE
b1 = diopter(alpha_A, n_air, n1(WL_RED), b0)
b2 = diopter(alpha_A + beta_A_1_2, n1(WL_RED), n2(WL_RED), b1)
b3 = diopter(alpha_A + beta_A_1_2 + beta_A_2_3, n2(WL_RED), n_air, b2)
b4 = diopter(alpha_B, n_air, n1(WL_RED), b3)
b5 = diopter(alpha_B + beta_B_1_2, n1(WL_RED), n2(WL_RED), b4)
b6 = diopter(alpha_B + beta_B_1_2 + beta_B_2_3, n2(WL_RED), n_air, b5)
print sprintf("%dnm: %+.3f > %+.3f > %+.3f > %+.3f > %+.3f > %+.3f > %+.3f (%.2f)", \
    WL_RED*1000,b0, b1, b2, b3, b4, b5, b6, stretch_factor_from_angles(b0, b6))
 
# Write tables
set table "deformation_r.tsv"
plot prisms_transform(WL_RED, theta)
unset table
 
set table "deformation_g.tsv"
plot prisms_transform(WL_GREEN, theta)
unset table
 
set table "deformation_b.tsv"
plot prisms_transform(WL_BLUE, theta)
unset table
 
plot ideal_deviation(theta) linetype 7 linewidth 3 title "ideal", \
     deviation(WL_BLUE,  theta) linetype 3 linewidth 2 title "blue", \
     deviation(WL_GREEN, theta) linetype 2 linewidth 2 title "green", \
     deviation(WL_RED,   theta) linetype 1 linewidth 2 title "red", \
     chroma_rb(theta) axes x1y2 linetype 2 title "chroma R-B", \
     chroma_rg(theta) axes x1y2 linetype 3 title "chroma R-G", \
     chroma_gb(theta) axes x1y2 linetype 1 title "chroma B-G"
 
pause -1 "\nHit return to end\n"

Chaque prisme sera donc constitué de 2 prismes tête-bêche, utilisant 2 milieux différents

Éthylène glycol / glycérol

  • Prisme A:
    • alpha_A = +16.4°
    • beta_A_1_2 = -7.7°
    • beta_A_2_3 = +25.7°
  • Prisme B:
    • alpha_B = -19.4°
    • beta_B_1_2 = +8.4°
    • beta_B_2_3 = -27.6°

Angles :

  • 615nm: +16.000 > +16.121 > +16.688 > +10.467 > +0.925 > +1.847 > +21.122 (1.35)
  • 555nm: +16.000 > +16.123 > +16.739 > +10.499 > +0.788 > +1.776 > +21.124 (1.35)
  • 465nm: +16.000 > +16.128 > +16.855 > +10.579 > +0.486 > +1.622 > +21.127 (1.35)
  • 465nm: -16.000 > -4.986 > -6.357 > -26.577 > -24.273 > -25.601 > -21.108 (1.35)
  • 555nm: -16.000 > -5.369 > -6.564 > -26.676 > -24.425 > -25.563 > -21.114 (1.35)
  • 615nm: -16.000 > -5.541 > -6.656 > -26.714 > -24.488 > -25.543 > -21.113 (1.35)

Prismes ethylene-glycol+glycerol.png

On constate que les aberrations chromatiques sont vraiment très faibles...

Réalisation

Plutôt que d'utiliser du verre, les parois de séparation seront en PMMA de 3mm, faciles à tailler sur la découpeuse laser. En fait, le boîtier entier sera sans doute taillé dans du PMMA, ce qui permettra une assemblage facile avec la technique des queues droites. Il faudra juste étancher les jonctions, et prévoir un système de remplissage (en tenant compte de la dilatation des liquides en cas d'élévation de température).

Liens