angle

L_{Ref}

=

Zoom :

Réglage du point H :

direct

angle et distance

Réglage de l'échelle :               L_{Ref}

+

-

Etudier une image existante

Insérer une nouvelle image

Distance OH :

distance OH

Réglage de la hauteur au-dessus de H :

cm

Cliquez sur Insérer image (triangle en bas à droite de ABC),
Cliquez sur le coin ImageA en bas à droite,
Clic-droit sur l'image, sélectionnez Propriétés :  
→Une fenêtre vous permet de sélectionner l'image. à étudier.
Cochez Image d'arrière-plan,
Dans l'onglet Position, choisissez ImageB comme coin droit,
Cliquez sur OK pour terminer. 
(Vous pouvez réglez la hauteur du cadre en déplaçant le point ImageD)

- Pour déplacer une ellipse   :   Point bleu foncé,
- Pour régler la longueur d'une ellipse  :  Point bleu ciel,
- Les axes des ellipses se rejoignent en un point H, à régler,
- Les largeurs des ellipses dépendent de la hauteur, à régler,
- Conseil : Commencez par régler les deux ellipses les plus éloignées.

Déplacez les extrémités du segment L_{Ref}
pour qu'il recouvre une longueur de référence,
et rentrez la valeur de référence correspondante.

Le point O est déplaçable,
Le point en haut du cercle permet de l'agrandir.

Choix_{image} = 1 (slider from 0 to 1, step 1)
Image_A = (6.219523268118611, -7.19039775234811)
h_{CadreA} = Line(Image_A, xAxis)
T = Point(h_{CadreA})
Zoom = 1.625 (slider from 0.5 to 8, step 0.0050)
Image_B = Dilate(T, Zoom, Image_A)
Cadre_D = Rotate(Image_B, 90*°, Image_A)
CadreAD = Ray(Image_A, Cadre_D)
Im_0 = Point(CadreAD)
Im_1 = Point(CadreAD)
Im_3 = Point(CadreAD)
Im_4 = Point(CadreAD)
Im_5 = Point(CadreAD)
Im_6 = Point(CadreAD)
Im_7 = Point(CadreAD)
Im_2 = Point(CadreAD)
n_{image} = 1 (slider from 1 to 7, step 1)
verticale_{CadreB} = Line(Image_B, yAxis)
Image_{D} = If(Choix_{image} ≟ 0, Im_0, If[n_{image} ≟ 1, Im_1, If[n_{image} ≟ 2, Im_2, If[n_{image} ≟ 3, Im_3, If[n_{image} ≟ 4, Im_4, If[n_{image} ≟ 5, Im_5, If[n_{image} ≟ 6, Im_6, If[n_{image} ≟ 7, Im_7]]]]]]])
h_{ImageD} = Line(Image_{D}, xAxis)
Image_C = Intersect(h_{ImageD}, verticale_{CadreB})
Largeur_{Image} = Distance(Image_A, Image_B)
k_{Hauteur} = 0.549 (slider from 0.1 to 3, step 0.0010)
Valeur_{Echelle} = 10
k_{DistanceOH} = 1.13 (slider from 0 to 3, step 0.01)
Réglage_H = 0 (slider from 0 to 1, step 1)
h_{CadreD} = Line(Cadre_D, xAxis)
Cadre_C = Intersect(h_{CadreD}, verticale_{CadreB})
Centre_{Image} = Midpoint(Image_A, Cadre_C)
Cadre'_D = Dilate(Cadre_D, 10, Centre_{Image})
Cadre'_C = Dilate(Cadre_C, 10, Centre_{Image})
Cadre'_B = Dilate(Image_B, 10, Centre_{Image})
Cadre'_A = Dilate(Image_A, 10, Centre_{Image})
Cadre', cadre_{AB}, f_1, g_1, h_1 = Polygon(Cadre'_A, Cadre'_B, Cadre'_C, Cadre'_D)
M = PointIn(Cadre')
cr_M = Circle(M, Largeur_{Image})
H_{libre} = PointIn(Cadre')
Ech_2 = PointIn(Cadre')
Ech_1 = PointIn(Cadre')
L_{Ref} = Distance(Ech_1, Ech_2)
O = PointIn(Cadre')
C_{Ref,O} = Circle(O, Largeur_{Image} / 2)
Origine = Intersect(xAxis, yAxis)
w = Vector(Origine, O)
Origine' = Translate(Origine, w)
U = Point(yAxis)
P = Dilate(U, Zoom, Origine)
P' = Translate(P, w)
verticale_O = Ray(Origine', P')
O'_{HauteurCercle} = Point(verticale_O)
c_{r,O} = Circle(O, 0.9 * Distance[O, O'_{HauteurCercle}])
H_r = Point(c_{r,O})
direction = Ray(O, H_r)
H_{r,ref} = Intersect(C_{Ref,O}, direction, 1)
Distance_{OH}: (ℯ^(k_{DistanceOH}) - ℯ^(-k_{DistanceOH})) * Largeur_{Image} / 2
H_{réglage} = Dilate(H_{r,ref}, Distance_{OH} / (Largeur_{Image} / 2), O)
H = If(Réglage_H ≟ 0, H_{réglage}, H_{libre})
m = Line(H, M)
M_r, M'_r = Intersect(cr_M, m)
m_r = Segment(M_r, M'_r)
M' = Point(m_r)
O_M = Midpoint(M, M')
dHO_M = Distance(H, O_M)
Hauteur: (ℯ^(k_{Hauteur}) - ℯ^(-k_{Hauteur})) * Largeur_{Image} / 2
α_M: atan(dHO_M / Hauteur) * 180 * ° / π
r_M: cos(α_M)
c_M = Circle(O_M, M)
m_M = LineBisector(M, M')
P_M, P'_M = Intersect(c_M, m_M)
B = PointIn(Cadre')
cr_B = Circle(B, Distance[Image_A, Image_B])
b = Line(H, B)
B_r, B'_r = Intersect(cr_B, b)
b_r = Segment(B_r, B'_r)
B' = Point(b_r)
m_B = LineBisector(B, B')
O_B = Midpoint(B, B')
dHO_B = Distance(H, O_B)
α_B: atan(dHO_B / Hauteur) * 180 * ° / π
r_B: cos(α_B)
c_B = Circle(O_B, B)
P'_B, P_B = Intersect(c_B, m_B)
D = PointIn(Cadre')
cr_D = Circle(D, Distance[Image_A, Image_B])
d = Line(H, D)
D_r, D'_r = Intersect(cr_D, d)
d_r = Segment(D_r, D'_r)
D' = Point(d_r)
m_D = LineBisector(D, D')
O_D = Midpoint(D, D')
c_D = Circle(O_D, D)
P_D, P'_D = Intersect(c_D, m_D)
dHO_D = Distance(H, O_D)
α_D: atan(dHO_D / Hauteur) * 180 * ° / π
r_D: cos(α_D)
L = PointIn(Cadre')
cr_L = Circle(L, Largeur_{Image})
l = Line(H, L)
L_r, L'_r = Intersect(cr_L, l)
l_r = Segment(L_r, L'_r)
L' = Point(l_r)
O_L = Midpoint(L, L')
dHO_L = Distance(H, O_L)
α_L: atan(dHO_L / Hauteur) * 180 * ° / π
r_L: cos(α_L)
c_L = Circle(O_L, L)
m_L = LineBisector(L, L')
P_L, P'_L = Intersect(c_L, m_L)
C = PointIn(Cadre')
cr_C = Circle(C, Distance[Image_A, Image_B])
c = Line(H, C)
C_r, C'_r = Intersect(cr_C, c)
c_r = Segment(C_r, C'_r)
C' = Point(c_r)
m_C = LineBisector(C, C')
O_C = Midpoint(C, C')
c_C = Circle(O_C, C)
P_C, P'_C = Intersect(c_C, m_C)
dHO_C = Distance(H, O_C)
α_C: atan(dHO_C / Hauteur) * 180 * ° / π
r_C: cos(α_C)
A = PointIn(Cadre')
cr_A = Circle(A, Distance[Image_A, Image_B])
a = Line(H, A)
A_r, A'_r = Intersect(cr_A, a)
a_r = Segment(A_r, A'_r)
A' = Point(a_r)
m_A = LineBisector(A, A')
O_A = Midpoint(A, A')
dHO_A = Distance(H, O_A)
α_A: atan(dHO_A / Hauteur) * 180 * ° / π
r_A: cos(α_A)
c_A = Circle(O_A, A)
P'_A, P_A = Intersect(c_A, m_A)
F = PointIn(Cadre')
cr_F = Circle(F, Largeur_{Image})
f = Line(H, F)
F_r, F'_r = Intersect(cr_F, f)
f_r = Segment(F_r, F'_r)
E = PointIn(Cadre')
e = Line(H, E)
cr_E = Circle(E, Distance[Image_A, Image_B])
E_r, E'_r = Intersect(cr_E, e)
Cadre, h, n_1, r, s = Polygon(Image_A, Image_B, Image_C, Image_{D})
e_r = Segment(E_r, E'_r)
E' = Point(e_r)
O_E = Midpoint(E, E')
dHO_E = Distance(H, O_E)
α_E: atan(dHO_E / Hauteur) * 180 * ° / π
verticale_{CadreA} = Line(Image_A, yAxis)
p_A = Segment(P_A, P'_A)
A'' = Dilate(P_A, r_A, O_A)
u_A = Vector(O_A, A'')
c'_A = Translate(c_A, u_A)
p_B = Segment(P_B, P'_B)
B'' = Dilate(P_B, r_B, O_B)
u_B = Vector(O_B, B'')
c'_B = Translate(c_B, u_B)
p_C = Segment(P_C, P'_C)
p_D = Segment(P_D, P'_D)
D'' = Dilate(P_D, r_D, O_D)
C'' = Dilate(P_C, r_C, O_C)
u_C = Vector(O_C, C'')
u_D = Vector(O_D, D'')
c'_C = Translate(c_C, u_C)
c'_D = Translate(c_D, u_D)
C''' = Mirror(C'', O_C)
cc = Segment(C'', C''')
B''' = Mirror(B'', O_B)
bb = Segment(B'', B''')
A''' = Mirror(A'', O_A)
aa = Segment(A'', A''')
D''' = Mirror(D'', O_D)
dd = Segment(D'', D''')
c''_B = Circle(O_B, B'')
c''_D = Circle(O_D, D'')
Image, cadre_1, cadre_2, image_c, image_d = Polygon(Image_A, Image_B, Image_C, Image_{D})
Echelle = Segment(Ech_1, Ech_2)
ChampTexte1 = Textfield(Valeur_{Echelle})
texte2 = LaTeX(dHO_A, true, true)
texte3 = LaTeX(dHO_B, true, true)
texte4 = LaTeX(α_A, true, true)
texte5 = LaTeX(α_B, true, true)
texte6 = LaTeX(dHO_C, true, true)
texte7 = LaTeX(dHO_D, true, true)
texte8 = LaTeX(α_C, true, true)
texte9 = LaTeX(α_D, true, true)
c''_A = Circle(O_A, A'')
c''_C = Circle(O_C, C'')
G = PointIn(Cadre')
J = PointIn(Cadre')
I = PointIn(Cadre')
g = Line(H, G)
j = Line(H, J)
i = Line(H, I)
c_E = Circle(O_E, E)
m_E = LineBisector(E, E')
P_E, P'_E = Intersect(c_E, m_E)
r_E: cos(α_E)
E'' = Dilate(P_E, r_E, O_E)
u_E = Vector(O_E, E'')
c'_E = Translate(c_E, u_E)
F_E, F'_E = Intersect(c'_E, e)
e_E = Ellipse(F_E, F'_E, E'')
F' = Point(f_r)
O_F = Midpoint(F, F')
m_F = LineBisector(F, F')
c_F = Circle(O_F, F)
P_F, P'_F = Intersect(c_F, m_F)
dHO_F = Distance(H, O_F)
α_F: atan(dHO_F / Hauteur) * 180 * ° / π
r_F: cos(α_F)
F'' = Dilate(P_F, r_F, O_F)
u_F = Vector(O_F, F'')
c'_F = Translate(c_F, u_F)
F'_F, F_F = Intersect(c'_F, f)
e_F = Ellipse(F_F, F'_F, F'')
F''' = Mirror(F'', O_F)
ff = Segment(F'', F''')
cr_G = Circle(G, Largeur_{Image})
G_r, G'_r = Intersect(cr_G, g)
g_r = Segment(G_r, G'_r)
G' = Point(g_r)
O_G = Midpoint(G, G')
m_G = LineBisector(G, G')
c_G = Circle(O_G, G)
P_G, P'_G = Intersect(c_G, m_G)
dHO_G = Distance(H, O_G)
α_G: atan(dHO_G / Hauteur) * 180 * ° / π
r_G: cos(α_G)
G'' = Dilate(P_G, r_G, O_G)
u_G = Vector(O_G, G'')
c'_G = Translate(c_G, u_G)
F_G, F'_G = Intersect(c'_G, g)
e_G = Ellipse(F_G, F'_G, G'')
G''' = Mirror(G'', O_G)
gg = Segment(G'', G''')
K = PointIn(Cadre')
k = Line(H, K)
cr_I = Circle(I, Largeur_{Image})
cr_J = Circle(J, Largeur_{Image})
cr_K = Circle(K, Largeur_{Image})
I_r, I'_r = Intersect(cr_I, i)
J_r, J'_r = Intersect(cr_J, j)
K_r, K'_r = Intersect(cr_K, k)
i_r = Segment(I_r, I'_r)
j_r = Segment(J_r, J'_r)
k_r = Segment(K_r, K'_r)
I' = Point(i_r)
J' = Point(j_r)
K' = Point(k_r)
O_I = Midpoint(I, I')
O_J = Midpoint(J, J')
O_K = Midpoint(K, K')
m_I = LineBisector(I, I')
m_J = LineBisector(J, J')
m_K = LineBisector(K, K')
c_I = Circle(O_I, I)
c_J = Circle(O_J, J)
c_K = Circle(O_K, K)
P_I, P'_I = Intersect(c_I, m_I)
P'_J, P_J = Intersect(c_J, m_J)
P_K, P'_K = Intersect(c_K, m_K)
dHO_I = Distance(H, O_I)
dHO_J = Distance(H, O_J)
dHO_K = Distance(H, O_K)
α_I: atan(dHO_I / Hauteur) * 180 * ° / π
α_J: atan(dHO_J / Hauteur) * 180 * ° / π
α_K: atan(dHO_K / Hauteur) * 180 * ° / π
r_I: cos(α_I)
r_J: cos(α_J)
r_K: cos(α_K)
I'' = Dilate(P_I, r_I, O_I)
J'' = Dilate(P_J, r_J, O_J)
K'' = Dilate(P_K, r_K, O_K)
u_I = Vector(O_I, I'')
u_J = Vector(O_J, J'')
u_K = Vector(O_K, K'')
c'_I = Translate(c_I, u_I)
c'_J = Translate(c_J, u_J)
c'_K = Translate(c_K, u_K)
F_I, F'_I = Intersect(c'_I, i)
F_J, F'_J = Intersect(c'_J, j)
F_K, F'_K = Intersect(c'_K, k)
e_I = Ellipse(F_I, F'_I, I'')
e_K = Ellipse(F_K, F'_K, K'')
e_J = Ellipse(F_J, F'_J, J'')
I''' = Mirror(I'', O_I)
E''' = Mirror(E'', O_E)
J''' = Mirror(J'', O_J)
ii = Segment(I'', I''')
ee = Segment(E'', E''')
jj = Segment(J'', J''')
K''' = Mirror(K'', O_K)
kk = Segment(K'', K''')
p_L = Segment(P_L, P'_L)
L'' = Dilate(P_L, r_L, O_L)
p_M = Segment(P_M, P'_M)
u_L = Vector(O_L, L'')
M'' = Dilate(P_M, r_M, O_M)
u_M = Vector(O_M, M'')
c'_L = Translate(c_L, u_L)
c'_M = Translate(c_M, u_M)
c''_L = Circle(O_L, L'')
c''_M = Circle(O_M, M'')
c''_F = Circle(O_F, F'')
c''_I = Circle(O_I, I'')
c''_G = Circle(O_G, G'')
c''_K = Circle(O_K, K'')
c''_J = Circle(O_J, J'')
c''_E = Circle(O_E, E'')
L''' = Mirror(L'', O_L)
M''' = Mirror(M'', O_M)
ll = Segment(L'', L''')
mm = Segment(M'', M''')
F_A, F'_A = Intersect(c'_A, a)
F_C, F'_C = Intersect(c'_C, c)
F_L, F'_L = Intersect(c'_L, l)
F_D, F'_D = Intersect(c'_D, d)
F_B, F'_B = Intersect(c'_B, b)
F_M, F'_M = Intersect(c'_M, m)
e_C = Ellipse(F_C, F'_C, C'')
e_A = Ellipse(F_A, F'_A, A'')
e_L = Ellipse(F_L, F'_L, L'')
e_D = Ellipse(F_D, F'_D, D'')
e_M = Ellipse(F_M, F'_M, M'')
e_B = Ellipse(F_B, F'_B, B'')
verticale_{Origine} = Ray(Origine, P)
p = Segment(O, O'_{HauteurCercle})
q = Segment(O, H_r)
Distance_{OH,réelle}: Distance_{OH} * Valeur_{Echelle} / L_{Ref}
Hauteur_{réelle}: Hauteur * Valeur_{Echelle} / L_{Ref}
texte18 = LaTeX(n_{image})
texte15: "" + Hauteur_{réelle} + " cm"
texte19: ": Image n°" + texte18 + ""