Více o 2D a 3D grafice

Antonín Slavík
MFF UK

Anonymní funkce (připomenutí)

= nepojmenované funkce, obvykle na jedno použití

({{Anonymní funkce jedné proměnné, Anonymní funkce více proměnných}, {Function[proměnná, předpis], Function[seznam proměnných, předpis]}, {(předpis s proměnnou #)&, (předpis s proměnnými #1, #2, ...)&}})

Příklad: Výpočet členů posloupnosti definované vztahy (Subscript[a, 0])=0.5,  (Subscript[a, n+1])=(Subscript[a, n])(1-(Subscript[a, n])).

(Subscript[a, n]) můžeme dostat jako n-tou iteraci funkce f(x)=x(1-x) v bodě 0.5.

NestList[f,x,n] spočte prvních n iterací funkce f v bodě x.

NestList[Function[x,x(1-x)],0.5,10]

NestList[#(1-#)&,0.5,10]

Options (připomenutí)

Chování většiny funkcí v Mathematice lze ovlivňovat pomocí voleb (options). Jejich význam je popsán v dokumentaci.

Options[Plot]

Adaptivní vykreslování

Graf funkce jedné proměnné je ve skutečnosti lomenou čarou spojující velké množství bodů. Lze se o tom přesvědčit pomocí InputForm nebo FullForm:

Plot[Sin[x],{x,0,4π}]

InputForm[%]

V místech s velkou křivostí je hustota kontrolních bodů největší (tj. úsečky jsou nejkratší). Pomocí Mesh->All lze zobrazit všechny kontrolní body:

Plot[Sin[x],{x,0,4 π},Mesh->All,MeshStyle->PointSize[0.015],PlotStyle->{Thick,Red}]

Adaptivní algoritmus konstruuje kontrolní body takto:

Na začátku zvolí jistý počet ekvidistantních bodů na ose x (volba PlotPoints, výchozí hodnota je 50), vypočte v nich funkční hodnoty a spojí takto vzniklé body lomenou čarou.

Pokud je velikost úhlu mezi dvěma sousedními úsečkami větší než 5˚, pak se příslušný interval rozpůlí; maximální počet takovýchto půlení je určen volbou MaxRecursion.

10 počátečních bodů (PlotPoints->10) a zákaz půlení (MaxRecursion->0):

Plot[Sin[x],{x,0,4 π},Mesh->All,MeshStyle->PointSize[0.02],PlotStyle->{Thick,Red},PlotPoints->10,MaxRecursion->0]

Povoleno jedno půlení:

Plot[Sin[x],{x,0,4 π},Mesh->All,MeshStyle->PointSize[0.02],PlotStyle->{Thick,Red},PlotPoints->10,MaxRecursion->1]

Manipulate[Plot[Sin[x],{x,0,4 π},Mesh->mesh,MeshStyle->PointSize[0.02],PlotStyle->{Thick,Red},PlotPoints->plotpoints,MaxRecursion->maxrecursion],{maxrecursion,0,15,1,Appearance->"Labeled"},{plotpoints,4,50,1,Appearance->"Labeled"},{mesh,{All,None}}]

Adaptivní vykreslování používají i další funkce (Plot3D, ParametricPlot atd.).

Plot3D[((x^2)+3 (y^2)) (E^(1-(x^2)-(y^2))),{x,-2,2},{y,-2.5,2.5}]

Plot3D[((x^2)+3 (y^2)) (E^(1-(x^2)-(y^2))),{x,-2,2},{y,-2.5,2.5}, Mesh->All]

Plot3D[((x^2)+3 (y^2)) (E^(1-(x^2)-(y^2))),{x,-2,2},{y,-2.5,2.5}, Mesh->All, MaxRecursion->0, PlotPoints->10]

Graf funkce dvou proměnných je poskládán z trojúhelníků:

Normal[InputForm[Plot3D[((x^2)+3 (y^2)) (E^(1-(x^2)-(y^2))),{x,-2,2},{y,-2.5,2.5},  MaxRecursion->0, PlotPoints->10]]]

Další použití Mesh

Mesh v 3D grafice

Grafy funkcí dvou proměnných a parametrizované plochy bývají pokryty sítí křivek, které představují obrazy přímek rovnoběžných s osami.

ParametricPlot3D[{(4+v Cos[(u/2)]) Cos[u],(4+v Cos[(u/2)]) Sin[u],v Sin[(u/2)]},{u,0,2 π},{v,-1,1},Boxed->False]

Pomocí Mesh->None lze křivky potlačit:

ParametricPlot3D[{(4+v Cos[(u/2)]) Cos[u],(4+v Cos[(u/2)]) Sin[u],v Sin[(u/2)]},{u,0,2 π},{v,-1,1},Boxed->False, Mesh->None]

Mesh->{m,n} specifikuje počty křivek v obou směrech:

ParametricPlot3D[{(4+v Cos[(u/2)]) Cos[u],(4+v Cos[(u/2)]) Sin[u],v Sin[(u/2)]},{u,0,2 π},{v,-1,1},Boxed->False, Mesh->{60,2}]

Styl čar a hranice je určen volbami MeshStyle a BoundaryStyle:

ParametricPlot3D[{(4+v Cos[(u/2)]) Cos[u],(4+v Cos[(u/2)]) Sin[u],v Sin[(u/2)]},{u,0,2 π},{v,-1,1},Boxed->False, Mesh->{60,2}, MeshStyle->Thick,BoundaryStyle->{Thick,Red}]

Mesh ve dvourozměrném případě

Mesh->n vyznačí body grafu, které odpovídají dělení definičního oboru na n+1 stejně dlouhých podintervalů.

Plot[Sin[x],{x,0,4 π},Mesh->7,MeshStyle->PointSize[0.02],PlotStyle->Thick]

Jinou variantou je přímo uvést x-ové souřadnice bodů, které chceme vyznačit.

Plot[Sin[x],{x,0,4 π},Mesh->{{1,2,3}},MeshStyle->PointSize[0.02],PlotStyle->Thick]

Zajímavějších výsledků lze dosáhnout spojením Mesh s volbou MeshFunctions. Na grafu pak budou vyznačeny body, ve kterých funkce zadaná v MeshFunctions nabývá hodnot specifikovaných v Mesh.

Výchozí nastavení MeshFunctions pro Plot je Function[{x,y},x]:

Plot[Sin[x],{x,0,4 π},Mesh->{{1,2,3}},MeshStyle->PointSize[0.02],MeshFunctions->{Function[{x,y},x]},PlotStyle->Thick]

Plot[Sin[x],{x,0,4 π},Mesh->{{-1/2,1/2}},MeshStyle->PointSize[0.02],MeshFunctions->{Function[{x,y},y]},PlotStyle->Thick]

Vyznačení všech nulových bodů funkce:

Plot[-12-58 x+(x^2)+(x^3),{x,-10,10},MeshFunctions->{Function[{x,y},y]},Mesh->{{0}},MeshStyle->PointSize[Large], PlotStyle->Thick]

Vyznačení průsečíků dvou funkcí:

f[x_]:=27 x+130;
g[x_]:=-12-58 x+(x^2)+(x^3);

Plot[{f[x],g[x]},{x,-10,10},MeshFunctions->{Function[{x,y},f[x]-g[x]]},Mesh->{{0}},MeshStyle->PointSize[Large], PlotStyle->{{Red,Thick},{Blue,Thick}}]

Clear[f,g]

Varování:  Algoritmus obvykle nevyznačí body na krajích definičního oboru a body, ve kterých se nabývá lokálních extrémů:

Plot[Sin[x],{x,0,4Pi},Mesh->{{0}},MeshStyle->PointSize[0.02],MeshFunctions->{Function[{x,y},y]},PlotStyle->Thick]

Plot[3Cos[x]+x^2-3,{x,-2.5,2.5},Mesh->{{0}},MeshStyle->PointSize[0.02],MeshFunctions->{Function[{x,y},y]},PlotStyle->Thick]

Znázornění vrstevnic na grafu funkce dvou proměnných

f[x_,y_]:=((x^2)+3 (y^2)) (E^(1-(x^2)-(y^2)))

plot=Plot3D[f[x,y],{x,-2,2},{y,-2.5,2.5}, BoxRatios->Automatic]

Vyznačení vrstevnic odpovídajících hodnotám 0.25, 0.50, 0.75, ..., 2.75:

Plot3D[f[x,y],{x,-2,2},{y,-2.5,2.5}, BoxRatios->Automatic, MeshFunctions->{Function[{x,y,z},z]},Mesh->{Range[0.25,2.75,0.25]}, MeshStyle->Thick]

Střídání barev vrstevnic:

Plot3D[f[x,y],{x,-2,2},{y,-2.5,2.5}, BoxRatios->Automatic, MeshFunctions->{Function[{x,y,z},z],Function[{x,y,z},z]},Mesh->{Range[0.25,2.75,0.5],Range[0.5,2.5,0.5]}, MeshStyle->{{Thick,Orange},{Thick,Blue}}]

Alternativa: Spojení Plot3D a ContourPlot

cplot=ContourPlot[f[x,y],{x,-2,2},{y,-2.5,2.5},ContourStyle->Thick]

Show[plot,Graphics3D[cplot[[1]]/.{x_Real,y_Real}->{x,y,-2}],PlotRange->{{-2,2},{-2.5,2.5},{-2,3}},BoxRatios->Automatic]

Volba MeshShading

f[x_,y_]:=((y^2)/2)-((x^2)/2)+((x^3)/3)

plot=Plot3D[f[x,y],{x,-2,2},{y,-2,2},Boxed->False]

cplot=ContourPlot[f[x,y],{x,-2,2},{y,-2,2},ContourStyle->Thick,Contours->{-2,-1,-0.5,-0.3,-0.1,0,0.1,0.3,0.5,1,2}, PlotRangePadding->None]

Plot3D[f[x,y],{x,-2,2},{y,-2,2},Boxed->False, Mesh->{{-2,-1,-0.5,-0.3,-0.1,0,0.1,0.3,0.5,1,2}}, MeshFunctions->{Function[{x,y,z},z]}, MeshStyle->Thick, PlotPoints->60]

MeshShading je seznam barev, které se použijí v oblastech mezi křivkami určenými Mesh a MeshFunctions:

Plot3D[f[x,y],{x,-2,2},{y,-2,2},Boxed->False, Mesh->{{-2,-1,-0.5,-0.3,-0.1,0,0.1,0.3,0.5,1,2}}, MeshFunctions->{Function[{x,y,z},z]}, MeshStyle->Thick, MeshShading->{Pink,White}, PlotPoints->60]

MeshShading ve 2D:

Plot[-12-58 x+(x^2)+(x^3),{x,-10,10},MeshFunctions->{Function[{x,y},y]},Mesh->{{0}},MeshStyle->PointSize[Large], PlotStyle->Thick, MeshShading->{Red, Blue}]

Volba ColorFunction

Obarvovací funkce

Pomocná funkce pro testování obarvovacích funkcí:

testColors[f_,min_:0,max_:1]:=DensityPlot[x,{x,min,max},{y,0,1},ColorFunction->f,Axes->{True,False},Frame->False,ImageSize->600,AspectRatio->1/6,ColorFunctionScaling->False,PlotPoints->100]

Hue vrací barevné odstíny, je periodická s periodou 1.

testColors[Hue,0,3]

Funkce, která na intervalu [0,1] přechází od modré k červené:

blueToRed[t_]:=Hue[0.5+0.5*t]

testColors[blueToRed]

Další předdefinované obarvovací funkce jsou k dispozici v ColorData (všechny jsou definovány na [0,1]):

ColorData["Gradients"]

testColors[ColorData["SunsetColors"]]

Manipulate[testColors[ColorData[col]],{col,ColorData["Gradients"]}]

Barvení grafů, křivek a ploch

Grafy, křivky a plochy lze barvit pomocí libovolné obarvovací funkce. Použijeme volbu ColorFunction s funkcí, která specifikuje barvu bodu v daném místě.

Plot[Abs[Sin[x]],{x,0,2π},PlotStyle->Thick,ColorFunction -> Function[{x,y},Hue[y]], AspectRatio->Automatic, ImageSize->700]

Hodnoty předávané obarvovací funkci jsou při výchozím nastavení lineárně transformovány do intervalu [0,1]; tuto vlastnost lze vypnout pomocí ColorFunctionScaling->False.

Plot3D[x+y,{x,0,2},{y,0,2},ColorFunction->Function[{x,y,z},Hue[z]], AxesLabel->{"x","y","z"}]

Plot3D[x+y,{x,0,2},{y,0,2},ColorFunction->Function[{x,y,z},Hue[z]], ColorFunctionScaling->False, AxesLabel->{"x","y","z"}]

c[t_]:={Cos[t]+0.2 Cos[26 t]+0.4 Cos[28 t]+0.8Sin[10 t]-0.4 Sin[17 t]-0.2 Sin[37 t],-0.8 Cos[10 t]-0.4 Cos[17 t]+0.2Cos[37 t]+Sin[t]-0.2 Sin[26 t]+0.4 Sin[28 t]};

ParametricPlot[c[t],{t,0,2Pi}, PlotStyle->Thick]

ParametricPlot[c[t],{t,0,2Pi}, PlotStyle->Thick, ColorFunction->Function[{x,y,t},Hue[t]]]

ParametricPlot[c[t],{t,0,2Pi}, PlotStyle->Thick, ColorFunction->Function[{x,y,t},Hue[x]]]

Použití předdefinovaných barevných schémat (obarvení podle souřadnice z):

Plot3D[((x^2)+3 (y^2)) (E^(1-(x^2)-(y^2))),{x,-2,2},{y,-2.5,2.5},ColorFunction->Function[{x,y,z},ColorData["SunsetColors"][z]], BoxRatios->Automatic]

Zkrácený zápis (viz dokumentaci ke ColorFunction).

Plot3D[((x^2)+3 (y^2)) (E^(1-(x^2)-(y^2))),{x,-2,2},{y,-2.5,2.5},ColorFunction->"SunsetColors", BoxRatios->Automatic]

Příklad použití ColorFunction v kombinaci s ContourPlot:

ContourPlot[((x^2)+3 (y^2)) (E^(1-(x^2)-(y^2))),{x,-2,2},{y,-2.5,2.5},ColorFunction->ColorData["Temperature"]]

Obarvení parametrizované křivky podle rychlosti

Příklad k ilustraci Keplerových pohybových zákonů:

soln=X[t]/.First[NDSolve[{X''[t]==-((X[t])/((Norm[X[t]])^3)),X[0]=={0.5,0},X'[0]=={0,1}},X[t],{t,0,2 π}]]

ParametricPlot[soln,{t,0,2 π}, PlotStyle->Thick]

speed[t_]=Norm[D[soln,t]]

Plot[speed[t],{t,0,2Pi}, PlotStyle->Thick]

max=Maximize[{speed[t],0≤t≤2Pi},t]//First

min=Minimize[{speed[t],0≤t≤2Pi},t]//First

normalizedSpeed[t_]=(speed[t]-min)/(max-min);

Plot[normalizedSpeed[t],{t,0,2Pi}, PlotStyle->Thick]

ParametricPlot[soln,{t,0,2 π}, PlotStyle->Thick, ColorFunction->Function[{x,y,t},blueToRed[normalizedSpeed[t]]], ColorFunctionScaling->False]

GraphicsComplex a 3D grafika

GraphicsComplex

GraphicsComplex slouží k úsporné reprezentaci rovinných i prostorových grafických objektů. Umožňuje zadat souřadnice bodů a později se na ně odvolávat pouze uvedením pořadového čísla bodu.

g=GraphicsComplex[{{0,0,0},{2,0,0},{2,2,0},{0,2,0},{1,1,2}},{PointSize[Large],Point[{1,2,3,4,5}],Polygon[{{1,2,5},{2,3,5},{3,4,5},{4,1,5},{1,2,3,4}}]}];

Graphics3D[g,Boxed->False,ImageSize->Small]

Ekvivalentní reprezentaci bez GraphicsComplex lze získat pomocí Normal:

Normal[g]

Mnoho funkcí v Mathematice vrací grafiku reprezentovanou jakou GraphicsComplex.

cPlot=ContourPlot[x^3+y^3==3x*y,{x,-3,3},{y,-3,3}]

Výsledkem je GraphicsComplex:

InputForm[cPlot]

Chceme-li seznam bodů tvořících křivku, použijeme Normal:

g=Normal[First[cPlot]]

pts=g[[1,3,1,2,1]];

Graphics[{Darker@Blue,Point[pts]},Axes->True]

VertexColors

Volba VertexColors umožňuje zadávat barvy vrcholů v Polygon, Line, Tube, Point nebo GraphicsComplex. Uvnitř útvaru se barvy interpolují.

Graphics[Polygon[{{-1,0},{1,0},{0,Sqrt[3]}},VertexColors->{Red,Green,Blue}],ImageSize->Small]

Graphics[{Thick,Line[{{0,0},{2,1}},VertexColors->{Red,Green}]}]

Každý vrchol může mít přiřazenu také průhlednost (Opacity).

Graphics3D[{GraphicsComplex[{{0,0,0},{2,0,0},{2,2,0},{0,2,0},{1,1,2}},Polygon[{{1,2,5},{2,3,5},{3,4,5},{4,1,5},{1,2,3,4}}],VertexColors->{Red,Green,Yellow,Blue,Opacity[.8,White]}]},
Lighting->"Neutral",Boxed->False]

Světla

Volba Lighting specifikuje světla, která budou použita k nasvícení trojrozměrné scény.

Options[Graphics3D]

Lighting->Automatic znamená, že k osvětlení scény se použijí tři barevná světla (červené, modré a zelené).

Graphics3D[{White,Sphere[]}]

Lépe to vynikne na lesklém povrchu:

Graphics3D[{GrayLevel[.25],Specularity[White,10],Sphere[]}]

Lighting->"Neutral" použije bílá světla.

Graphics3D[{White,Sphere[]},Lighting->"Neutral"]

Srovnání Automatic vs. "Neutral" pro žlutou kouli:

Graphics3D[{Yellow,Sphere[]}]

Graphics3D[{Yellow,Sphere[]},Lighting->"Neutral"]

Lighting->{(Subscript[s, 1]),(Subscript[s, 2]),...,(Subscript[s, n])} znamená, že bude použito n světelných zdrojů. U každého zdroje můžeme zadat typ zdroje, jeho umístění a barvu.

Jeden bodový zdroj:

Graphics3D[{Sphere[{0,0,0}],Sphere[{3,0,0}],Sphere[{0,3,0}],Sphere[{3,3,0}]},Lighting->{{"Point",Green,{2,2,2}}},Boxed->False,Axes->True,AxesLabel->{x,y,z}]

Pozor: Světlo prochází tělesy.

Graphics3D[{Sphere[{0,0,0}],Sphere[{3,0,0}],Sphere[{6,0,0}]},Lighting->{{"Point",Green,{9,0,0}}}]

Tři bodové zdroje:

Graphics3D[Sphere[],Lighting->{{"Point",Red,{2,0,0}},{"Point",Green,{0,-2,0}},{"Point",Blue,{0,0,2}}}]

Zdroj rovnoběžného světla (umístěn v nekonečnu, paprsky mají směr vektoru spojujícího zadané dva body):

Graphics3D[Sphere[],Lighting->{{"Directional",Green,{{1,0,0},{0,0,0}}}}]

Reflektor (kuželový zdroj s osou spojující zadané dva body a zadaným úhlem mezi osou a pláštěm kužele):

Graphics3D[{White,Sphere[]},Lighting->{{"Spot",Yellow,{{0,0,1.5},{0,0,0}},Pi/6}}]

Manipulate[Graphics3D[{White,Sphere[]},Lighting->{{"Spot",Yellow,{{0,0,h},{0,0,0}},α}}],{{α,Pi/6},0,Pi/2},{h,1.5,4}]

Světlo přicházející ze všech směrů:

Graphics3D[Sphere[],Lighting->{{"Ambient",Green}}]

Lesklá tělesa (Specularity)

Matná tělesa (obvykle tělesa s drsnějším povrchem) odrážejí dopadající světlo do všech směrů (tzv. difúzní odraz). Intenzita odraženého světla v libovolném bodě je úměrná cos α, kde α je velikost úhlu mezi dopadajícím paprskem a normálou k povrchu (je-li úhel větší než π/2, pak je intenzita nulová). Intenzita nezávisí na tom, odkud daný bod pozorujeme.

Graphics3D[{Blue,Sphere[]},Boxed->False,Lighting->{{"Directional",White,{{0,0,1},{0,0,0}}}},ImageSize->Small]

Od lesklých (hladkých) těles se světlo odráží podle zákona odrazu, na povrchu tělesa jsou vidět odlesky světel. Pro každé těleso lze specifikovat lesklou složku odraženého světla, která se přidává k difúzní složce.

Graphics3D[{Specularity[White,30],Blue,Sphere[]},Boxed->False,Lighting->{{"Directional",White,{{0,0,1},{0,0,0}}}},ImageSize->Small]

Syntaxe: Specularity[c,n].

c je barva, jejíž RGB složky se násobí RGB složkami dopadajícího světla. Odlesky proto mohou mít jinou barvu, než má samotný povrch tělesa.

Table[Graphics3D[{Black,Specularity[c,10],Sphere[]},Lighting->"Neutral"],{c,{Red,Green,Blue}}]

n je koeficient ostrosti: Intenzita odraženého světla ve směru, který svírá s ideálním odraženým paprskem úhel α, je úměrná (cos^n)α (Phongův model). Koeficient vyjadřuje ostrost zrcadlového odrazu, s většími hodnotami se odlesky stávají menšími a ostřejšími.

Manipulate[Plot[Cos[α °]^n,{α,0,90},PlotRange->{0,1}],{n,1,500,Appearance->"Labeled"}]

Příklady s různými koeficienty ostrosti:

Grid[Map[Table[Graphics3D[{Specularity[White,n],#,Sphere[]},Boxed->False,PlotLabel->n,Lighting->{{"Directional",White,{{0,0,1},{0,0,0}}}}],{n,{1,3,5,7,10,20,50}}]&,{Orange,Lighter[Blue],Darker[Red]}],Spacings->{-.5,-3}]

Lighting a Specularity fungují také ve spojení s Plot3D, ParametricPlot3D, ContourPlot3D atd.

Plot3D[((x y ((x^2)-(y^2)))/((x^2)+(y^2))),{x,-2,2},{y,-2,2},Boxed->False]

Plot3D[((x y ((x^2)-(y^2)))/((x^2)+(y^2))),{x,-2,2},{y,-2,2},Boxed->False,PlotStyle->{Lighter[Blue],Specularity[White,30]},Lighting->"Neutral"]

Při použití FaceForm[direktiva1,direktiva2] může každá strana plochy vypadat jinak.

Plot3D[((x y ((x^2)-(y^2)))/((x^2)+(y^2))),{x,-2,2},{y,-2,2},Boxed->False,PlotStyle->{FaceForm[Orange,Lighter[Blue]],Specularity[White,30]},Lighting->"Neutral"]

ContourPlot3D[x^2y^2+x^2z^2+z^2y^2==1,{x,-2,2},{y,-2,2},{z,-2,2},Axes->None,Mesh->False,Boxed->False,PlotPoints->40,ContourStyle->{FaceForm[Lighter[Blue],Orange],Specularity[White,30]}]

Mapování textury na plochu

img=;

Plot3D[Sin[x],{x,0,2 π},{y,-2,2},PlotStyle->Texture[img],Lighting->"Neutral",Mesh->False]

ParametricPlot3D[{Cos[u] (3+Cos[v]),Sin[u] (3+Cos[v]),Sin[v]},{u,0,2 π},{v,0,2 π},TextureCoordinateFunction->({2#4,#5}&),PlotStyle->Directive[Specularity[White,50],Texture[img]],Axes->False,Lighting->"Neutral",Mesh->None,Boxed->False]

ExampleData a Stanford Bunny

Ukázkové 3D modely v databázi ExampleData:

ExampleData["Geometry3D"]

Stanford Bunny je trojrozměrný model populární v 3D počítačové grafice. Vznikl v roce 1994 na Stanford University nasnímáním keramické figurky králíka pomocí 3D skeneru. Počítačový model se skládá z 69 451 trojúhelníků.

The Stanford 3D Scanning Repository,
http://graphics.stanford.edu/data/3Dscanrep/.

bunny=ExampleData[{"Geometry3D","StanfordBunny"}]

ExampleData[{"Geometry3D","StanfordBunny"},"PolygonCount"]

bunny[[1]]

Graphics3D[Prepend[bunny[[1]],RGBColor[0.66,0.33,0]],Lighting->{{"Directional",White,{{0,-1,0},{0,0,0}}}},Boxed->False]

Graphics3D[Join[{RGBColor[0.66,0.33,0],Specularity[White,100]},bunny[[1]]],Lighting->{{"Directional",White,{{0,-1,0},{0,0,0}}}},Boxed->False]

Variace na CowParade

cow=ExampleData[{"Geometry3D","Cow"}]

cow[[1]]

ExampleData[{"Geometry3D","Cow"},"PolygonCount"]

Obarvíme vrcholy trojúhelníků podle jejich x-ové souřadnice (použitím obarvovacích funkcí z ColorData) a nastavíme lesklý povrch:

Table[Image[Graphics3D[{EdgeForm[],Append[cow[[1,2]],VertexColors->Map[{Specularity[White,30],ColorData[colorfn][#[[1]]+.5]}&,cow[[1,2,1]]]]},Lighting->"Neutral",Boxed->False,Background->GrayLevel[.15],PlotLabel->Style[colorfn,White,FontFamily->"Arial"],ImageSize->150]],{colorfn,ColorData["Gradients"]}]

Další ukázky 3D grafiky

Decocube

Vytvořil Jeff Bryant, viz Scientific Visualization and Graphics with Mathematica, http://members.wri.com/jeffb/visualization/.

c=0.8;
ContourPlot3D[(((((x^2)+(y^2)-(c^2)))^2)+((((z^2)-1))^2)) (((((y^2)+(z^2)-(c^2)))^2)+((((x^2)-1))^2)) (((((z^2)+(x^2)-(c^2)))^2)+((((y^2)-1))^2)),{x,-1.5,1.5},{y,-1.5,1.5},{z,-1.5,1.5},Contours->{0.1},ContourStyle->{White,Specularity[White,50]},ViewVertical->{0,1,0},Boxed->False,Axes->False,ImageSize->400,Background->Black,Lighting->{{"Directional",RGBColor[0.5,0.5,1],ImageScaled[{0,1,0}]},{"Directional",RGBColor[1,0.5,0.5],ImageScaled[{1,-1,0}]},{"Directional",RGBColor[0.5,1,0.5],ImageScaled[{-1,-1,0}]}},SphericalRegion->True,Mesh->False,PlotPoints->50]

A Stylized Klein Bottle

First, we define the necessary functions to describe the surface.

bx=6*Cos[u]*(1+Sin[u]);
by=16*Sin[u];
rad=4*(1-Cos[u]/2);
X=If[π<u≤2 π,bx+rad*Cos[v+Pi],bx+rad*Cos[u]*Cos[v]];
Y=If[π<u≤2 π,by,by+rad*Sin[u]*Cos[v]];
Z=rad*Sin[v];

Next, we define the opacity value to be used for the "holes".

o=.2;

Then, we define the colors to be used for the surface which alternates between transparent-blue, and gray.

col1=Blue;
col2=Gray;

We define 3 light sources.

darklights={{"Directional",RGBColor[0.5, 0.5, 1],ImageScaled[{0, 1, 0}]}, 
     {"Directional",RGBColor[1, 0.5, 0.5],ImageScaled[{1, -1, 0}]}, {"Directional",RGBColor[0.5, 1, 0.5],ImageScaled[{-1, -1, 0}]}};

Now we create the graphic.

ParametricPlot3D[{X,Y,Z},{u,0,2*Pi},{v,0,2*Pi},PlotPoints->{48,12},Axes->False,Boxed->False,Mesh->59,MeshShading->{{{col1,Opacity[o],Specularity[White,128]},{col1,Opacity[o],Specularity[White,128]},{col2,Specularity[White,128]}},{{col1,Opacity[o],Specularity[White,128]},{col1,Opacity[o],Specularity[White,128]},{col2,Specularity[White,128]}},{{col1,Opacity[o],Specularity[White,128]},{col1,Opacity[o],Specularity[White,128]},{col2,Specularity[White,128]}},{{col2,Specularity[White,128]},{col2,Specularity[White,128]},{col2,Specularity[White,128]}}},MeshStyle->GrayLevel[.3],ImageSize->{640,500},MeshFunctions->{#4&,#5&},Background->Black,Lighting->darklights,SphericalRegion->True,ViewAngle->π/12]

Twisted Architecture

Vytvořil Christopher Carlson, viz Wolfram Blog

Bonus: Příklad na závěr

Věta: Má-li diferencovatelná funkce jedné reálné proměnné jedno lokální maximum (minimum) a žádné další stacionární body, pak jde o globální maximum (minimum).
Důkaz: Jednoduchá aplikace Rolleovy věty.

Pro funkce více proměnných analogická věta neplatí!

f[x_,y_]:=3 x (E^y)-(x^3)-(E^(3 y))

Reduce[{D[f[x,y],x]==0,D[f[x,y],y]==0},{x,y},Reals]

Plot3D[f[x,y],{x,-3,2.1},{y,-5,1},
         MeshFunctions->(#3&),Mesh->{Range[-3,2.8,0.2]},MeshShading->{Pink,White},
	PlotPoints->80,PlotRange->{-3,2.8},ClippingStyle->None]