Correction des exercices 1.6

Ex 1

Show[Graphics[Raster[{{(96/255)}}]], 
        AspectRatio -> Automatic];

Show[
        Graphics[
          Raster[{{(1/255) {135, 60, 93}}}, 
            ColorFunction -> RGBColor]], 
        AspectRatio -> Automatic];

Ex 2

Show[Graphics[{GrayLevel[(96/255)], Rectangle[{0, 0}, {1, 1}]}], 
        AspectRatio -> Automatic];

Show[
        Graphics[{RGBColor[(135/255), (60/255), (93/255)], 
            Rectangle[{0, 0}, {1, 1}]}], 
        AspectRatio -> Automatic];

Ex 3

pixel = 
        Show[Graphics[
            Raster[{{(1/255) {159, 74, 99}}}, 
              ColorFunction -> RGBColor]], 
          AspectRatio -> Automatic];

red = 
        Show[Graphics[
            Raster[{{(1/255) {159, 0, 0}}}, 
              ColorFunction -> RGBColor]], 
          AspectRatio -> Automatic];

green = 
        Show[Graphics[
            Raster[{{(1/255) {0, 74, 0}}}, 
              ColorFunction -> RGBColor]], 
          AspectRatio -> Automatic];

blue = 
        Show[Graphics[
            Raster[{{(1/255) {0, 0, 99}}}, 
              ColorFunction -> RGBColor]], 
          AspectRatio -> Automatic];

Show[GraphicsArray[{pixel, red, green, blue}]];

Ex 4

pixel = 
        Show[Graphics[{RGBColor[(159/255), (74/255), (99/255)], 
              Rectangle[{0, 0}, {1, 1}]}], 
          AspectRatio -> Automatic];

red = pixel = 
          Show[Graphics[{RGBColor[(159/255), 0, 0], 
                Rectangle[{0, 0}, {1, 
                    1}]}], 
AspectRatio -> 
              Automatic];

green = pixel = 
          Show[Graphics[{RGBColor[0, (74/255), 0], 
                Rectangle[{0, 0}, {1, 1}]}], 
            AspectRatio -> Automatic];

blue = pixel = 
          Show[Graphics[{RGBColor[0, 0, (99/255)], 
                Rectangle[{0, 0}, {1, 1}]}], 
            AspectRatio -> Automatic];

Show[GraphicsArray[{pixel, red, green, blue}]];

Ex 5

Table[
        Mod[x  + y, 2] , {x, 1, 5}, {y, 1, 
          5}];
Show[Graphics[Raster[%]], AspectRatio -> Automatic, 
        Frame -> True, FrameTicks -> False];

Table[{Random[], Random[], Random[]} , {x, 1, 5}, {y, 1, 
          5}];
Show[Graphics[Raster[%, ColorFunction -> RGBColor]], 
        AspectRatio -> Automatic, Frame -> True, 
        FrameTicks -> False];

ou

Table[Random[] , {x, 1, 5}, {y, 1, 5}];
Show[Graphics[Raster[%, ColorFunction -> Hue]], 
        AspectRatio -> Automatic, Frame -> True, 
        FrameTicks -> False];

Ex 6

Mean[Flatten[lenaGris, 1]] // N

Show[Graphics[Raster[{{(1/255) %}}]], 
        AspectRatio -> Automatic];

Mean[Flatten[lenaCouleurs, 1]] // N

Show[
        Graphics[Raster[{{(1/255) %}}, ColorFunction -> RGBColor]], 
        AspectRatio -> Automatic];

Ex 7

lenaGrisNew = 
        lenaCouleurs /. {r_, g_, 
                b_} -> ((0.3  r + 0.59  g + 0.11  b)/3) // 
          Round;

Show[Graphics[Raster[(lenaGrisNew/255)]], 
        AspectRatio -> Automatic];

Ex 8

lenaCouleursPâle = 
        lenaCouleurs /. {r_, g_, 
              b_} -> {((((r/255)))^0.3), ((((g/255)))^0.3), ((((b/255)))^0.3)};

Show[
        Graphics[
          Raster[lenaCouleursPâle, ColorFunction -> RGBColor]], 
        AspectRatio -> Automatic];

Ex 9

f[x_] := 1 /; x ≥ 122
f[x_] := 0
SetAttributes[f, Listable];

Map[f, lenaGris];
Show[Graphics[Raster[%]], 
        AspectRatio -> Automatic];

Ex 10

lenaGrisPâle = 
        lenaGris /. g_?NumericQ -> ((((g/255)))^0.3);
Show[Graphics[Raster[lenaGrisPâle]], 
        AspectRatio -> Automatic];

lenaGrisNégatif = 
        lenaGris /. g_?NumericQ -> ((-g + 255)/255);
Show[Graphics[Raster[lenaGrisNégatif]], 
        AspectRatio -> Automatic];

Ex 11

un = Table[g, {g, 0, 255}];

Show[Graphics[Raster[(1/255) {un}]], 
        AspectRatio ->  .2];

Ex 12

un = 
        Table[{GrayLevel[x], Rectangle[{x, 0}, {x + 0.01, 0.2}]}, {x, 0, 
            0.99, 0.01}];
Show[Graphics[un], AspectRatio -> Automatic, Frame -> True, 
        FrameTicks -> {True, False, False, False}, 
        PlotLabel -> "GrayLevel[g]"];

Ex 13

Table[{RGBColor[x, 0, 0], Rectangle[{x, 0}, {x + 0.01, 0.2}]}, {x, 0, 
          0.99, 0.01}];
Show[Graphics[%], AspectRatio -> Automatic, Frame -> True, 
        FrameTicks -> {True, False, False, False}, 
        PlotLabel -> "RGBColor[r,0,0]"];

Ex 14

Trois manières d'afficher la palette:

Table[{0, g, b}, {b, 0, 255, 25.5}, {g, 0, 255, 25.5}];
Show[
        Graphics[
          Raster[%, {{0, 0}, {255, 255}}, {0, 255}, 
            ColorFunction -> RGBColor]], AspectRatio -> Automatic, 
        Frame -> True, 
        FrameLabel -> {"g", "b"}];

Table[{RGBColor[0, x, y], Rectangle[{x, y}, {x + 0.1, y + 0.1}]}, {x, 
          0, 0.9, 0.1}, {y, 0, 0.9, 0.1}];
Show[Graphics[%], AspectRatio -> Automatic, Frame -> True, 
        FrameLabel -> {"g", "b", None, None}];

Plot3D[{0, RGBColor[0, x, y]}, {x, 0, 1}, {y, 0, 1}, 
        Boxed -> False, Axes -> {True, True, False} , 
        AxesLabel -> {"g", "b", Nul}, 
        ViewPoint -> {0, 0, 100}, PlotPoints -> 21];

Ex 15

cubeColoré[x_, y_, z_]:={RGBColor[x, y, z], Cuboid[{x-0.04, y-0.04, z-0.04 },{x+0.04, y+0.04, z+0.04 }]};

arêtesOx=Table[cubeColoré[x, y, z], {x,0,1,0.1},{y, 0, 1, 1},{z,0,1,1}];

arêtesOy=Table[cubeColoré[x, y, z], {x, 0, 1,1},{y, 0, 1, 0.1},{z,0,1,1}];

arêtesOz=Table[cubeColoré[x, y, z], {x, 0, 1, 1},{y,0,1,1},{z,0,1,0.1}];

cubeArêtes= {arêtesOx, arêtesOy, arêtesOz};

Show[Graphics3D[cubeArêtes], Lighting-> False,Boxed->False,Axes->True,
AxesLabel->{"R","G","B"},Ticks->{{0,1},{0,1},{0,1}}];

\(\(\(diagonale = 
        Table[cubeColoré[d, d, d], {d, 0, 1, 0.1}];\)\(
\)
    \)\)

Show[Graphics3D[{diagonale}], Lighting -> False];

Show[Graphics3D[cubeArêtes], Lighting -> False, 
        Boxed -> False, Axes -> False, 
        ViewPoint -> {100, 100, 100}];

Ex 16

Table[    {  Hue[x], 
          Rectangle[{x, 0}, {x + 0.01, 0.4}]  }, {  x, 0, 0.99, 
          0.01 }      ];
\(\(Show[\ Graphics[\ \ %\ \ ], Frame -> \ True, 

        AspectRatio -> \ Automatic, 
        FrameTicks\ \ \  -> {Automatic, None}];\)\)

Ex 17

z[α_] := Cos[α] + I Sin[α]
Table[{Hue[(α/(2  π))], 
          Disk[{Re[z[α]], Im[z[α]]}, 0.05]}, {α, 0, 
          2  π, 2  π/60}];

Show[Graphics[%], AspectRatio -> Automatic];

Ex 18

\(\(éventail = 
	
        Table[{Hue[t/\((2  Pi\ )\)], \ 
            Polygon[{{0, 0}, \ {Cos[t], Sin[t]}, {Cos[t + 2  Pi/100], 
                  Sin[t + 2  Pi/100]}}]}, {t, 0, 2  Pi, 
            2  Pi/100}];\)
\)
\(\(valeurs = 
        Table[Text[N[t/\((2  Pi)\), 3], \ 1.25 {Cos[t], Sin[t]}, 
            TextStyle -> {FontSize -> 9}], \ {t, 0, 
            2  Pi - 2  Pi/8, 2  Pi/8}];\)
\)
Show[ Graphics[ { éventail, valeurs} ],  
        AspectRatio -> Automatic, PlotRange -> All];

Ex 19

Table[{Hue[1, s, b], Rectangle[{s, b}, {s + 0.1, b + 0.1}]}, {s, 0, 
          0.9, 0.1}, {b, 0, 0.9, 0.1}];
Show[Graphics[%], AspectRatio -> Automatic, Frame -> True, 
        FrameLabel -> {"s", "l", None, None}];

Ex 20

On commence par définir les trois cercles.

cR = {0, ((Sqrt[3])/2.) }; cG = {0.5, 0}; cB = {-0.5, 0}; 
r = rR = rG = rB = ((Sqrt[3])/2.) ; 
bleu = {RGBColor[0, 0, 1], Circle[cB, r]}; 
rouge = {RGBColor[1, 0, 0], Circle[cR, r]}; 
\(vert = {RGBColor[0, 1, 0], 
        Circle[cG, r]}; 
\)
Show[Graphics[{rouge, vert, bleu}], AspectRatio -> Automatic, 
      Axes -> True];

On définit ensuite une fonction f(x, y) qui attribue la bonne couleur aux points des différentes zones. Cette couleur s'obtient en testant la distance du point aux centres des trois cercles.

d[v_, w_] := (Sqrt[(v - w) . (v - w)])
m = {x, y};

f[x_, y_] := 
      RGBColor[1, 0, 0] /; 
        d[m, cR] < r && d[m, cG] > r && d[m, cB] > r
f[x_, y_] := 
      RGBColor[0, 1, 0] /; 
        d[m, cG] < r && d[m, cB] > r && d[m, cR] > r
\(f[x_, y_] := 
      RGBColor[0, 0, 1] /; 
        d[m, cB] < r && d[m, cR] > r && 
          d[m, cG] > r

\)
f[x_, y_] := 
      RGBColor[1, 1, 0] /; 
        d[m, cR] < r && d[m, cG] < r && d[m, cB] > r
f[x_, y_] := 
      RGBColor[0, 1, 1] /; 
        d[m, cG] < r && d[m, cB] < r && d[m, cR] > r
\(f[x_, y_] := 
      RGBColor[1, 0, 1] /; 
        d[m, cR] < r && d[m, cB] < r && 
          d[m, cG] > r
\)
\(f[x_, y_] := 
      RGBColor[1, 1, 1] /; 
        d[m, cR] < r && d[m, cG] < r && 
          d[m, cB] < r

\)
f[x_, y_] := RGBColor[0, 0, 0]

Les quatre figures sont ensuite obtenues en construisant une table de rectangles colorés par la fonction f. La constante e est utilisée pour le fond noir.

e = 0.3;

pixelsLumière = 
        Table[{f[x, y], 
            Rectangle[{x, y}, {x + 0.02, y + 0.02}]}, {x, -0.5 - ((Sqrt[3])/2) - 
              e, 0.5 + e + ((Sqrt[3])/2), 0.02}, {y, -((Sqrt[3])/2) - e, (Sqrt[3]) + e, 
            0.02}];
un = 
        Show[Graphics[pixelsLumière], 
          AspectRatio -> Automatic];

pixelsLumièreDeuxTiers = 
      pixelsLumière /. 
        RGBColor[rr_, gg_, bb_] -> 
          RGBColor[(2/3) rr, (2/3) gg, (2/3) bb]; 
deux = 
        Show[Graphics[pixelsLumièreDeuxTiers], 
          AspectRatio -> Automatic];

pixelsLumièreDemi = 
      pixelsLumière /. 
        RGBColor[rr_, gg_, bb_] -> 
          RGBColor[(1/2) rr, (1/2) gg, (1/2) bb]; 
trois = 
        Show[Graphics[pixelsLumièreDemi], 
          AspectRatio -> Automatic];

pixelsLumièreUnTiers = 
      pixelsLumière /. 
        RGBColor[rr_, gg_, bb_] -> 
          RGBColor[(1/3) rr, (1/3) gg, (1/3) bb]; 
quatre = 
        Show[Graphics[pixelsLumièreUnTiers], 
          AspectRatio -> Automatic];

Show[GraphicsArray[{{un, deux}, {trois, quatre}}], 
        Frame -> True];

Ex 21.1

Pour disposer de la commande CMYColor on charge le package Graphics`Colors`.

<< Graphics`Colors`

Oon modifie ensuite l'instruction pixelsLumière définie à l'exercice 20.

pixelsPigments = 
        pixelsLumière /. 
          RGBColor[rr_, gg_, bb_] -> CMYColor[rr, gg, bb];

Show[Graphics[pixelsPigments], AspectRatio -> Automatic, 
        Frame -> True, FrameTicks -> False];

Ex 21.2

<< Graphics`Colors`

La commande AllColors permet de dresser la liste des 180 couleurs.

AllColors // Short

Show[Graphics[{Sienna, Rectangle[{0, 0}, {1, 1}]}], 
        AspectRatio -> Automatic];

Show[Graphics[{VenetianRed, Rectangle[{0, 0}, {1, 1}]}], 
        AspectRatio -> Automatic];

Show[Graphics[{Indigo, Rectangle[{0, 0}, {1, 1}]}], 
        AspectRatio -> Automatic];

Ex 21.3

<< Graphics`Colors`

cubeColoré[x_, y_, z_]:={CMYColor[x, y, z], Cuboid[{x-0.04, y-0.04, z-0.04 },{x+0.04, y+0.04, z+0.04 }]};

arêtesOx=Table[cubeColoré[x, y, z], {x,0,1,0.1},{y, 0, 1, 1},{z,0,1,1}];

arêtesOy=Table[cubeColoré[x, y, z], {x, 0, 1,1},{y, 0, 1, 0.1},{z,0,1,1}];

arêtesOz=Table[cubeColoré[x, y, z], {x, 0, 1, 1},{y,0,1,1},{z,0,1,0.1}];

cubeArêtes= {arêtesOx, arêtesOy, arêtesOz};

Show[Graphics3D[cubeArêtes], Lighting-> False,Boxed->False,Axes->True,
AxesLabel->{"C","M","J"},Ticks->{{0,1},{0,1},{0,1}}];

Ex 21.4

Ex 21.5

\(\(Table[{Hue[Random[]], 
          Rectangle[{a = Random[], b = Random[]}, {a + 1/10, 
              b + 1/10}]}, {100}];\)
\)
Show[Graphics[%], Frame -> True, FrameTicks -> None, 
        Background -> GrayLevel[0.7]];

\(\(Table[{Hue[Random[]], 
          Disk[{a = Random[], b = Random[]}, {a + 1/10, 
              b + 1/10}]}, {100}];\)
\)
Show[Graphics[%], Frame -> True, FrameTicks -> None, 
        Background -> GrayLevel[0.7]];

<< Graphics`Colors`

Table[{CMYColor[1, Random[], Random[]], 
          Rectangle[{a = Random[], b = Random[]}, {a + 1/10, 
              b + 1/10}]}, {100}];

    
Show[Graphics[%], Frame -> True, FrameTicks -> None, 
        Background -> GrayLevel[0.7]];

Correction des exercices 2.6

Ex 1

disque[x_, y_] := Disk[{x, y}, 1];

rgb[x_, y_]:=
Apply[RGBColor,((lenaCouleurs[[y+1,x+1]])/255.)];

pixelD[x_, y_] := {rgb[x, y], disque[x, y]};

lenaPixD = 
        Graphics[
          Table[pixel[x, y], {x, 0, 255}, {y, 0, 255}]];

Show[lenaPixD, AspectRatio -> Automatic];

Si on agrandit trop l'image on voit apparaître des trous entre les disques.

Ex 2

Plot[(x^0.3), {x, 0, 1}, Frame -> True];

Un peu plus pâle avec l'exposant 0.2

Plot[(x^0.2), {x, 0, 1}, Frame -> True];

lenaPixPâle1=lenaPix/.RGBColor[r_, g_, b_]->RGBColor[(r^0.2),(g^0.2),(b^0.2)];

Show[lenaPixPâle1, AspectRatio -> Automatic];

Un peu moins pâle avec l'exposant 0.4.

Plot[(x^0.4), {x, 0, 1}, Frame -> True];

lenaPixPâle1=lenaPix/.RGBColor[r_, g_, b_]->RGBColor[(r^0.4),(g^0.4),(b^0.4)];

Show[lenaPixPâle1, AspectRatio -> Automatic];

Ex 3

Voici les matrices exactes des neuf applications linéaires.

({{(({{0.5, 0}, {0, 0.5}}))  , (({{0.75, 0}, {0, 0.5}})),   (({{0.5, 0}, {0, 1}}))}})

({{(({{1, -1}, {0, 1}})),   (({{-1, 0}, {0, 1}}))}})

({{(({{Cos[110.  °], -Sin[110.  °]}, {Sin[110.  °], Cos[110.  °]}}))  , (({{Cos[200.  °], Sin[200.  °]}, {Sin[200.  °], -Cos[200.  °]}}))}})

({{(({{2  Cos[100.  °], -2 
                    Sin[100.  °]}, {2  Sin[100.  °], 2  Cos[100.  °]}})),   (({{2  Cos[200.  °], 2  Sin[200.  °]}, {2  Sin[200.  °], -2 
                      Cos[200.  °]}}))}})

Ex 4

Choisir par exemple une rotation de 90° et une symétrie par rapport à l'axe Ox.

Ex 5

(({{Cos[α], -Sin[α]}, {Sin[α], Cos[α]}})).(({{Cos[β], -Sin[β]}, {Sin[β], Cos[β]}}))//MatrixForm

(({{Cos[β], -Sin[β]}, {Sin[β], Cos[β]}})).(({{Cos[α], -Sin[α]}, {Sin[α], Cos[α]}}))//MatrixForm

(({{a, c}, {b, d}})).(({{k, 0}, {0, k}}))//MatrixForm

(({{k, 0}, {0, k}})).(({{a, c}, {b, d}}))//MatrixForm

Ex 6

Utilser le programme correspondant à la figure 2.7 en faisant varier les paramètres

Ex 7

Déterminer les matrices des similtudes affines de façon à ce que les coins inférieurs de lenaPix reposent sur les images de lenaPix par ces similitudes.

Ex 8

Après avoir réalisé quelques séquences à la main, on est conduit à faire un programme.

a = {0.5, ((Sqrt[3])/2.) }; b = {0, 0}; c = {1, 0};
fa[m_] := ((m + a)/2);
fb[m_] := ((m + b)/2);
fc[m_] := ((m + c)/2);
image[m_] := {fa, fb, fc}[[Random[Integer, {1, 3}]]][
        m]

    
jeuChaos[départ_, n_] := 
Show[
        Graphics[Map[Point, NestList[image, départ, n]]], 
        AspectRatio -> Automatic]

jeuChaos[{1, 1}, 10000];

On voit apparaître de manière surprenante un triangle de Sierpinski !

Remarque: On peut créer une sorte de triangle de Sierpinski avec la notation indicée supérieure et inférieure.

SubsuperscriptBox[1, 2, 3] // DisplayForm

SubsuperscriptBox[▪, ▪, ▪] // DisplayForm

Nest[SubsuperscriptBox[#,#,#]&,▪,6]//DisplayForm

Ex 9

OA = 
        Graphics[{RGBColor[1, 0, 0], Line[{{0, 0}, {1, 0}}]}];
r[1]={x_?NumericQ, y_?NumericQ}->(({{1/3. , 0}, {0, 1/3. }})).{x, y};
r[2]={x_?NumericQ, y_?NumericQ}->(({{Cos[60.  °], -Sin[60  °]}, {Sin[60  °], Cos[60.  °]}})).(({{1/3. , 0}, {0, 1/3. }})).{x, y}+{1/3. , 0};
r[3]={x_?NumericQ, y_?NumericQ}->(({{Cos[-60.  °], -Sin[-60 °]}, {Sin[-60 °], Cos[-60.  °]}})).(({{1/3. , 0}, {0, 1/3. }})).{x, y}+{1/2. , ((Sqrt[3])/6.) };
r[4]={x_?NumericQ, y_?NumericQ}->(({{1/3. , 0}, {0, 1/3. }})).{x, y}+{(2/3.),0};
copie[g_] := 
        Table[g /. r[i], {i, 1, 4}];

Show[Nest[copie, OA, 1], AspectRatio -> Automatic, 
        Frame -> True, 
        FrameTicks -> {{0, 1}, {0, ((Sqrt[3])/6)}, False, False}];

Show[Nest[copie, OA, 2], AspectRatio -> Automatic, 
        Frame -> True, 
        FrameTicks -> {{0, 1}, {0, ((Sqrt[3])/6)}, False, False}];

Show[Nest[copie, OA, 3], AspectRatio -> Automatic, 
        Frame -> True, 
        FrameTicks -> {{0, 1}, {0, ((Sqrt[3])/6)}, False, False}];

Show[Nest[copie, OA, 6], AspectRatio -> Automatic, 
        Frame -> True, 
        FrameTicks -> {{0, 1}, {0, ((Sqrt[3])/6)}, False, False}];

Ex 10

L' attracteur est la réunion de trois de ses copies.

pointO = Graphics[Point[{0, 0}]];

r[1]={x_?NumericQ, y_?NumericQ}->(({{0.5, 0}, {0, 0.5}})).(({{0, -1}, {1, 0}})).{x, y}+{0.5, 0};
r[2]={x_?NumericQ, y_?NumericQ}->(({{0.5, 0}, {0, 0.5}})).(({{0, 1}, {-1, 0}})).{x, y}+{0.5, 0.5};
r[3]={x_?NumericQ, y_?NumericQ}->(({{0.5, 0}, {0, 0.5}})).{x, y}+{0.25, 0.5};

copie[g_] := Table[g /. r[i], {i, 1, 3}];

Show[Nest[copie, pointO, 8], AspectRatio -> Automatic, 
        Frame -> True, FrameTicks -> False];

Ex 11

L' attracteur est la reunion de quatre de ses copies.

seg = Graphics[Line[{{0, 0}, {1, 0}}]];
r[1]={x_?NumericQ, y_?NumericQ}->(({{0.5, 0}, {0, 0.5}})).(({{0, 1}, {-1, 0}})).{x, y}+{0, 0.5};
r[2]={x_?NumericQ, y_?NumericQ}->(({{0.5, 0}, {0, 0.5}})).(({{0, -1}, {1, 0}})).{x, y}+{1, 0};
r[3]={x_?NumericQ, y_?NumericQ}->(({{0.5, 0}, {0, 0.5}})).{x, y}+{0, 0.5};
r[4]={x_?NumericQ, y_?NumericQ}->(({{0.5, 0}, {0, 0.5}})).{x, y}+{0.5, 0.5};


copie[g_] := 
        Table[g /. r[i], {i, 1, 4}];

Show[Nest[copie, seg, 7], AspectRatio -> Automatic, 
        Frame -> True, FrameTicks -> False];

Ex 12

Voici par exemple comment on peut inscrire le portrait de Lena dans une astroïde (équations paramétriques: x = 128  (cos^3) t,  y = 28  (sin^3) t; équation cartésienne implicite (x^(2/3)) + (y^(2/3)) = (128^(2/3))).

ParametricPlot[{128 (((Cos[t]))^3), 128 (((Sin[t]))^3)}, {t, 0, 
          2  Pi}, AspectRatio -> Automatic, 
        Ticks -> {{-128, 128}, {-128, 128}}];

NSolve[(x^(2/3)) + (y^(2/3)) == (128^(2/3)), y]

Show[lenaPixPâleO, lenaPixO/.{x_?NumericQ, y_?NumericQ}->(({{1, 0}, {0, ((((25.4- ((Abs[x])^(2/3))))^(3/2))/128.)}})).{x,y},              AspectRatio  ->  Automatic,Frame  ->  True];

Correction des exercices 3.7

Ex 1

Réaliser une voûte noire légèrement plus haute. 
Définir les nervures qui sont des arcs d'ellipse.
Afficher avec le tout avec voûteLena.

Ex 2

r = (255. /(2  Pi));

un = 
        ParametricPlot3D[{r Cos[α], r Sin[α], z, 
            rgb[(r α) // Round, z]}, {α, 0, 2  Pi}, {z, 0, 
            255}, PlotPoints -> 256, 
          DisplayFunction -> Identity];

deux = Insert[un, EdgeForm[], {1, 1}];

Show[deux, DisplayFunction -> $DisplayFunction, 
        Lighting -> False, Boxed -> False, Axes -> False, 
        ViewPoint -> {-2.039,  -2.403,  1.231}];

Ex 3

un = 
        Plot3D[{Sin[((2  Pi)/255) x], rgb[x, y]}, {x, 0, 255}, {y, 0, 
            255}, PlotPoints -> 256, Mesh -> False, 
          Boxed -> False, Axes -> False];

Ex 4

Les numéros des faces correspondent à celles d'un dé montrant un as. Le deux est dans le plan xOz.

poly = Polygon[{{0, 0, 0}, {1, 0, 0}, {1, 0, 1}, {0, 0, 1}}];

deux := {Hue[Random[]], 
          poly};
trois:=deux/.{x_?NumericQ, y_?NumericQ, z_?NumericQ}->(({{0, -1, 0}, {1, 0, 0}, {0, 0, 1}})).{x, y, z};
quatre := 
        trois /. {x_?NumericQ, y_?NumericQ, z_?NumericQ} -> {x + 1, y, z}; 

cinq := 
        deux /. {x_?NumericQ, y_?NumericQ, z_?NumericQ} -> {x, y + 1, z}; 

six:=deux/.{x_?NumericQ, y_?NumericQ, z_?NumericQ}->(({{1, 0, 0}, {0, 0, 1}, {0, -1, 0}})).{x, y, z};
diago = {GrayLevel[1], Line[{{0, 0, 0}, {1, 1, 1}}]}; 

boîte = {deux, trois, quatre,  cinq, six, diago}; 

Show[Graphics3D[boîte], 
        Lighting -> False, Boxed -> False, 
        Axes -> False];

rot=(({{(1/(Sqrt[3])), 0, -((Sqrt[2])/(Sqrt[3]))}, {0, 1, 0}, {((Sqrt[2])/(Sqrt[3])), 0, (1/(Sqrt[3]))}})).(({{((Sqrt[2])/2), ((Sqrt[2])/2), 0}, {-((Sqrt[2])/2), ((Sqrt[2])/2), 0}, {0, 0, 1}}));rot // MatrixForm

boîteNew = 
        boîte /. {x_?NumericQ, y_?NumericQ, z_?NumericQ} -> 
            rot . {x, y, z} + {3, 0, 0};
Show[Graphics3D[boîteNew], Lighting -> False, 
        Boxed -> False, Axes -> False, 
        ViewPoint -> 100 {0, 0, 1}];

Ex 5

Les numéros des faces correspondent à celles d'un dé montrant un as. Le deux est dans le plan xOz.

deux0 = 
        ParametricPlot3D[{x, 0, z, rgbLena[x, z]}, {x, 0, 255}, {z, 0, 255}, 
          PlotPoints -> 256, 
          DisplayFunction -> Identity];
deux = Insert[deux0, EdgeForm[], {1, 1}];

bordDeux = 
        Graphics3D[{RGBColor[0.0442664,  0.905516,  1], Thickness[0.01], 
            Line[{{0, 0, 0}, {255, 0, 0}, {255, 0, 255}, {0, 0, 255}, {0, 0, 
                  0}}]}];

faceDeux = {deux, bordDeux};

faceTrois=faceDeux/.{x_?NumericQ, y_?NumericQ, z_?NumericQ}->(({{0, -1, 0}, {1, 0, 0}, {0, 0, 1}})).{x, y, z};

faceQuatre = 
        faceTrois /. {x_?NumericQ, y_?NumericQ, z_?NumericQ} -> {x + 255, y, 
              z};

faceSix=faceDeux/.{x_?NumericQ, y_?NumericQ, z_?NumericQ}->(({{1, 0, 0}, {0, 0, 1}, {0, -1, 0}})).{x, y, z};

faceCinq = 
        faceDeux /. {x_?NumericQ, y_?NumericQ, z_?NumericQ} -> {x, y + 255, 
              z};

boîte = {faceDeux, faceTrois, faceQuatre, faceCinq, 
          faceSix};

Show[boîte, DisplayFunction -> $DisplayFunction, 
        Lighting -> False, ViewPoint -> {0.941,  -2.128,  2.456}, 
        Boxed -> False, Axes -> False];

Ex 6

Avant de prendre connaissance du corrigé, il est intéressant de lire la solution proposée en 1778 par Jacques Ozanam (Récréations mathémathiques et physiques, tome 3, page 372) en consultant le site web du CNAM (http://cnum.cnam.fr/fSYN/8PY9.html).

a) Le dessin est fait en prenant r = 1.

f[x_, y_] := Min[(Sqrt[(1^2) - (y^2)]), (Sqrt[(1^2) - (x^2)])]

solide = 
      Plot3D[f[x, y], {x, -1, 1}, {y, -1, 1}, PlotPoints -> 200, 
        Mesh -> False, BoxRatios -> Automatic, Boxed -> False, 
        Axes -> False, DisplayFunction -> Identity];

Ox = Line[{{0, 0, 0}, {1.5, 0, 0}}]; 
Oy = Line[{{0, 0, 0}, {0, 2, 0}}]; 
\(Oz = Line[{{0, 0, 0}, {0, 0, 2}}]; 
\)
texte = 
{Text["x", {1.7, 0, 
            0}], 
Text["y", {0, 2.3, 
            0}], 
Text["z", {0, 0, 
            2.2}]}; 

axes = Graphics3D[{Ox, Oy, Oz, texte}];

Show[solide, axes, DisplayFunction -> $DisplayFunction, 
      PlotRange -> All];

b) Le volume de la pyramide de même base et de même hauteur est (4/3) (r^3). Les sections horizontales de la voûte sont des carrés de côté 2 (Sqrt[ (r^2) - (z^2)]) ; son volume est donc \(4 \(∫\_0\%r\((r\^2 - 
                  z\^2)\) dz\) = \(8\/3\) \(\(r\^3\)\(.\)\)\)

c) Le patron est fait pour  r = 1.

L'aire de la partie voûtée est l'aire des huit demi-pointes du patron, soit 8 (∫_0^(π/2))cos x dx = 8 dans le cas particulier où r = 1 et  8  (r^2)dans le cas général.

d) Le solide n'est autre qu'un demi-cylindre de rayon r. Voici le dessin avec r = 1.

h[x_, y_] := 
      Min[(Sqrt[(1^2) - (y^2)]), (Sqrt[(1^2) - (x^2)])] /; (x - y) (x + 
                y) ≥ 0
h[x_, y_] := Max[(Sqrt[(1^2) - (y^2)]), (Sqrt[(1^2) - (x^2)])]

solide = 
Plot3D[
        h[x, y], {x, -1, 1}, {y, -1, 1}, PlotPoints -> 200, 
        Mesh -> False, BoxRatios -> Automatic];

On rend plus visibles les arcs d'ellipse en les surélevan légèrement.

ellipse1 = 
      ParametricPlot3D[
        1.01 {t, t, 1.01 (Sqrt[ 1 - (t^2)])}, {t, -1, 1}];

ellipse2 = 
      ParametricPlot3D[
        1.01 {-t, t, 1.01 (Sqrt[ 1 - (t^2)])}, {t, -1, 1}];

Show[solide, ellipse1, ellipse2];

L'aire du demi-cylindre  est 2  π (r^2)et son volume π (r^3).

e) Soit A l'aire de la voûte en arc de cloître et A' celle de la voûte d'arêtes. D'après d), on a (1/2) A + (1/2) A' = 2  π (r^2). Comme A = 8  (r^2)on en déduit que A' = 4  (r^2)(π - 2).

Soit V l'aire de la voûte en arc de cloître et V' celle de la voûte d'arêtes. D'après d), on a (1/2) V + (1/2) 
            V' = π (r^3). Comme V = (8/3) (r^3)on en déduit que V' = 2  (r^3)(π - (4/3)).

Ex 7

La droite d est maintenant la droite qui passe par I et par le point V(xv=0, yv=1280, zv=512).

Correction des exercices 4.3

Ex 1

Importation

tour = Import["Desktop/tour.jpeg"];

Show[%];

Détermination de la transformation qui corrige la perspective

Remove[éq1, x1, a, b, x, c, y, d]

Remove[éq2, y1, e, f, x, g, y, h]

Remove[système]

éq1 = 
        x1 == a + b x + c y + d x y;

    éq2 = y1 == g + h x + i y + j x y;

système = {éq1, éq2} /. 
{{x -> 85, y -> 82, x1 -> 85, 
              y1 -> 
                82}, 

{x -> 154, 
              y -> 523, x1 -> 85, 
              y1 -> 
                585}, 

{x -> 381, 
              y -> 140, x1 -> 381, 
              y1 -> 
                82}, 

{x -> 300, 
              y -> 586, x1 -> 381, y1 -> 585}} // 
        Flatten

sol = Solve[système] // Flatten

x1 = éq1[[2]] /. sol

y1 = éq2[[2]] /. sol

Pixelisation de l'image à transformer

InputForm[tour] // Short

tourCouleurs = 
        tour[[1, 1]];

tourCouleurs // Dimensions

carré[x_, y_] := 
        Polygon[{{x, y}, {x + 1, y}, {x + 1, y + 1}, {x, y + 1}}];

rgbTour[x_, y_]:=
Apply[RGBColor,((tourCouleurs[[y+1,x+1]])/255.)];
 pixelTour[x_, y_] := {rgbTour[x, y], carré[x, y]};
 
tourPix = 
          Graphics[Table[pixelTour[x, y], {x, 0, 449}, {y, 0, 599}]];

Show[tourPix, 
        AspectRatio -> Automatic, Frame -> True];

Correction de la perspective

tour1Pix = 
        tourPix /. {x_?NumericQ, y_?NumericQ} -> {x1, y1};

Show[tour1Pix, AspectRatio -> Automatic];

Détermination de la transformation qui corrige la déformation en tonneau

Remove[éq1, x1, a, b, x, c, y, d, e, f, g, h, i]

Remove[éq2, y1, j, k, l, m, n, o, p, q, r]

Remove[système]

éq1 = 
        x1 == 
          a + b x + c y + d x y + e (x^2) + f (y^2) + g x (y^2) + 
            h (x^(2 )) y + i (x^2) (y^2);
éq2 = 
        y1 == 
          j + k x + l y + m x y + n (x^2) + o (y^2) + p x (y^2) + 
            q (x^(2 )) y + r (x^2) (y^2);

système = {éq1, éq2} /. 
{{x -> 85, y -> 80, x1 -> 85, 
                y1 -> 80}, 
{x -> 65, 
                y -> 338, x1 -> 85, 
                y1 -> 338}, 
{x -> 88, 
                y -> 586, x1 -> 88, 
                y1 -> 586}, 
{x -> 375, 
                y -> 586, x1 -> 375, 
                y1 -> 586}, 
{x -> 399, 
                y -> 338, x1 -> 383, 
                y1 -> 338}, 
{x -> 383, 
                y -> 80, x1 -> 383, 
                y1 -> 80}, 
{x -> 217, 
                y -> 580, x1 -> 217, 
                y1 -> 580}, 
{x -> 217, 
                y -> 338, x1 -> 217, 
                y1 -> 338}, 
{x -> 217, 
                y -> 80, x1 -> 217, 
                y1 -> 80}

} // 
          Flatten;

sol = Solve[système] // Flatten

x1 = éq1[[2]] /. sol

y1 = éq2[[2]] /. sol

NSolve[système] // Flatten

x1N = x1 // N

Correction de la déformation en tonneau

Show[tour1Pix /. {x_?NumericQ, y_?NumericQ} -> {x1N, y}, 
        AspectRatio -> Automatic];

tourA = 
        Show[%, PlotRange -> {{30, 420}, {-8, 599}}];

Ex 2

La méthode consiste à 

1. découper l'image en quatre parties: fenêtre gauche (α), battant gauche (β), battant droit (γ),  fenêtre droite (δ) ;

2. fermer les deux battants par correction de perspective:  β ->ββ, γ ->γγ  ;

3. afficher sur une même figure les parties α, ββ, γγ, δ.

Importation

SetOptions[Graphics, AspectRatio -> Automatic];

vue = Import["Desktop/vue.jpeg"];

Show[vue, Frame -> True];

Matrice des couleurs

vueCouleurs = vue[[1, 1]];

Dimensions[vueCouleurs]

Pixelisation de la vue

carré[x_, y_] := 
        Polygon[{{x, y}, {x + 1, y}, {x + 1, y + 1}, {x, 
              y + 1}}];

rgbVue[x_, y_]:=
Apply[RGBColor,((vueCouleurs[[y+1,x+1]])/255.)];

pixelVue[x_, y_] := {rgbVue[x, y], carré[x, y]};

vuePix = 
        Graphics[
          Table[pixelVue[x, y], {x, 0, 799}, {y, 0, 531}]];

Dimensions[vuePix[[1]]]

Découpage de la vue

α = 
        Graphics[Take[vuePix[[1]], {1, 212}, {1, 532}]];
Show[α];

β = 
        Graphics[Take[vuePix[[1]], {224, 346}, {1, 532}]];
Show[β];

γ = 
        Graphics[Take[vuePix[[1]], {439, 597}, {1, 532}]];
Show[γ];

δ = 
        Graphics[Take[vuePix[[1]], {612, 800}, {1, 532}]];
Show[δ];

Fermeture du battant  β

Remove[éq1, x1, a, b, x, c, y, d]
Remove[éq2, y1, e, f, x, g, y, h]
Remove[système]

eq1 = 
        x1 == a + b x + c y + d x y;

    eq2 = y1 == e + f x + g y + h x y;

système = {eq1, 
              eq2} /. 
{{x -> 224, y -> 1, 
                x1 -> 214, 
                y1 -> 1}, 
{x -> 224, 
                y -> 532, x1 -> 214, 
                y1 -> 532}, 
{x -> 342, 
                y -> 46, x1 -> 399, 
                y1 -> 1}, 
{x -> 350, 
                y -> 495, x1 -> 399, y1 -> 532}} // 
          Flatten;

sol = NSolve[système] // Flatten

x1 = eq1[[2]] /. sol

y1 = eq2[[2]] /. sol

ββ = β /. {x_?NumericQ, y_?NumericQ} -> {x1, 
              y1};

Show[ββ];

Show[α, ββ];

Fermeture du battant γ

Remove[éq1, x1, a, b, x, c, y, d]
Remove[éq2, y1, e, f, x, g, y, h]
Remove[système]

eq1 = 
        x1 == a + b x + c y + d x y;

    eq2 = y1 == e + f x + g y + h x y;

système = {eq1, 
              eq2} /. 
{{x -> 598, y -> 1, 
                x1 -> 611, 
                y1 -> 1}, 
{x -> 600, 
                y -> 530, x1 -> 615, 
                y1 -> 532}, 
{x -> 443, 
                y -> 62, x1 -> 400, 
                y1 -> 1}, 
{x -> 444, 
                y -> 493, x1 -> 400, y1 -> 532}} // 
          Flatten;

sol = NSolve[système] // Flatten

x1 = eq1[[2]] /. sol

y1 = eq2[[2]] /. sol

γγ = γ /. {x_?NumericQ, y_?NumericQ} -> {x1, 
              y1};

Show[γγ];

Vue finale

Show[α, ββ, γγ, δ];

Show[%, PlotRange -> {1, 532}];

vueA = 
        Show[% /. RGBColor[r_, g_, b_] -> 
              RGBColor[1 - r, 1 - g, 1 - b]];