https://community.wolfram.com RSS Feed for Wolfram Community showing ideas tagged with Augmented and Virtual Realities sorted by active. https://community.wolfram.com/groups/-/m/t/3503134 ![Helping hand to Africa:prosthetic hand's kinetic movement & force-closure grasping analysis][1] &[Wolfram Notebook][2] [1]: https://community.wolfram.com//c/portal/getImageAttachment?filename=Screenshot2025-07-10at4.09.36%E2%80%AFPM.png&userId=3501263 [2]: https://www.wolframcloud.com/obj/b1e5f73f-31a2-405b-96fa-122564a24619 Eunchan Hwang 2025-07-10T22:07:54Z https://community.wolfram.com/groups/-/m/t/2292400 TL/DR Use Unity 2019.4.29f1 with Wolfram 12.3 unityLink Hello all. This will probably turn out to be a mistake, but I thought I'd post whatever nuggets I discover trying to get Wolfram and Unity to play nice. So far, here's what I know. Mathematica 12.3. I've been struggling with this for over a week now, and I could not get UnityLink to work in a stable fashion unless I rolled back to Unity 2019.4.28 f1. Now that I've done that, I'm back to having fun in Wolfram with Unity. I'm enclosing the "Spikey" Notebook for you to try yourselves, but if you get it to compile all the way to the end, you're in a good place ce with your setup. AFIK. &[Wolfram Notebook][1] [1]: https://www.wolframcloud.com/obj/3180afd1-447d-4abe-92f5-28dc604c4f4e duncan shepherd 2021-06-17T20:27:06Z https://community.wolfram.com/groups/-/m/t/2166965 Hi everyone! I made a website that uses Wolfram's client library for python in order to make 3D models of an inputted equation and view them in AR! Check it out here: https://devpost.com/software/3d-ar-grapher Does anyone have any suggestions or improvements I could make? Richard Sbaschnig 2021-01-18T22:10:17Z https://community.wolfram.com/groups/-/m/t/2143320 ![Figure 2][5] ![Figure 3][6] Since we have historical conjunction of Jupiter and Saturn I have prepared code with visualization planet Jupiter and Saturn with moons. First code also published [here][3]. Visualization of planet Jupiter: JSP = QuantityMagnitude[ UnitConvert[ PlanetaryMoonData[{"Io", "Europa", "Ganymede", "Callisto"}, {"OrbitPeriod", "SemimajorAxis", "Radius"}], "SI"] /. q : Quantity[_, "Days" | "Hours"] :> UnitConvert[q, "Seconds"]]; a = Pi*RandomReal[{0, 2}, Length[JSP]]; b = 31557600* QuantityMagnitude[Entity["Planet", "Jupiter"]["OrbitPeriod"]]* Table[1/JSP[[i, 1]], {i, 1, 4}]; R = Table[JSP[[i, 2]], {i, 1, 4}]; c = Table[JSP[[i, 3]], {i, 1, 4}]; k = 3; radius = QuantityMagnitude[ Entity["Planet", "Jupiter"]["EquatorialRadius"], "Kilometers"]; radius1 = QuantityMagnitude[Entity["Planet", "Jupiter"]["PolarRadius"], "Kilometers"]; Xoblateness = Entity["Planet", "Jupiter"]["Oblateness"]; Xobliquity = Entity["Planet", "Jupiter"]["Obliquity"]; distanse = QuantityMagnitude[ Entity["Planet", "Jupiter"]["AverageOrbitDistance"], "Kilometers"]; angularvelocity = Entity["Planet", "Jupiter"]["EquatorialAngularVelocity"]; texture = ImageReflect[ EntityValue[Entity["Planet", "Jupiter"], "CylindricalEquidistantTexture"], Bottom]; planet = ParametricPlot3D[{radius Cos[t] Sin[p], radius Sin[t] Sin[p], (1 - Xoblateness) radius Cos[p]}, {t, 0, 2 Pi}, {p, 0, \[Pi]}, Mesh -> None, PlotStyle -> Texture[texture], Lighting -> "Neutral", Boxed -> False, Axes -> False, PlotPoints -> 100] Visualization of travelling orbit (we solve restricted 3 body problem) M1 = QuantityMagnitude[Entity["Planet", "Jupiter"]["Mass"]]; M2 = QuantityMagnitude[Entity["Star", "Sun"]["Mass"]]; Ra = QuantityMagnitude[ Entity["Planet", "Jupiter"]["EquatorialRadius"]]*10^3; S = QuantityMagnitude[Entity["Planet", "Jupiter"]["SemimajorAxis"]]; ar = Ra/(S*149597870700); m = M1/M2; G = 6.67384*10^(-11); vS = Sqrt[G*M1/Ra]; u0 = 16000; {ux, uy, uz} = {0.28309789428056364`, -2.269693660804425`, 0.24765897137821516`}; tm = 2*0.007188414157797473; {x0, y0, z0} = {0.9987450742768228`, -0.00006988474848081634`, \ -0.000015444353758731164`}; eq = {x''[t] == 2*y'[t] + x[t] - ( m (-1 + m + x[t]))/((-1 + m + x[t])^2 + y[t]^2 + z[t]^2)^( 3/2) - ((1 - m) (m + x[t]))/((m + x[t])^2 + y[t]^2 + z[t]^2)^( 3/2), y''[t] == -2*x'[t] + y[t] - ( m y[t])/((-1 + m + x[t])^2 + y[t]^2 + z[t]^2)^( 3/2) - ((1 - m) y[t])/((m + x[t])^2 + y[t]^2 + z[t]^2)^(3/2), z''[t] == -((m z[t])/((-1 + m + x[t])^2 + y[t]^2 + z[t]^2)^( 3/2)) - ((1 - m) z[t])/((m + x[t])^2 + y[t]^2 + z[t]^2)^(3/2), x[0.] == x0, y[0.] == y0, x'[0.] == ux, y'[0.] == uy, z'[0.] == uz, z[0.] == z0}; {xfun, yfun, zfun} = NDSolveValue[eq, {x, y, z}, {t, 0, tm}]; rt = RotationTransform[Xobliquity, {1, 0, 0}]; V = rt[S*149597870.700*{xfun[t] - 1 + m, yfun[t], zfun[t]}]; {Orbit = ParametricPlot3D[V, {t, 0, tm}], Plot[Norm[V], {t, 0, tm}]} Show[{Graphics3D[Orbit[[1]], Boxed -> False], planet}] We have this picture with Jupiter and orbit around ![Figure 1][4] Now we combine orbit, planet and moons in one scene, and export it as a gif (or animate). Th = tm*31557600* QuantityMagnitude[ Entity["Planet", "Jupiter"]["OrbitPeriod"]]/(3600)/(2*Pi); frames = Table[ Show[{Graphics3D[ Rotate[planet[[1]], 2*Pi*Th*t/9.841666666666667/tm, {0, 0, 1}], Boxed -> False, Axes -> False, ImageSize -> .25 {1920, 1080}], Table[Graphics3D[{White, Sphere[{R[[i]]*Cos[a[[i]] + b[[i]]*t], R[[i]]*Sin[a[[i]] + b1[[i]]*t], 0}, k*c[[i]]]}, Background -> Black, Boxed -> False, PlotRange -> All], {i, 1, 4}]}, Background -> Black, SphericalRegion -> True, ViewAngle -> Pi/4, PlotRange -> All, Lighting -> {{"Ambient", GrayLevel[0.05]}, {"Point", White, {20 radius, 0, 0}}}, ViewVector -> {V, {0, 0, 0}}], {t, 0, (1 - .0025)*tm, .0025*tm}]; Export["C:\\...\\Jupiter.gif", frames, AnimationRepetitions -> Infinity] ![Figure 2][5] Second code with visualization of Saturn and moons "Mimas", "Enceladus", "Tethys", "Dione", "Rhea", "Titan" is differ from above since we need to show rings and also orbit around Saturn is not like orbit around Jupiter. The code is in notebook attached. And animation looks like this one ![Figure 3][6] [1]: https://community.wolfram.com//c/portal/getImageAttachment?filename=ezgif-7-e64479f927ce.gif&userId=20103 [2]: https://community.wolfram.com//c/portal/getImageAttachment?filename=ezgif-7-b5d492aca470.gif&userId=20103 [3]: https://mathematica.stackexchange.com/questions/236843/travelling-around-jupiter?noredirect=1#comment598213_236843 [4]: https://community.wolfram.com//c/portal/getImageAttachment?filename=JupiterOrbit.jpg&userId=1218692 [5]: https://community.wolfram.com//c/portal/getImageAttachment?filename=JupiterMF4.gif&userId=1218692 [6]: https://community.wolfram.com//c/portal/getImageAttachment?filename=SaturnFM5.gif&userId=1218692 Alexander Trounev 2020-12-20T22:28:26Z https://community.wolfram.com/groups/-/m/t/2097827 **[View this post in Wolfram Cloud Notebook format][1]** Viewing events in 3d on node level to compare the past and future generations of the Wolfram models ======================================================================== We created a new feature to the gigabrain.io physics 3d explorer. It features a comparison between final generations of the current, previous and future generation >![Wolfram model 6721 progress][2]<br> **[Video animation of 6721 progress in 50 generations][3]**<br> [Click to see model 6721 generation 8 comparison in 3d][4] >![Wolfram model 44586 progress][5]<br> **[Video animation of 44586 progress in 100 generations][6]**<br> [Click to see model 44586 generation 1 comparison in 3d][7] Color code explanations in the 3d viewer of the generation comparison --------------------------------------------------------------------- The 3d viewer's node colors are coded as following: - Red = Node is found only in previous generation - Light red = Node is found in previous and current but not the next generation - Blue Magenta = Node is found in all 3 previous, current and next generation - Light green = Node is found in current and next but not the previous generation - Green = Node is found only in next generation Wolfram model final states as image list ---------------------------------------- Below is a comparison of the event states in Wolfram SetReplace project. Here we use the Wolfram Model wm3147. Let's compare the images with the final states using the StatesPlotsList. ResourceFunction["WolframModel"][{{{1, 1, 2}, {3, 4, 5}} -> {{3, 3, 6}, {1, 3, 2}, {7, 1, 3}, {7, 8, 2}}}, {{1, 1, 1}, {1, 1, 1}}, 4 ][ "StatesPlotsList",VertexLabels -> Automatic, ImageSize -> 100] ![Generations output][8] Comparing generations in 3d viewer ---------------------------------- **[Click to See model 3147 generation 3 comparison in 3d viewer][9]** To compare the generation 3 with the 3d viewer we can use the link below and we get the image below. In the user interface you can change the mode by clicking on the mode button. Default mode is for a single graph the next mode is the generation comparison and the third mode is to download the graph as a OBJ 3d file. ![3d Generation comparison][10] In this graph the Current generation is 3 and previous is 2 and next is 4. For reference the generations are below. Magenta Nodes 1, 2 and 3 are found in generations 2, 3 and 4. Light red Node 4 is not in the generation 4 but can be found in 3 and 2. Light green Nodes 5, 6 and 7 are created in current generation and also present in next generation. Green Nodes 8, 9, 10, 11, 12 and 13 are found only in generation 4. ![Generations 2 3 4][11] **[Click to See model 3147 generation 4 comparison in 3d viewer][12]** When changing the view to the next generation 4 we get the image below. ![3d Generation comparison 2][13] In this graph the current generation is 4 and previous is 3 and next is 5 . For reference the generations are below. Magenta Nodes 1, 2, 3, 5, 6 are found in generations 3, 4 and 5. Light red Node 7 is not in the generation 5 but can be found in 4 and 3. Light green Nodes 8,9,10,11,12,13 are created in current generation 4 and also present in next generation 5. Green Nodes 14,15,16,17,18,19 are found only in the next generation 5. ![Generations 3 4 5][14] The final generation comparison does not take account the single events that produce the final states. We can see a full comparison of the events that produced the states with the EventsStatesPlotsList. The documentation says about the graphs: Here the dotted gray edges are the ones about to be deleted, whereas the red ones have just been created. ResourceFunction["WolframModel"][{{{1, 1, 2}, {3, 4, 5}} -> {{3, 3, 6}, {1, 3, 2}, {7, 1, 3}, {7, 8, 2}}}, {{1, 1, 1}, {1, 1, 1}}, 4 ][ "EventsStatesPlotsList",VertexLabels -> Automatic, ImageSize -> 100] ![Event states][15] Events to produce the generation 3. Nodes with red lines are created. ![Event State 1][16] Events to produce the generation 4. Here we see the removal of the node 4 with two dotted gray lines. ![Event State 2][17] Events to produce the generation 5. Here we see the removal of the node 7 with two dotted gray lines. ![Event State 3][18] Conclusion ========== As a conclusion this shows that the comparison of the final generations can visually show in what areas the new nodes are created and in what areas the nodes are being deleted. But it does not show the full event graph of how the events are produced. Problems ======== - The viewer does not show events differently that have first removed a node and later on added the node again in the same generation. It only compares the differences of the final generations. - Currently the 3d viewer does not handle all types of Wolfram models, like single-element models wm161, model with multiple rules wm4486 - The model calculation is done by Javascript and does not use Wolfram language. By the cause of this the rule choosing is not available in the 3d viewer and the resulting event numbering might differ. - We use the name Wolfram model as defined in SetReplace Project: "A more interesting case (which we call a Wolfram model) is one where the set elements are related to each other. Specifically, we can consider a set of ordered lists of atomic vertices; in other words, an ordered hypergraph. " Although the implementation is made currently with Javascript's own implementation and not the SetReplace package. References ======== - Wolfram Model Explorer: Zoli Kahan, [https://community.wolfram.com/groups/-/m/t/1985729][19] [https://github.com/Zolmeister/wolfram-model-explorer][20] - SetReplace: Max Piskunov, [https://github.com/maxitg/SetReplace/][21] [PlotsOfEvents][22] - Registry of Notable Universe Models: [https://www.wolframphysics.org/universes/wm3147/][23] [1]: https://www.wolframcloud.com/obj/tuomas0/Published/Compare_Generations_in_3d_wm3147.nb [2]: https://community.wolfram.com//c/portal/getImageAttachment?filename=wm6721Animation50generations.gif&userId=2053745 [3]: https://gigabrain.s3-eu-west-1.amazonaws.com/physics/wm6721+Animation+50+generations.mp4 [4]: http://gigabrain.io/physics/index.html?rule=%7B%7B%7B1,1,2%7D,%7B3,2,4%7D%7D-%3E%7B%7B5,5,3%7D,%7B3,1,5%7D,%7B4,2,4%7D%7D%7D&init=%7B%7B1,1,1%7D,%7B1,1,1%7D%7D&steps=8&modelId=556&modeType=1 [5]: https://community.wolfram.com//c/portal/getImageAttachment?filename=44586generation100animation.gif&userId=2053745 [6]: https://gigabrain.s3-eu-west-1.amazonaws.com/physics/wm44586+Animation+100+generations.mp4 [7]: http://gigabrain.io/physics/index.html?rule=%7B%7B%7B1,2,3%7D,%7B4,2,5%7D%7D-%3E%7B%7B6,3,1%7D,%7B3,6,4%7D,%7B1,2,6%7D%7D%7D&init=%7B%7B1,1,1%7D,%7B1,1,1%7D%7D&steps=1&modelId=335&modeType=1 [8]: https://community.wolfram.com//c/portal/getImageAttachment?filename=Generationsout1.png&userId=2053745 [9]: http://gigabrain.io/physics/index.html?rule=%7B%7B%7B1,1,2%7D,%7B3,4,5%7D%7D-%3E%7B%7B3,3,6%7D,%7B1,3,2%7D,%7B7,1,3%7D,%7B7,8,2%7D%7D%7D&init=%7B%7B1,1,1%7D,%7B1,1,1%7D%7D&steps=3&modelId=193&modeType=1 [10]: https://community.wolfram.com//c/portal/getImageAttachment?filename=gigabrainGeneration3comparison.png&userId=2053745 [11]: https://community.wolfram.com//c/portal/getImageAttachment?filename=Generations1.png&userId=2053745 [12]: http://gigabrain.io/physics/index.html?rule=%7B%7B%7B1,1,2%7D,%7B3,4,5%7D%7D-%3E%7B%7B3,3,6%7D,%7B1,3,2%7D,%7B7,1,3%7D,%7B7,8,2%7D%7D%7D&init=%7B%7B1,1,1%7D,%7B1,1,1%7D%7D&steps=4&modelId=193&modeType=1 [13]: https://community.wolfram.com//c/portal/getImageAttachment?filename=gigabrainGeneration4comparison.png&userId=2053745 [14]: https://community.wolfram.com//c/portal/getImageAttachment?filename=Generations2.png&userId=2053745 [15]: https://community.wolfram.com//c/portal/getImageAttachment?filename=Eventsout1.png&userId=2053745 [16]: https://community.wolfram.com//c/portal/getImageAttachment?filename=Eventsout2.png&userId=2053745 [17]: https://community.wolfram.com//c/portal/getImageAttachment?filename=Eventsout3.png&userId=2053745 [18]: https://community.wolfram.com//c/portal/getImageAttachment?filename=Eventsout4.png&userId=2053745 [19]: https://community.wolfram.com/groups/-/m/t/1985729 [20]: https://github.com/Zolmeister/wolfram-model-explorer [21]: https://github.com/maxitg/SetReplace/ [22]: https://github.com/maxitg/SetReplace/blob/master/Documentation/SymbolsAndFunctions/WolframModelAndWolframModelEvolutionObject/Properties/PlotsOfEvents.md "PlotsOfEvents" [23]: https://www.wolframphysics.org/universes/wm3147/ Tuomas Sorakivi 2020-10-19T08:07:04Z https://community.wolfram.com/groups/-/m/t/1810945 [![Cover Image][1]](https://community.wolfram.com//c/portal/getImageAttachment?filename=diamond_denoised.png&userId=93201) Couple of days ago, in Wolfram's Wechat group there was a pleasant discussion about Tim's neat post [**Ray-tracing Graphics3D with UnityLink**]( https://community.wolfram.com/groups/-/m/t/1801300). I then promised a walkthrough on how to work with [*LuxCoreRender*](http://www.luxcorerender.org/). I think it would be nice to share my experience not only in the Wechat group but also here to the Community. LuxCoreRender is a cross-platform render engine published under GPLv3 license. It provides nice features and both Python and C++ APIs. According to [the official site](https://luxcorerender.org/goals/), it's a *physically correct, unbiased* rendering engine. Usually LuxCoreRender can be accessed as a plugin in many popular 3D tools such as Blender, but in this post I'll talk about the way more suitable for scripting from Mathematica's side. First of all, let's set our working directory. ``` SetDirectory[NotebookDirectory[]]; ``` ## Import and Export LuxCoreRender SDL files Readers can safely skip this section. We'll just dump our import and export functions for the LuxCoreRender SDL files here. Please use them with caution. Though I have tested them with some examples, edge cases can bite. ``` ClearAll[branch] branch = Through@*{##} & ; ``` ``` ClearAll[luxcoreReaderInternalStep, luxcoreReader] luxcoreReaderInternalStep[e : {__List}] := e // RightComposition[ Map[If[Length[#] == 1, #[[1]], #] &], GroupBy[ListQ], If[KeyExistsQ[#, True], # // MapAt[GroupBy[First -> Rest] /* Map[luxcoreReaderInternalStep], Key[True]], #] &, If[KeyExistsQ[#, False], # // MapAt[Apply[Sequence], Key[False]], #] &, Values, Switch[#, {_Association}, #[[1]], _, # ] & ] luxcoreReader = Module[{numReader = ImportString[#, "Table"][[1, 1]] &}, RightComposition[ StringReplace[(StartOfLine ~~ {Whitespace, "#" ~~ Except["\n"] ...} ... ~~ "\n") .. :> ""], StringTrim, StringSplitNested[#, {"\n", Whitespace ~~ "=" ~~ Whitespace}] &, MapAt[StringTrim, {;; , ;;}], MapAt[StringSplit[#, "."] &, {;; , 1}], Map[Flatten], luxcoreReaderInternalStep, Map[Last, #, {-2}] &, Map[ Switch[#, _?(StringMatchQ["\"" ~~ ___ ~~ "\""]) , StringTake[#, {2, -2}], _?(Not@*StringFreeQ[Whitespace]) , StringSplit[#, Whitespace] // Map[#0], _?(StringMatchQ[{DigitCharacter, ".", "+", "-", "e"} ..]), numReader@#, _, # ] & , #, {-1}] & ] ]; ``` ``` ClearAll[luxcoreWriter] luxcoreWriter = Module[{ keychainCombiner = Cases[Key[key_] :> key] /* (Riffle[#, "."] &), stringifier = ExportString[#, "RawJSON", "Compact" -> 0] & }, RightComposition[ MapIndexed[Sow[{##}] &, #, {-1}] &, Reap, #[[2, 1]] & , {#, Range[Length@#]}\[Transpose] & , GroupBy[IntegerQ[#[[1, 2, -1]]] &] ,(* atomic values: *) MapAt[ MapAt[Apply[{#1 // stringifier, #2 // keychainCombiner} & /* Apply[StringJoin[#2, " = ", #1] &]], {;; , 1}] , Key[False]] ,(* numerical arrays: *) If[# // KeyExistsQ[True] , # // MapAt[ RightComposition[ MapAt[Apply[{#2 // Most, {Last[#2], #1}} &], {;; , 1}] , GroupBy[(#[[1, 1]] &) -> ({#[[1, 2]], #[[2]]} &)] , Map@branch[ (#[[;; , 1, 2]] &) /* stringifier /* (StringReplace[{"," -> " ", "[" | "]" :> ""}]) , #[[1, 2]] & ] , KeyMap[keychainCombiner] , KeyValueMap[{StringJoin[#1, " = ", #2[[1]]], #2[[2]]} &] ] , Key[True]] , #] & , Values, Apply@Join, SortBy[Last], #[[;; , 1]] & , Riffle[#, "\n"] &, StringJoin ] ]; ``` ## Anchor the world Before any rendering happens, a scene is necessary. The center of our scene is going to be the origin of our "world" coordinate system. ``` stageCenter = {0, 0, 0}; ``` ## Lighting ### Spotlight On a stage, the most indispensable thing is lighting. Among all the lights, nothing attracts more attention than a spotlight. To project a spotlight onto the stage, we need to determine its position, aiming target, color, size, etc. (Reference: `"Spot"` in documentation of [`Lighting`](http://reference.wolfram.com/language/ref/Lighting.html) ) ``` spotLightPos = {4.5, 0, 6}; Clear[spotLight] spotLight := <|"type" -> "spot" , "position" -> spotLightPos, "target" -> stageCenter , "color" -> RGBColor[1, 1, 1], "power" -> 100, "efficency" -> 17, "gain" -> {1, 1, 1} , "coneangle" -> 14 \[Degree] (* <- half angle of the cone *) , "conedeltaangle" -> 1 \[Degree] |> // Function[cfg , cfg // RightComposition @@ MapThread[ If[KeyExistsQ[cfg, #2], MapAt[##], Identity] & , { {"color" , List @@ ColorConvert[#, "RGB"] &} , {"transformation", TransformationMatrix /* Transpose /* Flatten} , {"coneangle" , N[#]/Degree &} , {"conedeltaangle", N[#]/Degree &} }\[Transpose] // Reverse] ] ``` For more detail about lighting in LuxCoreRender, please refer to the [official wiki](https://wiki.luxcorerender.org/Lighting) and [document page](https://wiki.luxcorerender.org/LuxCore_SDL_Reference_Manual_v2.2#Light_sources). ## Camera Rendering is like taking a photo, you carefully set up your camera, adjust the aperture and focal distance, and look for the the best angle of view. We set up a camera aiming at the stage from an angle somewhat perpendicular to the light and focusing on the center. With this setting, we hope to capture a rich shades of light and shadow. ### Perspective Camera ``` cameraPos = {7., -7., 5.}; cameraTarget = stageCenter + {-.2, 0, -.3}; cameraAimingAxis = cameraTarget - cameraPos; cameraFocus = stageCenter; ``` `cameraUpVecF[` $\theta$`,cameraAimingAxis]` will be used to adjust the orientation of our film. Setting $\theta$ to $0^\circ$ and $90^\circ$ correspond to landscape and portrait. ``` Clear[cameraUpVecF] cameraUpVecF = Function[{\[Theta], aimingAxis}, aimingAxis // RightComposition[ RotationTransform[90 \[Degree], {aimingAxis, {0, 0, 1}}] , RotationTransform[\[Theta], aimingAxis] , Developer`FromPackedArray (* <- Currently our luxcoreWriter cannot handle PackedArray correctly *) ]]; ``` ``` Clear[camera] camera := <| "type" -> "perspective" (* (* use the default clipping *) ,"cliphither" -> 0 (* <- Working like minimum distance in M's ViewRange *) ,"clipyon" -> \[Infinity] (* <- Working like maximum distance in M's ViewRange *) *) , "lookat" -> <|"orig" -> cameraPos, "target" -> cameraTarget|> , "up" -> cameraUpVecF[0 \[Degree], cameraAimingAxis] , "fieldofview" -> 25 \[Degree] (* <- Working like M's ViewAngle *) , "lensradius" -> 0.1 (* <- Set a positive value to enable blurring by depth-of-field, 0 to disable it. *) , "focaldistance" -> Norm[cameraFocus - cameraPos] |> // Function[cfg , cfg // RightComposition @@ MapThread[If[KeyExistsQ[cfg, #2], MapAt[##], Identity] &, { (* clip-range must be positive real number in luxcore renderer: *) {"cliphither" , Clip[#, {.001, 1. 10^30}] &} , {"clipyon" , Clip[#, {.001, 1. 10^30}] &} , {"fieldofview" , N[#]/Degree &} }\[Transpose] // Reverse] ] ``` For more detail about camera, please refer to the [official wiki](https://wiki.luxcorerender.org/LuxCoreRender_Cameras) and [document page](https://wiki.luxcorerender.org/LuxCore_SDL_Reference_Manual_v2.2#Camera). ## Object In LuxCoreRender, solid objects can be represented by meshes and materials. The easiest way to introduce mesh is through the [PLY format](http://reference.wolfram.com/language/ref/format/PLY.html). It's well-supported both in LuxCoreRender and in Mathematica. ### Stage plane We have been talking a lot about stage, but we haven't really got a stage yet. We are goint to forge a minimalist one with a square plane. ``` stage = Polygon[Append[0] /@ CirclePoints[{5, \[Pi]/4}, 4]] // TranslationTransform[{0, 0, -1.7}]; stageMesh = stage // DiscretizeRegion // Export["stage_plane.ply", #, "PLY", "BinaryFormat" -> True] &; ``` We use LuxCoreRender's built-in Lambertian material to style our stage, with a neural gray diffuse color. ``` stageMaterial = <|"type" -> "matte", "kd" -> {0.5, 0.5, 0.5}|>; ``` The full configuration is ``` stageConfig = <| "objects" -> <|"stage_plane" -> <|"ply" -> stageMesh, "material" -> "stage_mat"|>|> , "materials" -> <|"stage_mat" -> stageMaterial |> |>; ``` ### Main Role Now everything on the stage is ready except for the star. We are going to put a diamond at the center. [TruncatedPolyhedron](http://reference.wolfram.com/language/ref/TruncatedPolyhedron.html) is a handy function to cut a gem. With some additional positioning, in two lines we have our diamond mesh ready. ``` gem = Fold[TruncatedPolyhedron, Octahedron[], ConstantArray[.3, 2]] // ScalingTransform[1.3 {1, 1, 1}] // RotationTransform[-10 Degree, {0, 0, 1}]; gem // Graphics3D[#, Boxed -> False] & gemMesh = gem // DiscretizeGraphics // RegionBoundary // Export["gem.ply", #, "PLY", "BinaryFormat" -> True] &; ``` ![gem mesh as Graphics3D][2] Recall our camera is focusing on stage center, now we would like to adjust it to focus on the top facet of the diamond. ``` gemBd = gem // BoundaryDiscretizeGraphics; facetID = gemBd // {MeshCellIndex[#, 2], PropertyValue[{#, 2}, MeshCellCentroid]}\[Transpose] & // MaximalBy[#[[2, -1]] &] // #[[1, 1]] &; ``` Or, more specifically, on one of the facet's corners nearest to our camera. Because we used delayed definition (reference: [`SetDelayed`](http://reference.wolfram.com/language/ref/SetDelayed.html)), our `camera` will be automatically up-to-date everytime we query it. ``` cameraFocus = MeshPrimitives[gemBd, facetID][[1]] // MinimalBy[Norm[# - cameraPos] &] // First; Graphics3D[{gem, {Red, Sphere[cameraFocus, .05]}} , ViewVector -> Values[camera["lookat"]] , Boxed -> False] ``` ![gem mesh, highlight the focus-on point][3] To emulate a real diamond, we need LuxCoreRender's built-in "glass" material with refractive index of diamond. ``` gemIOR = Entity["Mineral", "Diamond"]@EntityProperty["Mineral", "RefractiveIndices"] // First (* Out[]= 2.418 *) ``` For the dispersion, [LuxCoreRender uses Cauchy's empirical formula](https://wiki.luxcorerender.org/LuxCore_SDL_Reference_Manual_v2.2#Type:_glass). We'll set it to a very high value. (For details about the formula, please refer to http://scienceworld.wolfram.com/physics/CauchysFormula.html .) ``` gemDispersion = 0.02; gemMaterial = <| "type" -> "glass" , "kr" -> {1, 1, 1} (* <- reflected color *) , "kt" -> {1, 1, 1} (* <- transmited color *) , "interiorior" -> gemIOR (* <- refractive index *) , "cauchyc" -> gemDispersion (* <- coefficient of \[Lambda]^-2 term in Cauchy's dispersion formula *) |>; ``` The full configuration is ``` gemConfig = <| "objects" -> <|"gem" -> <|"ply" -> gemMesh, "material" -> "gem_mat"|>|> , "materials" -> <|"gem_mat" -> gemMaterial |> |>; ``` ## The Whole Scene Combining all the lights, camera and objects together, we have a full specification of our scene. ``` sceneConfig = <|"scene" -> Join[ <| "camera" -> camera , "lights" -> <|"spot_light_1" -> spotLight|> |> , Merge[{stageConfig, gemConfig}, Apply@Join] ]|>; ``` We use our exporter `luxcoreWriter` to format the scene configuration to match LuxCoreRender's scn DSL specification. ``` sceneFile = sceneConfig // luxcoreWriter // Export["diamond.scn", #, "String"] & (* Out[]= diamond.scn *) ``` ## Render Our post is already lengthy so I'm not going into details about the render configuration here. Just to point out that our importer/exporter can handle both scene describing file (.scn) and render configuration file (.cfg). Another thing worth reminding readers not familiar with rendering is the choice of render strategy. As in this case we would like to see nice caustic from the diamond, **"BIDIRCPU"** engine coupled with **"METROPOLIS"** sampling is our best choice. We may talk about other methods in the future. ``` renderConfig = <| "scene" -> <|"file" -> sceneFile |> , "renderengine" -> <|"type" -> "BIDIRCPU" |> , "sampler" -> <|"type" -> "METROPOLIS"|> , "light" -> <|"maxdepth" -> 20 |> , "path" -> <|"maxdepth" -> 20 |> , "batch" -> <|"haltspp" -> 2000 |> , "film" -> <| "width" -> 1920, "height" -> 1080 , "filter" -> <|"type" -> "NONE"|> , "imagepipelines" -> <| "0" -> <| "0" -> <|"type" -> "TONEMAP_AUTOLINEAR" |> , "1" -> <|"type" -> "GAMMA_CORRECTION", "value" -> 2.5`|> |> , "1" -> <| "0" -> <|"type" -> "INTEL_OIDN" |> , "1" -> <|"type" -> "TONEMAP_AUTOLINEAR" |> , "2" -> <|"type" -> "GAMMA_CORRECTION", "value" -> 2.5`|> |> |> , "outputs" -> <| "0" -> <|"index" -> 0, "type" -> "RGB_IMAGEPIPELINE", "filename" -> "diamond_original.png"|> , "1" -> <|"index" -> 1, "type" -> "RGB_IMAGEPIPELINE", "filename" -> "diamond_denoised.png"|> |> |> |>; renderCfgFile = renderConfig // luxcoreWriter // Export["diamond.cfg", #, "String"] & ``` We can import the configuration file and browse it with [`Dataset`](http://reference.wolfram.com/language/ref/Dataset.html) as easy. ``` Import[renderCfgFile, "String"] // StringTrim // luxcoreReader // Dataset ``` ![rendering configuration][4] To start rendering, we use the portable **LuxCoreRender Standalone release v2.2** from https://luxcorerender.org/download/ . (The one I used is *Python 3.7 and Windows 64bit with OpenCL support*). After extracting you'll find two executables *pyluxcoretool* and *luxcoreui*. You can either start the renderer from console by executing (from our working directory, which is `Directory[]`) pyluxcoretool console diamond.cfg or by loading the .cfg file through **Rendering » Load** menu in *luxcoreui* (which has a simple GUI). To be lazy and stay in Mathematica, on Windows you can invoke the console as following. (Please remember to change the `luxbin` to your actual path.) ```` luxbin = "path\\to\\your\\pyluxcoretool.exe"; luxPS = StartProcess[{$SystemShell, "/C", StringTemplate[ "start /I /WAIT cmd /C \"\"`bin`\" console \"`cfg`\"\""][<| "bin" -> luxbin, "cfg" -> renderCfgFile |>] }] ```` When the render process finishes, we shall find the results under our current working directory with filenames according to `renderConfig[["film","outputs",;;,"filename"]]`. We have set the render halt condition to 2000 samples (`renderConfig[["batch","haltspp"]]`). For this scene it will take almost 1 hour on a computer with Intel Core i7-8750H CPU. ("BIDIRCPU" engine does most job on CPU.) For quick preview rendering, you can set it to smaller values (e.g. 20). Smaller `renderConfig[["film",{"width","height"}]]` will also reduce the computing time (with smaller resulting images). Additionally, you can always break the render process anytime (on Windows press **Ctrl + C** in cmd, or click the **Rendering » Pause** menu in *luxcoreui*). The intermediate result will be saved to disk for the console mode, or can be manually saved from **Film » Save outputs** menu in *luxcoreui*. ## Epilog Hopefully you have got a beautiful photo of the diamond like our cover image. So far we have demonstrated in Mathematica how to setup a simple scene and render it with LuxCoreRender. We have plans to talk about more advanced topics (like HDRI, volume, how to generate smooth mesh, etc.) in the fufuture. ## References - [Visualization: Advanced 3D Graphics](https://www.wolfram.com/training/videos/GEN422/) - [Extract values for ViewMatrix from a Graphics3D](https://mathematica.stackexchange.com/questions/3528/extract-values-for-viewmatrix-from-a-graphics3d) - [LuxCore SDL Reference Manual v2.2](https://wiki.luxcorerender.org/LuxCore_SDL_Reference_Manual_v2.2) - [LuxCoreRender User's Manual](https://wiki.luxcorerender.org/LuxCoreRender_User%27s_Manual) - [LuxCore test scenes project](https://github.com/LuxCoreRender/LuxCoreTestScenes) ## Bounus - Click the cover image to get the full sized version! - Find the Notebook for this post below! [1]: https://community.wolfram.com//c/portal/getImageAttachment?filename=diamond_denoised_small.png&userId=93201 [2]: https://community.wolfram.com//c/portal/getImageAttachment?filename=gem_mesh.png&userId=93201 [3]: https://community.wolfram.com//c/portal/getImageAttachment?filename=gem_mesh_with_focus_point.png&userId=93201 [4]: https://community.wolfram.com//c/portal/getImageAttachment?filename=render_cfg.png&userId=93201 Silvia Hao 2019-10-22T15:49:06Z https://community.wolfram.com/groups/-/m/t/1801300 [![Rotating stage][13]][14] Here is an example of a basic rendered scene by calling Unity from Mathematica. Of course, a lot of work can be required to make it pretty. Needs["UnityLink`"]; UnityOpen["SphereLighting"]; CreateUnityAssetDirectory[{"Scenes", "Meshes", "Materials"}]; CreateUnityScene[File["Scenes/SphereLight"]]; boxwalls = {CreateUnityPlane["Box_bottom", Properties -> {"Position" -> {0, 0, 0}, "LocalScale" -> {1, 1, 1}, "EulerAngles" -> {0, 0, 0}}], CreateUnityPlane["Box_top", Properties -> {"Position" -> {0, 10, 0}, "LocalScale" -> {1, 1, 1}, "EulerAngles" -> {0, 0, 0}}], CreateUnityPlane["Box_left", Properties -> {"Position" -> {-5, 5, 0}, "LocalScale" -> {1, 1, 1}, "EulerAngles" -> {0, 0, 90}}], CreateUnityPlane["Box_right", Properties -> {"Position" -> {5, 5, 0}, "LocalScale" -> {1, 1, 1}, "EulerAngles" -> {0, 0, 90}}], CreateUnityPlane["Box_back", Properties -> {"Position" -> {0, 5, 5}, "LocalScale" -> {1, 1, 1}, "EulerAngles" -> {90, 0, 0}}]}; hexToRGB = RGBColor @@ (IntegerDigits[#~StringDrop~1~FromDigits~16, 256, 3]/ 255.) &; boxmat = CreateUnityMaterial[File["Materials/Mat_box"], Properties -> {"Color" -> hexToRGB["#F9F9F9"], "_Glossiness" -> 0.0}]; SetProperty[#, "SharedMaterial" -> boxmat] & /@ boxwalls; sphere = CreateUnityGameObject["sphere", Graphics3D[Sphere[{0, 0, 0}]], Properties -> {"Position" -> {0, 1, 2}}]; spheremat = CreateUnityMaterial[File["Materials/Mat_sphere"], Properties -> {"Color" -> hexToRGB["#F9F9F9"], "_Glossiness" -> 0.75}]; SetProperty[sphere, "SharedMaterial" -> spheremat]; UnityCameraImage[] positions = {{5, 1, 0}, {0, 1, 5}, {-5, 1, 0}, {0, 1, -5}, {0, 10, 0}}; angles = {{0, 270, 0}, {0, 180, 0}, {0, 90, 0}, {0, 0, 0}, {90, 0, 0}}; camera = CreateUnityCamera["Test Camera"]; go = camera[["GameObject"]]; views = Table[go[["Position"]] = positions[[i]]; go[["EulerAngles"]] = angles[[i]]; UnityCameraImage[camera, ImageResolution -> 800, ImageSize -> 300], {i, Length[positions]}]; DeleteUnityGameObject[go] ListAnimate[views] [![Glossy Sphere In Unity][1]][2] # Update to Include Material Shading Variations From the OP's comment, they would like to see shading like metallics and crystals. Ideally, one would use a Principled Based Shader to achieve this result. It looks like the standard offering through Unity is rather basic, but literally, there are hundreds of commercial offerings to create realistic materials. In the standard shader, there was no Index of Refraction _IOR_ setting, so the best you can get is transparency. Here is an example of three materials from left to right of a metallic, transparent, and a diffuse material. I also added a Reflection Probe, but I had to manually bake the scene to see the effect. Needs["UnityLink`"]; UnityOpen["SphereLighting"]; CreateUnityAssetDirectory[{"Scenes", "Meshes", "Materials"}]; CreateUnityScene[File["Scenes/SphereLight"]]; boxwalls = {CreateUnityPlane["Box_bottom", Properties -> {"Position" -> {0, 0, 0}, "LocalScale" -> {1, 1, 1}, "EulerAngles" -> {0, 0, 0}}], CreateUnityPlane["Box_top", Properties -> {"Position" -> {0, 10, 0}, "LocalScale" -> {1, 1, 1}, "EulerAngles" -> {0, 0, 180}}], CreateUnityPlane["Box_left", Properties -> {"Position" -> {-5, 5, 0}, "LocalScale" -> {1, 1, 1}, "EulerAngles" -> {0, 0, -90}}], CreateUnityPlane["Box_right", Properties -> {"Position" -> {5, 5, 0}, "LocalScale" -> {1, 1, 1}, "EulerAngles" -> {0, 0, 90}}], CreateUnityPlane["Box_back", Properties -> {"Position" -> {0, 5, 5}, "LocalScale" -> {1, 1, 1}, "EulerAngles" -> {-90, 0, 0}}]}; hexToRGB = RGBColor @@ (IntegerDigits[#~StringDrop~1~FromDigits~16, 256, 3]/ 255.) &; boxmat = CreateUnityMaterial[File["Materials/Mat_box"], Properties -> {"Color" -> hexToRGB["#F9F9F9"], "_Glossiness" -> 0.0}]; SetProperty[#, "SharedMaterial" -> boxmat] & /@ boxwalls; sphere1 = CreateUnityGameObject["sphere1", Graphics3D[Sphere[{0, 0, 0}]], Properties -> {"Position" -> {2.25, 1, 2}}]; sphere1mat = CreateUnityMaterial[File["Materials/Mat_sphere1"], Properties -> {"Color" -> hexToRGB["#27EC86"], "_Glossiness" -> 0.75}]; SetProperty[sphere1, "SharedMaterial" -> sphere1mat]; sphere2 = CreateUnityGameObject["sphere2", Graphics3D[Sphere[{0, 0, 0}]], Properties -> {"Position" -> {0, 1, 2}}]; sphere2mat = CreateUnityMaterial[File["Materials/Mat_sphere2"], Properties -> {"RenderQueue" -> 3000, "Color" -> RGBColor[0.830726683139801, 0.8980392217636108, 0.33333340287208557, 0.4156862795352936], "_Glossiness" -> 1, "_GlossMapScale" -> 0.8, "_Metallic" -> 0.1, "ShaderKeywords" -> {"_ALPHAPREMULTIPLY_ON", "_SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A"}, "_Mode" -> 3, "_DstBlend" -> 10, "_ZWrite" -> 1.}]; SetProperty[sphere2, "SharedMaterial" -> sphere2mat]; CreateUnityReflectionProbe[sphere2]; sphere3 = CreateUnityGameObject["sphere3", Graphics3D[Sphere[{0, 0, 0}]], Properties -> {"Position" -> {-2.25, 1, 2}}]; sphere3mat = CreateUnityMaterial[File["Materials/Mat_sphere3"], Properties -> {"Color" -> RGBColor[1, 1, 1], "_Glossiness" -> 1, "_Metallic" -> 1}]; SetProperty[sphere3, "SharedMaterial" -> sphere3mat]; CreateUnityReflectionProbe[sphere3]; camera = FindUnityComponent["Main Camera"]; camera[["Position"]] = {-0.9, 3, -6.3}; UnityCameraImage[] positions = {{5, 1, 0}, {0, 1, 5}, {-5, 1, 0}, {0, 1, -5}, {0, 10, 0}}; angles = {{0, 270, 0}, {0, 180, 0}, {0, 90, 0}, {0, 0, 0}, {90, 0, 0}}; camera = CreateUnityCamera["Test Camera"]; go = camera[["GameObject"]]; views = Table[go[["Position"]] = positions[[i]]; go[["EulerAngles"]] = angles[[i]]; UnityCameraImage[camera, ImageResolution -> 800, ImageSize -> 300], {i, Length[positions]}]; DeleteUnityGameObject[go] ListAnimate[views] [![Unbaked spheres][3]][4] After manually baking the Reflection Probes I re-displayed the camera with the following: camera = FindUnityComponent["Main Camera"]; camera[["Position"]] = {-0.9, 3, -6.3}; UnityCameraImage[] positions = {{5, 1, 0}, {0, 1, 5}, {-5, 1, 0}, {0, 1, -5}, {0, 10, 0}}; angles = {{0, 270, 0}, {0, 180, 0}, {0, 90, 0}, {0, 0, 0}, {90, 0, 0}}; camera = CreateUnityCamera["Test Camera"]; go = camera[["GameObject"]]; views = Table[go[["Position"]] = positions[[i]]; go[["EulerAngles"]] = angles[[i]]; UnityCameraImage[camera, ImageResolution -> 800, ImageSize -> 300], {i, Length[positions]}]; DeleteUnityGameObject[go] ListAnimate[views] [![Baked spheres][5]][6] I installed the free version of Lux from the Asset Store, but it appears that a lot of the functionality could not be installed due to licensing claims. I have not experimented with any other shaders so I have no opinion. ## Previous Rigid Body Simulation in Blender Answer I answered a question about flipping a coin [here](https://community.wolfram.com/groups/-/m/t/1803725) where I interfaced _Mathematica_ to _Blender_. _Blender_ has a Principled shader in its distribution that has _IOR_ and other settings that should allow you to create a more realistic scene without needing to find a commercial option. [![Blender Principled Shader Interface][7]][8] # Update #2: Blender 2.79b Implementation I am very new to the Unity universe and could use a good recommendation for principled shaders. In lieu of finding a good Unity shader, I threw together a simple implementation in Blender to utilize its shader from _Mathematica_. To use this implementation, you will need to install Blender 2.79b and make sure that it is in your path. ## Use [`StringTemplate`](https://reference.wolfram.com/language/ref/StringTemplate.html)to Create Blender Python Script Blender has a fairly complete Python API and there are many examples that you can grab from the web. I created a module the generates a Blender python script that will use the photorealistic Cycles renderer to display a _Mathematica_ object that has been saved as STL. I used [`Compress`](https://reference.wolfram.com/language/ref/Compress.html) to try to preserve the important space delimited formatting of the python code that tends to get garbled here when trying to copy a python code within MMA code. I also created 2 functions to render either sharp (like a crystal) or smooth objects (like a heart). The following will produce Blender code and execute it in the background. Depending on your hardware, you may need to adjust the render settings. I am using Windows, but I think it should work on other platforms. Because _Mathematica_ and _Blender_ need to share files, I thought the most straightforward approach was to use the NotebookDirectory. This implies that following code needs to be executed from a previously saved notebook. blenderworkflow[mmaobj_, frames_: 1] := Module[{pre, imgset, nbd, glassRenderScript, file, fileName, outputfile, stext, files, imgs}, nbd = NotebookDirectory[]; pre = StringTemplate[ Uncompress[ "1:eJydVl1v2zYU7Wv/\ Bes9yAYKTnKbrCvghyZNtgFLE8TFiiI1XEqiLC4UaZBUUv/B/a7eS+qztZO1RhCJvPee+\ 3GOTT5L9fXyv6dPnohqq40j6Xb3KU7mhdEV2TJXSpGSxnQFy85WwaI1GJYLpizavF0bool\ QiEVz5hjV6b88c/Y1Wgl8REE0dbstJ4sFiS7Oln9GBIP6vbOLq/\ cfoy4AP5paLgGGLMh7U/PWxKXlh/\ zOGRjbsn4hb2HfccKkJE1FWKUrObEZV94RS9Zb21RMcx8xnfUYSw79cpVzQ7jaCMWJ0yTb\ ZZJbfKstJ5U2HHyYFNaJDCfFjYBKWvxMK8e/OOqT0gBGGzBo/\ fTj6d9ny6hPd8Ky243RtcrJqZbaoOVeG5mDdzdiv2Fvog/4jFadD4WK1krnUF4/\ t4CdlQyTbnACUPYdkzV45Rr+saLACeJomvp88RvACKiIuHaGc/8GefsiQ/\ J0Q4Xa1s7exCsYY8Fq6dY+xc3rFyvAmcY0jo+PX72c//acxDRJ4uP4d3ybz4+\ PXr2YjUGSb0AAIKHxkNoCx3caiEiZ5fl48OAiigLpMTzPhS1JITVoblkyaO8dNHFi86Lxw\ QBwO0ePd6zCbJPrZj0ZGocMdOmo4vfTYfhsGLKXEKNQrp1LN93GptCoXJh1sxcWPhd+\ axbRuJN/uLzjLvKp71LYCBDqJgoWcrJ8ex6oghF3xoumCXJZOxh8tGoJiJa1KVjGQ4gGK8\ R4YKq9K2qgg8T6pFC3oT6AeE7Qq6+mg/WKjr5nF+QxP0I5xHHzAJkkgy/ih1I4/odk1g/\ kvlu1fPX2ydjhMGdjkNk4bC9v9xtP3MBrRB2akTt89uT53YPEeZjAWyDGu/\ 8oM01QaDjwso8nX9ghogLGpMeYrB6nLQGWwt+jGNe63pSKQ7ff4wDhR4/F/3V5vScyoS+\ PepW8IbYUakcq7pjELf8y0sgF7vQa8cvDGuniZ+OI/\ fKoUB4Dp7E6qkYd1Ugd1UPquDJCZWIreT6SSPUzEglBPeJDOqke0skhoDa7712KbB9b/\ wvgYaUk49M5FwbOLm12eB4r7Xiq9W2/G24oEg/whb/STKPPKgXz52jw6/Imz/\ 3p5w8JH6IazaT6C7UuCKa9LYR70LritkTbtBCS4+VpYZ2ZNsl+\ JR5i5pOwzIk7fukvGY3W2ltBMK3DBYSQb71be6vKwbGBrl8BJ79PMw=="]][<| "nbdir" -> StringReplace[nbd, "\\" -> "\\\\"]|>]; imgset = StringTemplate[ Uncompress[ "1:eJyFVNtuGjEQzVv/\ onK3DywVcoAEmkbiIYqStFKSotJUlSjamPUArhbvyjYhqOq/\ d8beJUtoUwTClzNnzlw8b6b5l9HrVwcHb9kIHLsWy4INTV6AcQrsj3anm9HRgE2LDZfCCU\ 57O24QsjGpANxtCkBUNLq7jbaHKwuJziVYvPlqVuAvtNO49fd0lzgD4Fe2uh43LpbKWpXr\ xoQrXawc+hshTs/\ dAo8kzMQqc8mDyFbktNvzlvn0Z10nbiFFy4iURpMKwrM8FQ65ERsftzqtfnN7ZXLnrxJYZ\ WAI0Ob9XqvN271et/O+1eEn/\ f7Rh463oF9IGgqTCLfgnNJzHwapSHPt4NFxm4IGnm7SDCxqf1ApiW5cDe8af4cGPu5UBsk\ jQjvdk/8DNy8BS+cWM5H5avSC/\ n8iqXJCq6VwIBMLIGsVDIGfSckk6FxZjPlFeZnYgLHj9qROvjXdI/\ 6mYM3Osox9DgWs8pzhhpWlZ6lYghF0NRMpRc47tMHjegsEFLbAuV+\ EJrBOGIfBzTMqA0K4X5fmvLqowQ7RR73iXknZXswthGNrhXqnUHYCSC8sNwRiSrP91JTWp\ wRk+KHus4F4wC5FZuEFigdM3BRL/\ pxEzZjOHYuJbKEksGDu10mQ1tyC97zWq0De8sKiJ1gfyTKPicsTOkiCCci4uZO0nZw95et\ SacmWYBfhgYcV+\ htTZM8irD9cCocE0mQZDKKbi9HHUMBAe24Am5MJT83mJl8VdeWBhMOycJtESBl7msbw+\ uzTbXL2/WLUaLFqEgzidovRt+kDqvzvz5JK/9zQRNwOmAtyErSVt1xjxmgc3uD+\ irRFT8qHAmvhypRg67jFsxhqSQmgnTYpgvmAlb5CT0ORpPnKn9/\ PDHq395VHoiMA8RksDlC4TxZPLVFNvSqI3XG4gxp3Jwg0QiqhbezZ37G4c4Kjkh3Wybej0\ jfokp57hCNf2EXy67R9LH/zQs8jjhpx1niiZoUujNIunuUZ9u0hmu5QbUvj3xMWYUT/\ 0aQaOjOciYXA1FJXmucsFQN1SmkQ/mK2NspBYnGmZgN6Eswb/AFsMV/A"]][<| "frames" -> frames|>]; DeleteFile@FileNames["_trash_*.png"]; glassRenderScript = pre <> mmaobj <> imgset; fileName = "glassrender.py"; file = OpenWrite[fileName]; WriteString[file, glassRenderScript]; Close[file]; outputfile = CreateFile[]; Run["blender --background --python glassrender.py >>" <> outputfile]; stext = OpenRead[outputfile]; Close[stext]; DeleteFile[outputfile]; files = FileNames["_trash_*.png", nbdir]; imgs = Import[#] & /@ files; imgs ] (* Bounding Box Related Info *) bb[r_] := Module[{c, min, max, ext, temp}, c = Mean@Transpose@RegionBounds@r; temp = Transpose@RegionBounds@r; min = temp[[1]]; max = temp[[2]]; ext = (Differences@Transpose@RegionBounds@r)[[1]]; {c, min, max, ext}] (* Use this function for MMA objects with sharp edges *) impMMAobj[s_, mat_: "whiteGlass"] := StringTemplate[ Uncompress[ "1:eJxdjk0OgjAQhXuUETewqT97DuDKBLcm0NYhlLRM006M3tBjSSG4cPcy3/\ teZqepuX2EEHu4+ECRgQeEjvQ4KY/d/\ Xg69zlBDcXvKhO7IiMd3pJCknZRW49pyKzsrcOgeKgTx7In98AIB1iGqiqLyrB94lWPaHi\ ezjuGJsYXyxW1tLL/8oa9YoxWuVnutrx8+wWRckmI"]][<|"objname" -> s, "material" -> mat|>] (* Use this function for additional smoothing applied in Blender *) impMMAobjsmooth[s_, mat_: "whiteGlass"] := StringTemplate[ Uncompress[ "1:eJxdjz0OwjAMRnsUU5Z2CT97D8CEBCtSmrauEpTUUWIhODK3oElVhNgsv+\ 99ljcdXa7voii2cHKeAgNrhJa6+\ 6Qctrf94TimCRoov1sR2ZYJdf4lyEdhsiodRp1YNRqLXrFuIodqJDtggB3korr+\ FedG7FlErQaU0RGxrnJA9WweeM54vp3yPU2MTxYLkosK/+\ EVO8UYjLKz3K5zfucD6o9VhQ=="]][<|"objname" -> s, "material" -> mat|>] (* Directory Info *) nbdir = NotebookDirectory[]; SetDirectory@nbdir; I found an implicit function that creates a nice heart shaped region in the documentation. The following code will discretize the region, create an appropriately sized stage, assign a white glass material to the object and render the image in Blender. (* Create Heart Shaped Region *) drheart = DiscretizeRegion[ ImplicitRegion[(x^2 + (9/4) y^2 + z^2 - 1)^3 - x^2 z^3 - (9/80) y^2 z^3 == 0, {x, y, z}], MaxCellMeasure -> 0.00005]; {c, min, max, ext} = bb[drheart]; (* Create a Stage *) box = Cuboid[{-Max[ext], -Max[ext], min[[3]] - ext[[3]]/10}, {Max[ext], Max[ext], min[[3]]}]; RegionPlot3D[{drheart, box}] (* Export MMA objects as STL *) Export["heart.stl", drheart]; Export["box.stl", box]; (* Render in Blender in the background *) (* Default material is white glass *) imgs = blenderworkflow[impMMAobjsmooth["heart"]]; First@imgs [![Glass Heart][9]][10] The following changes the material to a shiny white metal. (* Now render in white shiny metal *) imgs = blenderworkflow[impMMAobjsmooth["heart", "whiteMetal"]]; First@imgs [![Steel heart][11]][12] You can also create a rotating stage animation by setting the frame parameter to something other than 1, but this can take a while to render. (* Rotate the stage *) (* Will take a long time *) (* Default material is glass *) imgs = blenderworkflow[impMMAobjsmooth["heart"], 60]; First@imgs ListAnimate[imgs] [![Rotating stage][13]][14] Finally, for objects with sharp features, one should not use smoothing as it will round the corners. Here is an example with Spikey. (* Create a glass spikey *) poly = PolyhedronData["Spikey", "BoundaryMeshRegion"]; {c, min, max, ext} = bb[poly]; box = Cuboid[{-Max[ext], -Max[ext], min[[3]] - ext[[3]]/10}, {Max[ext], Max[ext], min[[3]]}]; Export["spikey.stl", poly]; Export["box.stl", box]; RegionPlot3D[{poly, box}] imgs = blenderworkflow[impMMAobj["spikey"]]; First@imgs [![Glass Spikey][15]][16] ---------- *The original version of this post can be found [HERE][17].* [1]: https://i.stack.imgur.com/6P2TD.png [2]: https://i.stack.imgur.com/6P2TD.png [3]: https://i.stack.imgur.com/pmC3X.png [4]: https://i.stack.imgur.com/pmC3X.png [5]: https://i.stack.imgur.com/TMySF.png [6]: https://i.stack.imgur.com/TMySF.png [7]: https://i.stack.imgur.com/rVKI3.png [8]: https://i.stack.imgur.com/rVKI3.png [9]: https://i.stack.imgur.com/znkw0.png [10]: https://i.stack.imgur.com/znkw0.png [11]: https://i.stack.imgur.com/5Zb3O.png [12]: https://i.stack.imgur.com/5Zb3O.png [13]: https://i.stack.imgur.com/MST7J.gif [14]: https://i.stack.imgur.com/MST7J.gif [15]: https://i.stack.imgur.com/SpCsy.png [16]: https://i.stack.imgur.com/SpCsy.png [17]: https://mathematica.stackexchange.com/a/202180 Tim Laska 2019-10-04T15:22:32Z https://community.wolfram.com/groups/-/m/t/1383237 #What is this project? This project is intended to let you experience the world how other people see and hear it. I Especially explore various auditory and visual impairments and simulate their effects. I hope this tool can go on to help friends and families understand what their loved ones are going through. Overall I set out to create an interactive display of different sensory deficiencies, and I believe in part I achieved my goal. Although I would like to add more things I got some of the most common/impactful ailments! I used two main sources to acquire my data http://www.roger-russell.com/hearing/hearing.htm https://www.sciencedirect.com/science/article/pii/S167229301150008X?via%3Dihub#bb0005 #What does it look like? Below are instances of the simulation as well as rough regressions I made to supplement ![Audio Distortion][1]![Visual Distortion][2] ![Female Regression][3]![Male Regression][4] #How did I Create this project? In order to simulate frequency loss I used Fourier transforms isolate and lower (by a certain percentage) the decibel level of ranges of frequencies. To add tinnitus I had to play around with different functions in the audio space but eventually I was able to simplify it and go on to apply it. The bulk of my code is below it is the code which implements the Fourier transform ``` AgeAlter[audio_, age_, gender_] := Module[{sampleRate, fromDezibel, amps, kernel, Data}, If[gender == "Male", Data = ApproximateAgeMale[age], Data = ApproximateAgeFemale[age]]; sampleRate = First@Values@Options[audio, SampleRate]; fromDezibel = x \[Function] Exp[-x/8.685889638065035`]; amps = MapAt[N@BlockMap[Mean, \[Pi] #/sampleRate, 2, 1] &, MapAt[fromDezibel, Transpose[Data], {2}], {1}]; kernel = LeastSquaresFilterKernel[amps, First@Values@Options[audio, SampleRate]]; e = AudioLoudness[ Audio[Map[channel \[Function] ListConvolve[kernel, channel], AudioData@audio], Sequence @@ Options[audio]]]; If[age < 0, "How Are you Alive???", If[age > 90, "You're either Dead or Deaf (Or you're hearing is far too \ negligible to simulate)", If[age <= 30, Grid[{{ListLinePlot[AudioLoudness[audio], PlotLabels -> "What you hear/would hear", PlotLabel -> "Decibel level of orignal and modified audio clips", LabelStyle -> {Black, Bold}, AxesLabel -> {"Seconds", "Decibels"}, ImageSize -> Large]}, {audio}}], Grid[{{ListLinePlot[{e, AudioLoudness[ AudioTrim[audio, (-1*(Duration[audio] * .88094189354))], Alignment -> Center]}, PlotLabels -> {"What you hear", "What you would hear"}, PlotLabel -> "Decibel level of original and modified audio clips", LabelStyle -> {Black, Bold}, AxesLabel -> {"Seconds", "Decibels"}, ImageSize -> Large]}, {Audio[ Map[channel \[Function] ListConvolve[kernel, channel], AudioData@audio], Sequence @@ Options[audio]]}}]]]]] ``` This code essentially takes in an audio file and corresponding age, it then transforms the audio into Fourier space and maps decimal lowering amounts across different frequency ranges. Since decibels use a logarithmic scale i often struggled dealing with different units and converting between them although a professor helped me work it out. Other than this the rest was not too difficult to implement, the visual aspects were just a simple blurring of the image and extracting different RGB values (using built in functions). #In the future in the future I intend to improve and grow this project, expanding its reach for many different deficiencies, both applying the auditory and visual senses and not applying. I also hope to use this project, as a demonstration, to help raise awareness for people afflicted with these ailments or if this project becomes solidified enough, to directly make an impact on those who need it. [1]: http://community.wolfram.com//c/portal/getImageAttachment?filename=4967AudioModel.png&userId=1372232 [2]: http://community.wolfram.com//c/portal/getImageAttachment?filename=10323VIsualModel.png&userId=1372232 [3]: http://community.wolfram.com//c/portal/getImageAttachment?filename=Female2.png&userId=1372232 [4]: http://community.wolfram.com//c/portal/getImageAttachment?filename=Male.png&userId=1372232 Sartaj Gulati 2018-07-13T20:53:52Z https://community.wolfram.com/groups/-/m/t/1379131 # Augmented and Virtual reality functions in Mathematica # ## Overture ## The goal of my project at Wolfram Summer School '18 was to implement VR and AR visualization features in the Wolfram Language. Conceptually, the underlying idea was to create two simple functions through which deploy in a VR or AR environment any 3D object created from Mathematica, spanning from a random solid (e.g. created using the [ConvexHullMesh][1] function): ConvexHullMesh[RandomReal[5, {50, 3}]] to a detailed view of 3D elevation data for a specific region: ListPlot3D[GeoElevationData[GeoDisk[Entity["City", {"Tivoli", "Lazio", "Italy"}], 4 Quantity[1, "Kilometers"]], GeoZoomLevel -> 12]] ## How ## The two functions ARDeploy and VRDeploy work in conjunction with the WebVR BoilerPlate platform and AR.js library, which provide the required JavaScript tools to manage the VR/AR environments. The objects representation is translated from Mathematica into a js compatible format by Three.js and Aframe.js libraries. In particular, VRDeploy enables to investigate abstract mathematical (and any 3D Mathematica models) representations in a new environment leading to a clearer and easier understanding of them. In combination with mobile devices, equipped with a headset, enables the user full immersion experience. ARDeploy, on the other side, enables the "on-screen" exploration of the same objects compatible in VRDeploy, attaching it to a marker which could be visualized in the Mathematica notebook. The great difference between the two functions relies on the way the 3D object is explored. The VRDeploy offers a static full immersive point of view while ARDeploy offers a dynamic exploration. These two functions (in form of Mathematica package) and all the required files can be downloaded at [https://github.com/DomenicoRomano/ARVRDeploy][2]. ## VRDeploy Example Code ## VRDeploy (as ARDeploy) works with any 3D surfaces from Plot3D or Example Data. In the example code below the 3D surface from [Plot3D][3] is translated in a VR object, VRDeploy returns a link to a webpage in which there is the WebVR environment with the Plot3D object visualised: VRDeploy[Plot3D[0.5 *Sin[0.4*x y], {x, -4, 4}, {y, -4, 4}, MaxRecursion -> 4]] Below a screenshot view of the webpage returned by VRDeploy as seen from mobile devices, this provides the full immersion experience. It is also possible to switch to normal view and then navigate the VR scene using the mobile device orientation hardware. ![Mobile device view of the full immersive experience][4] Below a view of the same webpage as above returned by VRDeploy as seen from a laptop/desktop computer: ![Web page visualizing the output of the above VRDeploy line of code][5] Another example is the VR visualization of the stars distribution around the Earth, using the [StarData][6] function. The following code extracts the position of the 35000 closest stars to our Sun, then converts the distances to parsec and VRDeploy them: VRDeploy[Graphics3D[ Sphere[QuantityMagnitude[ DeleteMissing[StarData[EntityClass["Star", List[Rule[EntityProperty["Star", "DistanceFromEarth"], TakeSmallest[35000]]]], "HelioCoordinates"]]/3.26], .05], { Axes -> {True, True, True}, AxesLabel -> {"pc", "pc", "pc"}, ImageSize -> Large}]] Resulting in the picture below: ![A full immersive view of the closest 35000 stars as seen from Earth, created with VRDeploy and the StarData function.][7] --- ##ARDeploy example## A simple example of ARDeploy function presented here use the Viking Lander model from the 3D Example data of Wolfram Mathematica, following is the code: ARDeploy[ExampleData[{"Geometry3D", "VikingLander"}]] The returned CloudObject is a link to a webpage, which can be easily converted to a QR code and scanned by mobile devices. BarcodeImage[ First[ARDeploy[ExampleData[{"Geometry3D", "VikingLander"}]]], "QR"] The webpage opened in the mobile device will ask "to allow the application to access the camera". After granting the access to the camera the mobile device will recognize the marker, plotting on it the ARDeployed object: ![The Viking Lander 3D model, taken from Mathematica Example data, visualized attached to a marker on a laptop screen.][8] ## Future Directions ## Next steps require to enrich the visualization experience with interactive capabilities, displaying specific information or changing the object properties. Another required step is the marker independent placement of the object, using absolute GPS coordinates. The required mobile hardware improvements will be soon available. It will be also interesting to offer a virtual reality Mathematica notebook in which the user could experience the advantages to learn in a full-immersive three-dimensional virtual world. [1]: http://reference.wolfram.com/language/ref/ConvexHullMesh.html [2]: https://github.com/DomenicoRomano/ARVRDeploy [3]: http://reference.wolfram.com/language/ref/Plot3D.html?q=Plot3D [4]: http://community.wolfram.com//c/portal/getImageAttachment?filename=IMG_0020.PNG&userId=1362723 [5]: http://community.wolfram.com//c/portal/getImageAttachment?filename=ScreenShot2018-07-10at21.47.34.png&userId=1362723 [6]: http://reference.wolfram.com/language/ref/StarData.html?q=StarData [7]: http://community.wolfram.com//c/portal/getImageAttachment?filename=ScreenShot2018-07-10at15.17.01.png&userId=1362723 [8]: http://community.wolfram.com//c/portal/getImageAttachment?filename=IMG_0012.jpg&userId=1362723 Romano Domenico 2018-07-11T18:57:54Z https://community.wolfram.com/groups/-/m/t/1369571 I recently came across a video that intended to show how neural networks interpret images of (not so beautiful) things if they have only been trained on beautiful things. It is quite a nice question, I think. [Here is a website describing the technique][1], and [here is a video that illustrates the idea][2]. In this post I will show you, how to generate similar effects easily with the Wolfram Language: ![enter image description here][3] and in video format: ![enter image description here][4] On the right you see the "interpretation" of a neural network that has been shown lots of photos of flowers, when it actually looks at a rubbish dump with a couple of birds sitting on the rubbish. Devising a plan ---------- We will need a training dataset and should hope to find a network in the [Wolfram Neural Net Repository][5] that more or less does what we want to do. If you have watched some of the [excellent training videos on neural nets][6] offered by Wolfram you will have noticed that the general suggestion is not to develop your own neural networks from scratch, but rather use what is already there and perhaps combine it, or adapt it so that you can achieve what you want. This is also very well described in this recent [blog-post by experts on the topic][7]. I am usually happy if I can use the work of others and do not have to re-invent the wheel. If you read the posts describing how to build a network that have only seen beautiful things, you will find that they used a variation of the pix2pix network and an implementation in tensorflow (a "conditional adversarial network"). If you go through the extensive list of networks that are offered on the Wolfram Neural Net Repository you will see that there are Pix2pix resources, e.g. ResourceObject["Pix2pix Photo-To-Street-Map Translation"] or net=ResourceObject["Pix2pix Street-Map-To-Photo Translation"] I will use the latter resource object, but that does not actually matter. Next, we will need to build a training set. Scraping data for the training set ---------- The next thing we need is a solid training set. My first attempt was to use ServiceConnect with the google search to obtain lots of images of flowers. googleCS = ServiceConnect["GoogleCustomSearch"] imgs = ServiceExecute["GoogleCustomSearch", "Search", {"Query" -> "Flowers", MaxItems -> 1000, "SearchType" -> "Image"}]; It turns out that the max of results returned is only 100, which is not enough for our purpose. I tried to fix this by using imgs2 = ServiceExecute["GoogleCustomSearch", "Search", {"Query" -> "Flowers", MaxItems -> 1000, "StartIndex" -> 101, "SearchType" -> "Image"}]; but that did not work. So WebImageSearch is the way to go. It does cost ServiceCredits, but the costs are relatively limited. Let's download information on 1000 images of flowers: imgswebsearch = WebImageSearch["Flowers", MaxItems -> 1000]; Export["~/Desktop/imglinks.mx", imgswebsearch] A WebImageSearch of up to 10 results costs 3 ServiceCredits. So this should be 300 credits. 500 credits can be bought for $3, and 5000 for $25 (+VAT). This would mean the generation of our training set comes in at maximally $1.8, which is manageable - particularly if we consider the price of the eGPU that we will use later on.... Just in case we export the result, because we paid for it and might have to recover it later if we suffer a kernel crash or something. Alright. Now we have a dataset that looks more or less like this: ![enter image description here][8] Great. That contains the "ImageHyperlink" which we will now use to download all the images: rawimgs = Import /@ ("ImageHyperlink" /. Normal[imgswebsearch]); Export["~/Desktop/rawimgs.mx", rawimgs] Again, we export the result (better safe than sorry!). Let's make the images conform: imagesconform = ConformImages[Select[rawimgs, ImageQ]]; By using Select[...,ImageQ] we make sure that we use only images; and not error messages of the cases where it didn't work. Generating a training set ---------- In the original posts they suggest that they used edges, i.e. EdgeDetect to generate partial information of the images, and then linked that to the full image like so: rules = ImageAdjust[EdgeDetect[ImageAdjust[#]]] -> # & /@ imagesconform; It turns out that my results with that were less than impressive so I went for a more time consuming approach that gave better results. I used Monitor[rulesnew = Table[Colorize[ClusteringComponents[rules[[i, 2]], 7]] -> rules[[i, 2]], {i, 1, Length[rules]}];, I] i.e. ClusteringComponents to generate a trainingset. Partial information on the images now looked like this: ![enter image description here][9] rather than ![enter image description here][10] when we use EdgeDetect. Our training data set now links the image with partial (CluseteringComponents) information via a rule to the original image. Basically, we give partial information of the world and train the network to see flowers. Just in case we export the data set like so: Export["~/Desktop/rulesnew.mx", rulesnew] Training the network ---------- If you want to train on the EdgeDetect version you can use: retrainednet = NetTrain[net, rules, TargetDevice -> "GPU", TrainingProgressReporting -> "Panel", TimeGoal -> Quantity[120, "Minutes"]] otherwise you can use retrainednet2 = NetTrain[net, rulesnew, TargetDevice -> "GPU", TrainingProgressReporting -> "Panel", TimeGoal -> Quantity[120, "Minutes"]] Note that I use a GPU and considerable training time (2h). On a CPU this would take quite a while. Here are typical results of the EdgeDetect network: retrainednet[EdgeDetect[CurrentImage[], 0.7]] ![enter image description here][11] and the ClusteringComponents one: ![enter image description here][12] We should not forget to export the network: Export["~/Desktop/teachnwnicethings2.wlnet", retrainednet2] More examples ---------- Let's look at the ClusteringComponents network a bit closer. We apply GraphicsRow[{ImageResize[#, {256, 256}], beautifulnet[Colorize[ClusteringComponents[#, 7]]]}] & to different images to obtain: ![enter image description here][13] Application to videos ---------- Suppose that I have the frames of a recorded movie stored in the variable movie1. Then load our network into the function beautifulnet beautifulnet = Import["/Users/thiel/Desktop/teachnwnicethings2.wlnet"] Then the following will generate frames for an animation: animation1 = GraphicsRow[{ImageResize[#, {256, 256}], beautifulnet[Colorize[ClusteringComponents[#, 7]]]}] & /@ movie1; We can animate this like so: ListAnimate[animation1] ![enter image description here][14] Conclusion ---------- These are only very preliminary results. But we see the workflow from scraping data, via generating a training set, choosing a network and training it. I think that having more images and more training, perhaps a small change of the net might give us much better results. The video is quite bad, because we should use a better object than "four cables in a hand". It is also a bit debatable whether it is ok to say that this is how a network that only has seen beautiful things interprets the world, but I couldn't resit the hype. Sorry for that! This is certainly in the realm of "recreational use of the Wolfram Language", but the network does appear to make the world more colourful and provides a very special interpretation of the world. I hope that people in this forum who are better than me at this ([@Sebastian Bodenstein][at0] , [@Matteo Salvarezza][at1] , [@Meghan Rieu-Werden][at2] , [@Vitaliy Kaurov][at3] ?) can improve on the results. Cheers, Marco [at0]: http://community.wolfram.com/web/sebastianb [at1]: http://community.wolfram.com/web/matteosalvarezza [at2]: http://community.wolfram.com/web/meghanr [at3]: http://community.wolfram.com/web/vitaliyk [1]: http://www.memo.tv/learning-to-see-you-are-what-you-see/ [2]: https://vimeo.com/260612034 [3]: http://community.wolfram.com//c/portal/getImageAttachment?filename=Screenshot2018-07-0600.33.06.png&userId=48754 [4]: http://community.wolfram.com//c/portal/getImageAttachment?filename=1838animated.gif&userId=48754 [5]: https://resources.wolframcloud.com/NeuralNetRepository/ [6]: http://www.wolfram.com/broadcast/s?sx=neural%20networks&c=105&v=1522 [7]: http://blog.wolfram.com/2018/06/14/launching-the-wolfram-neural-net-repository/ [8]: http://community.wolfram.com//c/portal/getImageAttachment?filename=Screenshot2018-07-0523.04.32.png&userId=48754 [9]: http://community.wolfram.com//c/portal/getImageAttachment?filename=Screenshot2018-07-0523.13.54.png&userId=48754 [10]: http://community.wolfram.com//c/portal/getImageAttachment?filename=Screenshot2018-07-0523.15.48.png&userId=48754 [11]: http://community.wolfram.com//c/portal/getImageAttachment?filename=Screenshot2018-07-0523.21.05.png&userId=48754 [12]: http://community.wolfram.com//c/portal/getImageAttachment?filename=Screenshot2018-07-0523.22.34.png&userId=48754 [13]: http://community.wolfram.com//c/portal/getImageAttachment?filename=resulttable.png&userId=48754 [14]: http://community.wolfram.com//c/portal/getImageAttachment?filename=1838animated.gif&userId=48754 Marco Thiel 2018-07-05T23:14:51Z https://community.wolfram.com/groups/-/m/t/1305281 Since it is basketball season (right now we are in the middle of March madness) I thought it'd be fun to make a basketball simulation. Basketball Boids is motivated by the boids model of bird flocks, with a term for separation from teammates, a term for cover/separation from the other team (sign depends on offense or defense), an attraction towards the basket. You can try your own parameters, and you can try other models. Ideally, there would be so-called emergent properties like team work and creativity as in the bird flocks. ![basketball boids][1] Blue is offense and red is defense. m = Through[{m1, m2, m3, m4, m5}[t]];(*{m1[t],m2[t],m3[t],m4[t],m5[t]}*) p = Through[{p1, p2, p3, p4, p5}[t]];(*{p1[t],p2[t],p3[t],p4[t],p5[t]}*) Those are the variables and this solves the differential equation, with the boid parameters in the code. The separation and cover terms are inverse square forces, but the hoop term is just radial. dm[n_] := separation* Sum[(m[[n]] - m[[i]])/((m[[n]] - m[[i]]).(m[[n]] - m[[i]]))^(3/2), {i, 5}] + cover*Sum[(m[[n]] - p[[i]])/((m[[n]] - p[[i]]).(m[[n]] - p[[i]]))^(3/2), {i, 5}] + hoop*(-m[[n]]/(m[[n]].m[[n]])^(1/2)) dp[n_] := separation*Sum[(p[[n]] - p[[i]])/((p[[n]] - p[[i]]).(p[[n]] - p[[i]]))^(3/2), {i, 5}] - cover*Sum[(p[[n]] - m[[i]])/((p[[n]] - m[[i]]).(p[[n]] - m[[i]]))^(3/2), {i, 5}] + hoop*(-p[[n]]/(p[[n]].p[[n]])^(1/2)) params={separation -> 1, cover -> 10, hoop -> 100}; sol = Quiet[NDSolve[Evaluate[N@Flatten[Table[{D[m[[i]], t, t] == dm[i], D[p[[i]], t, t] == dp[i], (D[m[[i]], t] /. t -> 0) == {0, 0}, (D[p[[i]], t] /. t -> 0) == {0, 0}, (m[[i]] /. t -> 0) == RandomReal[1, 2], (p[[i]] /. t -> 0) == RandomReal[1, 2]}, {i, 5}]]/. params],Join[m, p], {t, 0, 1}][[1]]]; ParametricPlot[Evaluate[Join[m, p] /. sol], {t, 0, 1}, PlotStyle -> Join[Table[Blue, 5], Table[Red, 5]]] ![parametric plot of a solution][2] The animation above was made with Animate[ListPlot[Join[Style[#, Blue] & /@ m, Style[#, Red] & /@ p] /. sol /. t -> s, Axes -> False, Prolog -> {Brown, Disk[{0, 0}, .2]}, AspectRatio -> 1, PlotRange -> 4 {{-1, 1}, {-1, 1}}], {s, 0, 1, .01}] (I remember talking several years ago to a student at the [Wolfram High School Summer Program][3] about Boids, which is why I was thinking about them.) [1]: http://community.wolfram.com//c/portal/getImageAttachment?filename=basketball-boids.gif&userId=23275 [2]: http://community.wolfram.com//c/portal/getImageAttachment?filename=basketball-boids.png&userId=23275 [3]: https://education.wolfram.com/summer/camp/ Todd Rowland 2018-03-20T14:23:53Z https://community.wolfram.com/groups/-/m/t/879610 I had an idea while waiting for my own HTC Vive [(website)][1] to arrive regarding Wolfram|Alpha. If it could be implemented as a program for the Vive, it could make 3D plots (both across real numbers and the complex plane) become easily visualized, especially with it's "Room Scale" capabilities. I know that the Vive was really made with games in mind, but I think that it could be also useful when used with Wolfram|Alpha. I'm not sure if this is the right place to post this idea, but hopefully the Wolfram|Alpha team will see this and consider it. Please share with me your thoughts, and hope this is seen by Wolfram|Alpha developers so they can see your ideas too. [1]: http://www.htcvive.com Caelum Codicem 2016-06-30T05:13:39Z https://community.wolfram.com/groups/-/m/t/772917 On January 5th, 2016 *The Atlantic* published an article by Rose Eveleth entitled "[A Brief History of Noise:From the big bang to cellphones][1]" featuring my father, nuclear physicist [John G. Cramer][2] who used Mathematica to recreate a simulation of the sound of the Big Bang. [He first did this in 2003][3], and then [did it again in 2013 using new data][4]. (There is also [a version on YouTube featuring graphics from the LISA Mission][5].) [Here is a link to an archive of the initial Mathematica][6] notebook in the Wolfram Library Archive. UPDATE: I asked him if there is a newer version of the file than the one in the archive. The most recent BBSound notebook, used for the Planck data, is at: [http://faculty.washington.edu/jcramer/BigBang/Planck_2013/BB_Sound_3.nb][7] and the Planck data file is at [http://faculty.washington.edu/jcramer/BigBang/Planck_2013/PlanckData.txt][8] [1]: http://www.theatlantic.com/science/archive/2016/01/a-brief-history-of-noise/422481/ [2]: https://faculty.washington.edu/jcramer/ [3]: http://www.wolfram.com/mathematica/customer-stories/mathematica-simulates-the-sound-of-the-big-bang.html [4]: http://www.washington.edu/news/2013/04/04/listening-to-the-big-bang-in-high-fidelity-audio/ [5]: https://youtu.be/1OpNI5DjxC0 [6]: http://library.wolfram.com/infocenter/MathSource/5083 [7]: http://faculty.washington.edu/jcramer/BigBang/Planck_2013/BB_Sound_3.nb [8]: http://faculty.washington.edu/jcramer/BigBang/Planck_2013/PlanckData.txt Kathryn Cramer 2016-01-13T16:47:17Z https://community.wolfram.com/groups/-/m/t/908742 ## Abstract This Summer School Wolfram Project represents an image-based approach for gesture recognition with the use of machine learning and neural network training. Up to now gesture recognition remains a complex problem solved with different techniques, each of them has its pron and cons. It has a wide range of applications: from sign language recognition to virtual reality simulation. Sign language is not universal and almost each country has its unique, although they are quite similar in many ways. _American sign language_ ![American sign language][1] Two methods of recognition and 4 different training sets are used. All gestures in this work come from American and Polish sign languages. - First method is to classify data via **Classify** function. It was implemented for a complex data-set of images, captured in an uncontrolled environment, and showed insufficient result with accuracy less than 3%. The reason is that image database contains full body images and it's hard to distinguish hands only. - Second method involves neural network training via **NetTrain**. The dataset includes 3477 images for 5 gestures of ASL. Training is tested on two sets of images with uniform and non-uniform backgrounds. This method produced 76-77% accuracy result and it can be further improved up to 100% for static gestures by enlarging datasets. ____ ## Classify Function [First dataset][3] contains 899 images of 12 different people for 27 gestures from Polish sign language (set1). It is complemented by 2072 full body images of 20 different people (set 2) and images captured from one person (set 3). ![enter image description here][4] Test sets are generated from selection of original training sets. Several combinations of training and validation data selections were testified: ![enter image description here][5] None of big data-sets gave sufficient result. Nevertheless, **Classify** can produce sufficient results with carefully sorted data. ![enter image description here][6] ___ ## NetTrain [Training][7] and [validation][8] database for the network training includes images of only hands. There are 3477 images in training set, 317 test images with uniform background and 317 images with complex background. Table below shows how many times each gesture is represented. ![enter image description here][9] Training is proceeded with a 13-layer setup. Resulting accuracy for uniform background validation data is about 77%, and about 75% for complex background data . ![enter image description here][10] cm = ClassifierMeasurements[lenet, uniTestData]; cm["Accuracy"] 0.766562 Confusion matrix is presented below. ![enter image description here][11] ___ ##Examples ![enter image description here][12] img ![enter image description here][13] lenet[img,"TopProbabilities"] {"b" -> 0.981646} ___ ## Conclusion - Sufficient identification requires differentiation of human body and background, as well as of different parts of body. - In order to improve recognition results, database enlargement together with image pre-processing should be done. Feature extraction algorithms would allow to remove background and to distinguish hands on an image. - Preferable method to use is neural network training, as it confidently wins over Classify Function in that case. [1]: http://community.wolfram.com//c/portal/getImageAttachment?filename=18kzh07ccj6zkjpg.jpg&userId=900559 [2]: http://community.wolfram.com//c/portal/getImageAttachment?filename=8525polish.png&userId=900559 [3]: http://sun.aei.polsl.pl/~mkawulok/gestures/hgr1_images.zip [4]: http://community.wolfram.com//c/portal/getImageAttachment?filename=test.gif&userId=900559 [5]: http://community.wolfram.com//c/portal/getImageAttachment?filename=trainSet6.png&userId=900559 [6]: http://community.wolfram.com//c/portal/getImageAttachment?filename=pasted_image_at_2016_08_19_02_21_pm.png&userId=900559 [7]: http://www.idiap.ch/resource/gestures/data/shp_marcel_train.tar.gz [8]: http://www.idiap.ch/resource/gestures/data/shp_marcel_test.tar.gz [9]: http://community.wolfram.com//c/portal/getImageAttachment?filename=trainSet.png&userId=900559 [10]: http://community.wolfram.com//c/portal/getImageAttachment?filename=Capture.PNG&userId=900559 [11]: http://community.wolfram.com//c/portal/getImageAttachment?filename=trainSet7.png&userId=900559 [12]: http://community.wolfram.com//c/portal/getImageAttachment?filename=Capture2.PNG&userId=900559 [13]: http://community.wolfram.com//c/portal/getImageAttachment?filename=no.jpg&userId=900559 Lev Dushkin 2016-08-19T14:31:12Z https://community.wolfram.com/groups/-/m/t/814988 ![enter image description here][1] Some time ago I asked myself: with all these great graphics and interactive capabilities of _Mathematica_, what kinds of 3D games can be implemented in it? And the answer which came to mind is [Minecraft classic][2]. The scene in this game is almost static, the [first person view][3] and [controls][4] can be easily implemented, the terrain textures are [freely available][5], and the overall functionality does not seem to be complicated... There is even a related [demonstration][6] on the Demonstrations Project! ---------- **So, can Mathematica really handle Minecraft classic game functionality? Well, the answer seems to be YES :)** ---------- Here is my implementation of Minecraft classic game in Mathematica. Let's start with some screenshots which were taken during the construction of the final scene which will be displayed an the end of this post. ![enter image description here][7] ![enter image description here][8] ![enter image description here][9] ![enter image description here][10] **Features** - Blocks are creatable and removable - One texture per block - Player automatically jumps to the obstacles of one block height and on the blocks which are created directly underneath. You can also try to fall down. - Simplified selection tracking, which can miss cube corners, is implemented. Anyway it is still quite intuitive and allows to put blocks diagonally. - Big action range: you can place and remove blocks located far away. **Controls** - W-A-S-D: move forward-left-backward-right. By default double steps are used, Shift key enables single step. - Arrow keys: look up-down-left-right - Mouse selects current block - 1…9: select new block type - B: show blocks selector - Left mouse click: delete block - Right mouse click or Space: create block - R: set respawn position - Enter: respawn - X: Save game state - L: Load game state **Performance tuning** **Terrain construction.** Simple random walk terrain generation is implemented. The following parameters can by adjusted: `prmTERRAINBLOCKSN` – approximate number of terrain blocks `prmCLOUDSN` – number of clouds. Each cloud consists of random number of blocks. `prmTERRAINGRAIN` and `prmTERRAINOFFSET` control the landscape properties. On the first picture below `prmTERRAINOFFSET` is 8, and is 3 for the second one. ![enter image description here][11]![enter image description here][12] **Hardware issues.** On some systems the presence of a _single_ opacity directive drastically decreases performance. In this case one can set `prmDISABLETRANSPARENCY` to `True` or/and try to use `prmRENDERINGENGINE=”BSPTree”`. **Conclusion** To be honest I am myself surprised how well the final code performs. On average system it easily handles thousands and even tens of thousands blocks. With the growth of this number the "gameplay" becomes too slow. It is also should be noted that what really matters is the number of faces, because hidden faces are not included in the final Graphics3D, so clustered blocks are preferable. The result of my first construction session is ![enter image description here][13] The code has been tested on _Mathematica_ version 8.0.4 and WinXP and Win7 operation systems. Further improvements are appreciated as well as the comments about the code organisation and style. Thank you! I would like to make some considerations about the performance of the above code ([here is the link][14] to it on Pastebin for convenience). The speed of current implementation is both hardware and version specific. There are two main characteristics: the smoothness of motion and the speed of scene update after block creation or removal. I guess that the smoothness depends on graphics card, and the update speed on both the processor and GPU. On my working G860 3Hz Intel processor with integrated Intel HD graphics and Win7 OS I have the following: - The default scene with 5000 terrain blocks and 3 clouds is smooth enough for comfortable movement _with disabled transparency_. It speeds up a bit when no dynamic selection is displayed (when I point to the sky). - The update speed is approximately 1-2 seconds per operation. - The overall performance deteriorates significantly with enabled transparency. One way out is to set `prmCLOUDSN=0` since it is clouds what is transparent on the default scene. - With 20 000 terrain blocks and disabled opacity the movement is still pretty smooth, the scene update takes 2-3 seconds. - No performance differences between versions 8 and 9 on my system. - The scene I've constructed began with 1000 terrain blocks, no clouds (I added them manually) and no transparency. With this inital settings the scene updates momentally and is comfortable for construction. Honestly I am not sure about how transparency is handled on different systems, but on the system with an old discrete GeForce card it seemed to work faster than on integrated GPUs. So my advices on performance improvement still are: - Use `prmTERRAINBLOCKSN` and `prmCLOUDSN` wisely. Try to set them to zero at all. - Try `prmDISABLETRANSPARENCY=True` - Point to the sky when move --- ---------- *NOTE: this article was originally posted at [Mathematica Stack Exchange][15].* ---------- This scene can be downloaded (and loaded from _Mathematica_) from [here][16]. Here is the code. prmWORLDWIDTH = 200; prmWORLDHEIGHT = 100; prmVIEWERHEIGHT = 2.75; prmVIEWRANGE = {0.01, 300}; prmMOVESTEP = .95; prmACTIONRANGE = 300; prmTRACESTEP = 0.33; prmVIEWANGLE = 45 Degree; prmFALLINGPAUSE = 0; prmVERTLOOKANGLEDELTA = 4.99 Degree; prmHORLOOKANGLEDELTA = 90 Degree/4.; prmSKYCOLOR = RGBColor[0.58, 0.77, 0.96]; prmTEXTURESIZE = 16; prmTERRAINBLOCKSN = 5000; prmCLOUDSN = 3; prmFLOORMATERIAL = matSand; prmRENDERINGENGINE = Automatic; prmDISABLETRANSPARENCY = False; prmSMOOTHTERRAIN = True; prmTERRAINGRAIN = 3; prmTERRAINOFFSET = 3; terrainImg = Import["http://i.imgur.com/2uAswvI.png"]; ClearAll["mat*"]; materials = {matGrass -> {1, 1}, matStone -> {1, 2}, matDirt -> {1, 3}, matPlanks -> {1, 5}, matPlate -> {1, 7}, matBricks -> {1, 8}, matCobblestone -> {2, 1}, matBedrock -> {2, 2}, matSand -> {2, 3}, matGravel -> {2, 4}, matWood -> {2, 5}, matLeaves -> {2, 7}, matMossStone -> {3, 5}, matObsidian -> {3, 6}, matGlass -> {4, 2}, matWhiteWool -> {5, 16}, matGrayWool -> {5, 15}, matDarkGrayWool -> {5, 14}, matMagentaWool -> {5, 13}, matPinkWool -> {5, 12}, matPurpleWool -> {5, 10}, matBlueWool -> {5, 9}, matLightBlueWool -> {5, 8}, matCyanWool -> {5, 7}, matGreenWool -> {5, 5}, matLimeWool -> {5, 4}, matYellowWool -> {5, 3}, matOrangeWool -> {5, 2}, matRedWool -> {5, 1}, matClouds -> {1, 12}, matSilver -> {2, 8}, matGold -> {2, 9} }; dirVectors = {{0, 1, 0}, {1, 0, 0}, {0, -1, 0}, {-1, 0, 0}, {0, 0, -1}, {0, 0, 1}}; vtc = {{0, 0}, {1, 0}, {1, 1}, {0, 1}}; vertCoords = # - {1, 1, 1} & /@ {{0, 0, 0}, {0, 0, 1}, {1, 0, 1}, {1, 0, 0}, {0, 1, 0}, {0, 1, 1}, {1, 1, 1}, {1, 1, 0}}; faceCoords = {{7, 6, 5, 8}, {3, 7, 8, 4}, {2, 3, 4, 1}, {6, 2, 1, 5}, {5, 8, 4, 1}, {3, 2, 6, 7}}; filename = "save.mmc"; initMaterials[] := Block[{}, nMat = Length@materials; Evaluate[materials[[All, 1]]] = Range[nMat]; matAir = 0; With[{ts = prmTEXTURESIZE}, textures = ImageTake[terrainImg, ts (#1 - 1) + {1, ts}, ts (#2 - 1) + {1, ts}] & @@@ (materials[[All, 2]]) ]; textures[[matClouds]] = Image[Array[{1, 1, 1} &, {prmTEXTURESIZE, prmTEXTURESIZE}]]; ClearAll[transparentQ]; Do[transparentQ[mat] = MemberQ[{matLeaves, matGlass, matClouds, matAir}, mat], {mat, 0, nMat}]; If[! prmDISABLETRANSPARENCY, textures[[matLeaves]] = ImageData[ textures[[ matLeaves]]] /. {{1., 1., 1.} -> {0., .5, 0., 0.}, {r_, g_, b_} :> {r, g, b, 1.}}; textures[[matGlass]] = ImageData[ textures[[ matGlass]]] /. {{1., 1., 1.} -> {5., .5, .1, 0.}, {r_, g_, b_} :> {r, g, b, 1.}}; textures[[matClouds]] = Array[{1, 1, 1, .75} &, {prmTEXTURESIZE, prmTEXTURESIZE}]; ]; ]; initIcons[] := Block[{}, icons = Graphics3D[{ EdgeForm@None, Texture[#], Polygon[# & /@ vertCoords[[#]], VertexTextureCoordinates -> vtc] & /@ faceCoords}, Lighting -> "Neutral", Boxed -> False, ImageSize -> 64, Background -> Black] & /@ textures; setterbar = Column[SetterBar[ Dynamic[ palette[[ curBlockType]], {(palette[[ curBlockType]] = #) &, (updatePalette[]; DialogReturn[]) &}], #] & /@ Partition[Thread[Range[nMat] -> icons], 6, 6, {1, 1}, {}] ]; palette = {matStone, matCobblestone, matBricks, matDirt, matPlanks, matWood, matLeaves, matGlass, matPlate}; curBlockType = 1; updatePalette[]; ]; updatePalette[] := (paletteGfx = Image[ GraphicsRow[icons[[palette]], Evaluate[Frame -> Array[# == curBlockType &, 9]], Evaluate[FrameStyle -> Directive[White, AbsoluteThickness@3]], Background -> Black ], ImageSize -> 500]); updateCubes[] := (cucubes = Flatten@cubes;); saveGame[file_] := Export[file, {pos, viewDir, moveDir, strafeDir, palette, curBlockType, SparseArray@blocks} // Compress, "Text"]; loadGame[file_] := Block[{p, vd, md, sd, pal, cbt, bl}, If[! FileExistsQ[file], MessageDialog["File not found"]; Return[]]; {p, vd, md, sd, pal, cbt, bl} = Uncompress@Import[file, "Text"]; {pos, viewDir, moveDir, strafeDir, palette, curBlockType} = {p, vd, md, sd, pal, cbt}; blocks = Normal@bl; dim = Dimensions@blocks; {prmWORLDWIDTH, prmWORLDHEIGHT} = Rest@dim; initFloor[]; initCubes[]; updateCubes[]; updatePalette[]; getSelection[]; FinishDynamic[]; ]; saveDialog[] := CreateDialog[ Grid@{{Dynamic["Save to file: " <> filename], FileNameSetter[Dynamic[filename], "Save"]}, {DefaultButton[saveGame[filename]; DialogReturn[]], CancelButton[] }} ]; loadDialog[] := CreateDialog[ Grid@{{Dynamic["Load from file: " <> filename], FileNameSetter[Dynamic[filename], "Open", {"mmc" -> {"*"}}]}, {DefaultButton[loadGame[filename]; DialogReturn[]], CancelButton[] }} ]; showBlockChooser[] := CreateDialog[setterbar, {}, WindowSize -> 500, Background -> Black, Modal -> True, WindowFrame -> "Frameless", TextAlignment -> Center ]; initBlocks[] := ( dim = {prmWORLDWIDTH, prmWORLDWIDTH, prmWORLDHEIGHT}; blocks = Array[0 &, dim]; ); initCamera[] := Block[{}, pos = {1.5, 1.5, prmVIEWERHEIGHT}; height = Ceiling@prmVIEWERHEIGHT; moveDir = {1, 1, 0} // Normalize; viewDir = moveDir; strafeDir = {1, -1, 0} // Normalize; respawnPos = Null; currentBlockPos = newBlockPos = Null; selection = {}; viewAngle = 0; ]; initFloor[] := (floor = With[{w = prmWORLDWIDTH}, {EdgeForm[None], Texture[textures[[prmFLOORMATERIAL]]], Polygon[{{0, 0, 0}, {0, w, 0}, {w, w, 0}, {w, 0, 0}}, VertexTextureCoordinates -> {{0, 0}, {w, 0}, {w, w}, {0, w}}]} ]); initCubes[] := Block[{g, type, pointers, faces}, cubes = {Texture@#} & /@ textures; cubePointers = Developer`ToPackedArray[{{0, 0, 0}}] & /@ textures; g = ParallelMap[{#, createCube[#]} &, Position[blocks, b_ /; b > 0]]; Scan[({pointers, faces} = Transpose@#; type = blockAt@First@pointers; cubes[[type]] = cubes[[type]]~Join~faces; cubePointers[[type]] = cubePointers[[type]]~Join~pointers; ) &, GatherBy[g, blockAt@First@# &] ]; ]; processFalling[] := Block[{i, j, k}, While[ ({i, j, k} = blockPos[pos])[[3]] > height && blocks[[i, j, k - height]] == 0, pos -= {0, 0, 1}; FinishDynamic[]; Pause[prmFALLINGPAUSE] ]]; lookHor[da_] := ({moveDir, strafeDir, viewDir} = RotationTransform[da, {0., 0., 1.}] /@ {moveDir, strafeDir, viewDir}); lookVert[da_] := If[Abs[viewAngle + da] <= Pi/2, viewAngle += da; viewDir = RotationTransform[da, strafeDir]@viewDir ]; move[dv_, n_Integer] := Do[move@dv, {n}]; move[dv_] := Block[{newpos, i, j, k, space}, newpos = pos + dv; If[! inRange@newpos, Return[]]; {i, j, k} = blockPos@newpos; If[k + 1 > prmWORLDHEIGHT, Return[]]; space = blocks[[i, j, (k - height + 1) ;; k + 1]]; Which[ And @@ Thread[Most@space == 0], pos = newpos, First@space != 0 && (And @@ Thread[Rest@space == 0]), pos = newpos + {0, 0, 1} ]; processFalling[]; ]; processKeyboard[] := ( Switch[CurrentValue["EventKey"], "W", move[prmMOVESTEP moveDir], "S", move[-prmMOVESTEP moveDir], "A", move[-prmMOVESTEP strafeDir], "D", move[prmMOVESTEP strafeDir], "w", move[prmMOVESTEP moveDir, 2], "s", move[-prmMOVESTEP moveDir, 2], "a", move[-prmMOVESTEP strafeDir, 2], "d", move[prmMOVESTEP strafeDir, 2], "q", pos += {0, 0, 1}, "b", showBlockChooser[], "r", (respawnPos = pos), "x", saveDialog[], "l", loadDialog[], " ", addCurrentBlock[], "1", curBlockType = 1; updatePalette[], "2", curBlockType = 2; updatePalette[], "3", curBlockType = 3; updatePalette[], "4", curBlockType = 4; updatePalette[], "5", curBlockType = 5; updatePalette[], "6", curBlockType = 6; updatePalette[], "7", curBlockType = 7; updatePalette[], "8", curBlockType = 8; updatePalette[], "9", curBlockType = 9; updatePalette[] ]; getSelection[]; ) actions = { {"MouseDown", 1} :> deleteCurrentBlock[], {"MouseUp", 2} :> (addCurrentBlock[]; getSelection[]), "MouseMoved" :> getSelection[], "LeftArrowKeyDown" :> lookHor[prmHORLOOKANGLEDELTA], "RightArrowKeyDown" :> lookHor[-prmHORLOOKANGLEDELTA], "UpArrowKeyDown" :> lookVert[prmVERTLOOKANGLEDELTA], "DownArrowKeyDown" :> lookVert[-prmVERTLOOKANGLEDELTA], "ReturnKeyDown" :> If[respawnPos =!= Null, move[respawnPos - pos]], "KeyDown" :> processKeyboard[], PassEventsDown -> False }; inRange = And @@ Thread[{0, 0, 0} < # <= dim] &; blockAt = blocks[[Sequence @@ #]] &; setBlock = (blocks[[Sequence @@ #1]] = #2) &; setMouse[expr_] := MouseAppearance[expr, "Arrow"]; blocksCount[] := Count[blocks, b_ /; b != 0, {3}]; facesCount[] := Count[cubes, Polygon[__], {3}]; blockPos = Ceiling; neighborList[p_] := Block[{cf}, cf = If[transparentQ@blockAt@p, (blockAt[#] == matAir) &, (transparentQ@blockAt[#] &) ]; Quiet[Flatten@ Position[p + # & /@ dirVectors, _?(inRange[#] && cf[#] &), {1}, Heads -> False]] ]; createCube[coords_] := Polygon[coords + # & /@ vertCoords[[#]], VertexTextureCoordinates -> vtc] & /@ faceCoords[[neighborList@coords]]; setCube[coords_, type_] := ( AppendTo[cubes[[type]], createCube[coords]]; AppendTo[cubePointers[[type]], coords]; ) addBlock[bp : {_Integer, _Integer, _Integer}?inRange] := ( setBlock[bp, palette[[curBlockType]]]; setCube[bp, palette[[curBlockType]]]; updateNeighbors@bp; ); neighborCoords[p_] := Quiet[Cases[ p + # & /@ dirVectors, _?(inRange[#] && blockAt[#] != matAir &), 1]]; updateNeighbors[p_] := Block[{np, locs}, np = neighborCoords@p; locs = ParallelMap[Position[cubePointers, #, {2}, Heads -> False] &, np]; (cubes[[Sequence @@ (First@#1)]] = createCube@#2) & @@@ Transpose@{locs, np}; ]; deleteBlock[bp : {_Integer, _Integer, _Integer}?inRange] := Block[{loc}, loc = Position[cubePointers, bp, {2}, Heads -> False]; setBlock[bp, 0]; cubePointers = Delete[cubePointers, loc[[1]]]; cubes = Delete[cubes, loc[[1]]]; updateNeighbors@bp; ]; addCurrentBlock[] := If[newBlockPos != blockPos@pos, getSelection[]; addBlock@newBlockPos; move@{0, 0, 0}; getSelection[]; updateCubes[]; ]; deleteCurrentBlock[] := ( getSelection[]; deleteBlock@currentBlockPos; getSelection[]; processFalling[]; updateCubes[]; ); getSelection[] := Block[{flag, found, chain, mp}, flag = False; mp = MousePosition["Graphics3DBoxIntercepts", Null]; currentBlockPos = newBlockPos = Null; selection = {}; If[mp === Null, Return[]]; v = Normalize[Subtract @@ mp]; If[v.viewDir < 0, v = -v]; found = (flag = (Last@# < 0 || blockAt[blockPos@#] != 0)) &; chain = NestWhileList[ # + prmTRACESTEP v &, pos, (And @@ Thread[{0, 0, -1} < # < dim]) && (! found@#) &, 1, Ceiling[prmACTIONRANGE/prmTRACESTEP]]; If[flag, currentBlockPos = blockPos@chain[[-1]]; selection = {EdgeForm@{Black, Thick}, FaceForm[None], Cuboid[currentBlockPos - 1, currentBlockPos] }; If[Length@chain > 1, newBlockPos = blockPos@chain[[-2]]]; ]; ]; (*World generation*) randomWalkPattern[nb_, m_, d_] := Module[{n = prmWORLDWIDTH, q, i0, j0, i1, j1, field, applyAt, offset, ok, p, next}, field = Array[0 &, {n, n}]; applyAt = Function[{i, j}, field[[i - m ;; i + m, j - m ;; j + m]] += 1]; offset = RandomInteger[d {-1, 1}, {2}] &; ok = (m < #1 <= n - m) && (m < #2 <= n - m ) &; next = (While[! ok @@ (q = # + offset[]), q]; q) &; p = Floor[{n, n}/2]; Do[applyAt @@ p; p = next@p, {Round[nb/(2 m + 1)^2]}]; If[prmSMOOTHTERRAIN, ListConvolve[BoxMatrix[2]/25, field] // Round, field] ]; createTerrain[bc_] := Block[{field}, field = randomWalkPattern[bc, prmTERRAINGRAIN, prmTERRAINOFFSET]; With[{h = Min[field[[##]], prmWORLDHEIGHT]}, blocks[[#1, #2, 1 ;; h]] = RandomChoice[{matGravel, matStone}, h]; blocks[[#1, #2, 1]] = RandomChoice@{matBedrock, matDirt}; If[1 < h < RandomInteger@{4, 9}, blocks[[#1, #2, h - 1 ;; h]] = matDirt; If[RandomChoice@{True, False}, blocks[[#1, #2, h]] = matGrass]; ]; ] & @@@ Position[field, b_ /; b > 0, {2}]; ]; createClouds[nClouds_] := Block[{cloud, ww = prmWORLDWIDTH, wh = prmWORLDHEIGHT, i, j, h}, Do[ cloud = randomWalkPattern[RandomInteger@{200, 1000}, 1, 2]; {i, j} = RandomInteger[{-ww, ww}/2, 2]; h = RandomInteger@{wh/2, wh}; Quiet[blocks[[#1 + i, #2 + j, h]] = matClouds] & @@@ Position[cloud, b_ /; b != 0, {2}], {nClouds} ]; ]; initMaterials[]; initIcons[]; initBlocks[]; createTerrain[prmTERRAINBLOCKSN]; createClouds[prmCLOUDSN]; initFloor[]; initCubes[]; initCamera[]; updateCubes[]; scene = Graphics3D[{Dynamic@floor, EdgeForm@None, Dynamic@cucubes, Dynamic@selection}, ViewVector -> Dynamic@{pos, pos + viewDir}, ViewRange -> prmVIEWRANGE, PlotRange -> All, Lighting -> "Neutral", Boxed -> False, BoxRatios -> Automatic, ImageSize -> Dynamic@AbsoluteCurrentValue[EvaluationNotebook[], WindowSize], ViewAngle -> prmVIEWANGLE, Background -> prmSKYCOLOR, PlotRangePadding -> 0, Epilog -> {crosshair, Inset[Dynamic@paletteGfx, Scaled@{.5, .05}]} ]; crosshair = {White, AbsoluteThickness@2, Line[{Scaled@{.49, .5}, Scaled@{.51, .5}}], Line[{Scaled@{.5, .49}, Scaled@{.5, .51}}] }; CreateDocument[ EventHandler[ setMouse@Style[scene, Selectable -> False, Editable -> False], actions ], CellMargins -> 0, ShowCellBracket -> False, ShowCellLabel -> False, "TrackCellChangeTimes" -> False, WindowElements -> {}, WindowFrame -> "Normal", WindowSize -> Full, "BlinkingCellInsertionPoint" -> False, "CellInsertionPointCell" -> {}, WindowMargins -> Automatic, WindowTitle -> "Mathematicraft", Background -> Black, Editable -> False, NotebookEventActions -> actions, TextAlignment -> Center, Deployed -> True, RenderingOptions -> {"Graphics3DRenderingEngine" -> prmRENDERINGENGINE} ]; blocksCount[] facesCount[] [1]: https://community.wolfram.com//c/portal/getImageAttachment?filename=3364hero.gif&userId=20103 [2]: http://www.minecraftwiki.net/wiki/Classic [3]: http://mathematica.stackexchange.com/q/5649/219 [4]: http://mathematica.stackexchange.com/q/17557/219 [5]: https://www.google.by/search?q=minecraft+textures&hl=ru&tbo=d&source=lnms&tbm=isch&sa=X&ei=A7QeUe2ZPMnEswaJnICIAQ&ved=0CAoQ_AUoAQ&biw=1174&bih=642 [6]: http://demonstrations.wolfram.com/BlockBuilder/ [7]: http://community.wolfram.com//c/portal/getImageAttachment?filename=8566sdf453qwyrgdfzg9rgdfv.png&userId=11733 [8]: https://community.wolfram.com//c/portal/getImageAttachment?filename=92938.png&userId=20103 [9]: https://community.wolfram.com//c/portal/getImageAttachment?filename=93129.png&userId=20103 [10]: https://community.wolfram.com//c/portal/getImageAttachment?filename=465010.png&userId=20103 [11]: https://community.wolfram.com//c/portal/getImageAttachment?filename=356211.png&userId=20103 [12]: https://community.wolfram.com//c/portal/getImageAttachment?filename=694312.png&userId=20103 [13]: https://community.wolfram.com//c/portal/getImageAttachment?filename=13.gif&userId=20103 [14]: http://pastebin.com/CjFZ3MpW [15]: http://mathematica.stackexchange.com/q/19669/13 [16]: https://dl.dropbox.com/u/66486755/scene.mmc Boris Faleichik 2016-03-02T16:14:21Z https://community.wolfram.com/groups/-/m/t/230347 After reading Stephen Wolfram mind blowing blog post "[url=http://blog.stephenwolfram.com/2014/03/injecting-computation-everywhere-a-sxsw-update/]Injecting Computation Everywhere[/url]", I tried to reproduce some of the demos he had for his SXSW talk. The results obtained adding just a little bit of code were quite surprising to me. Here is what happened when I injected the data from an accelerometer connected to an Arduino into the Wolfram Language using a few Graphics3D directives, six spheres and a pair of tubes: [img=width: 800px; height: 472px;]/c/portal/getImageAttachment?filename=ArduinoConnected.jpg&userId=56204[/img] Tadaa! Homer Simpson started computing the trajectory of a three-dimensional object! [img=width: 669px; height: 440px;]/c/portal/getImageAttachment?filename=simpson.gif&userId=56204[/img] To create this experiment I used the same hardware listed by Arnoud in this post  [url=http://community.wolfram.com/groups/-/m/t/160740]"Connecting to an accelerometer over a serial connection"[/url] (but instead of connecting the Arduino to the Raspberry Pi, I used my own laptop):[list] [*][url=http://www.adafruit.com/products/163]5V ready triple-axis accelerometer (+-3g analog output)[/url] [*][url=http://www.adafruit.com/products/64]Half-size bread board[/url] [*][url=http://www.adafruit.com/products/758]Male/male jumper wires[/url] [*][url=http://www.adafruit.com/products/50]Arduino Uno[/url] [/list]Once everything has been wired follow these steps: [list] [*]First upload the following Sketch to your Arduino: [/list][code] void setup() { Serial.begin(115200); } void loop() { long x = analogRead(0); long y = analogRead(1); long z = analogRead(2); Serial.write(x); Serial.write(y); Serial.write(z); delay(100); }[/code][list] [*]Take note of the serial port name that you will be using. [/list][list] [*]Connect the Arduino into the Wolfram Language. (The name of my port was "usbmodemfa131", replace it for the one you are using) [/list][mcode]serial = DeviceOpen["Serial", {"/dev/tty.usbmodemfa131", "BaudRate" -> 115200}][/mcode][list] [*]Check the data streamed by the Serial when the accelerometer lies flat: [/list][mcode]Partition[DeviceReadBuffer[serial], 3][/mcode][list] [*]Then set a function to scale the three coordinates XYZ between -1g and 1g: [/list][mcode]g[x_] := Divide[84 - x, -84][/mcode][list] [*]When the function is applied to the buffer's values, and the accelerometer lies flat, the average vector should approximate {0,0,1}g [/list][mcode]Partition[g /@ DeviceReadBuffer[serial], 3] // Mean // N[/mcode][list] [*]Once the accelerometer has been calibrated, run the following ScheduledTask every 0.1 seconds: [/list][mcode]RunScheduledTask[ bee = Partition[g /@ DeviceReadBuffer[serial], 3] // Mean // Normalize // N, 0.1][/mcode] Now, you are ready to dynamically control Homer Simpson's eyes :) [mcode]Graphics3D[{ Orange, Sphere[Dynamic[3*bee], 0.2], White, Sphere[eyeL = {0.1, 0.9, -2}, 1], Sphere[eyeR = {0.1, -0.9, -2}, 1], Gray, Sphere[Dynamic[Normalize[3 bee - eyeL] + eyeL], 0.25], Sphere[Dynamic[Normalize[3 bee - eyeR] + eyeR], 0.25], Yellow, Tube[{{-1, 0, -4}, {3, 0, -4}}, 2.5], Tube[{{0.8, 0, -1.8}, {1, 0, -0.8}}, 0.4], Brown, Sphere[{3, 0, -3}, 2.3]}, Lighting -> {{"Ambient", GrayLevel[.1]}, {"Point", White, Dynamic[3.5 bee]}}, ViewPoint -> {-0.8, -2.1, 2.5}, ViewVertical -> {-1.2, -0.8, 0.5}, PlotRange -> {{-4, 3}, {-3.2, 3.2}, {-7.5, 4}}, Background -> Black, Boxed -> False][/mcode] Bernat Espigulé 2014-04-02T20:32:43Z https://community.wolfram.com/groups/-/m/t/96837 I have been an intern at Wolfram Research for the summer and ended up writing [url=http://github.com/philngo/sphero-mathematica]this package[/url] for connecting to a [url=http://www.gosphero.com]Sphero[/url] robot. Sphero is a little spherical robot that you can drive on land or in water from your iPhone, iPad, Android, tablet and (now) from Mathematica. The package uses [url=http://library.wolfram.com/infocenter/Demos/5726]SerialIO[/url] and Bluetooth to connect to Sphero. I included a sample notebook to help people get started that shows how to load the package, connect via bluetooth, etc. I embedded the SerialIO package as well. You'll need to find figure out which virtual serial port was opened by Bluetooth, but once you do so, this command gets you up and running. I've only done this on Mac, so if anyone succeeds on a Windows or Linux machine, would you post how you did it? [mcode]mySphero = SpheroDeviceConnect["/dev/tty.Sphero-BWR-RN-SPP"][/mcode] The package is in its infancy, but already lets you do some pretty cool stuff. My favorite uses Sphero to control a Graphics3D object - twist and turn Sphero in your hand and watch your Graphics3D object mimic its twists and turns on the screen. If you find some other cool ways to interact with Sphero from within Mathematica, please post. Access Sphero's data with this command, which returns a List of rules that can be used to access the various data fields that Sphero streams. [mcode]SpheroDeviceData[mySphero][/mcode] I would love feedback on how to improve the package. By the way, Sphero 2.0 (looks very cool) came out today - not sure if this package will still work with it, but let me know if it does. Phil Ngo 2013-08-14T21:47:27Z https://community.wolfram.com/groups/-/m/t/90931 So the Leap Motion controller has just been released and I thought I might as well post some code that Todd Gayley and I wrote to connect the Leap Motion and all of its functionality to Mathematica! Here are the setup instructions: 1. (If you haven't already) download and install the leap motion software from [b][url=http://www.leapmotion.com/setup]leapmotion.com/setup[/url][/b] 2. Download the leap motion SDK off their developer page. 3. Connect the Leap Motion to your computer. 4. Find the file "LeapJava.jar" inside of the Leap SDK (It should be under lib.) 5. Open Mathematica and paste this in: [mcode]Needs["JLink`"]; ReinstallJava[CommandLine -> "java", JVMArguments -> "-Djava.library.path=[path to directory CONTAINING LeapJava.jar]"];[/mcode]Now put the path to "LeapJava.jar" in the indicated position, and remember this is the path to the directory containing LeapJava.jar, not the path to LeapJava.jar itself and run the code. 6. Now paste this in:[mcode]AddToClassPath["[path to LeapJava.jar]"];[/mcode]Replace the indicated area with the path to LeapJava.jar itself and run it. 7. To setup the controller, run this:[mcode]controller = JavaNew["com.leapmotion.leap.Controller"][/mcode] You should now be fully connected and ready to go!  To see if it is working you can run:[mcode]Methods[controller][/mcode]and it should return a list of all the methods under the controller. The main method you want to look at is frame[] which contains all of the information about what is going on. To see the methods under frame[] run this:[mcode]Methods[controller@frame[]] [/mcode] From here you should be able to figure things out like this: [mcode]controller@frame[]@fingers@count[][/mcode]which should count the visible fingers in the scene. Also in a final note I want mention that I was having problems accessing the fingers with this:[mcode]controller@frame[]@finger[finger number][/mcode]and so you may want to try:[mcode]controller@frame[]@fingers[]@get[finger number][/mcode]instead.  The same goes for palms. Well, if you write anything cool using this please post it back up here along with any questions you have. (I am going to try to post some of the code I have written with this soon :D ) Christopher Wolfram 2013-08-06T17:30:52Z https://community.wolfram.com/groups/-/m/t/35026 [b][url=http://www.wolfram.com/community/web/community/groups/-/message_boards/message/34483]Christopher question about augmented reality[/url][/b] reminded me about a concealed identity trick used in video streams when black strips or blurred areas follow character faces. We can do this with Mathematica [b][url=http://reference.wolfram.com/mathematica/ref/FindFaces.html]FindFaces[/url][/b] functionality. There are a few different ways we can overlay transparent or opaque graphic objects and images with a live video stream. One of them is simply using Show. Let us find some simple overlay masks – and what can be better than some glasses, mustaches, goatees, and pipes? [mcode]mask = Import /@ { "http://i.imgur.com/155BjOY.png", "http://i.imgur.com/zq3Qsm6.png", "http://i.imgur.com/kONG87s.png", "http://i.imgur.com/WaQkDsn.png", "http://i.imgur.com/JZqCWEN.png", "http://i.imgur.com/9Y5CcUQ.png", "http://i.imgur.com/5CiN4Af.png" } [/mcode][img]http://i.imgur.com/2vd08f3.png[/img] Now execute this code and bring a few friends to smile into camera: [mcode]Manipulate[ i = CurrentImage[]; Show[i, Graphics[ MapThread[ Inset[If[mix == "RANDOM", RandomChoice[mask], mix, mix], Offset[{0, -.27 #2}, #1], Center, #2] &, {Mean /@ #, -.8 Subtract @@@ #[[All, All, 1]]} &[FindFaces[i]] ] ], ImageSize -> 450] , {{mix, mask[[7]], ""}, mask~Join~{"RANDOM"}, Setter}, FrameMargins -> 0, SynchronousUpdating -> False] [/mcode][img]http://i.imgur.com/uJOw5Ca.png[/img] Thanks to our Wolfram volunteers for avid participation! Let me know if you can think of any improvements for this code. Have fun! Vitaliy Kaurov 2013-02-01T22:50:28Z