Stereoscopy-based procedural generation of virtual environments
CC Attribution - NoDerivatives 2.0 UK: England & Wales:
You are free to use, copy, distribute and transmit the work or content in unchanged form for any legal purpose as long as the work is attributed to the author in the manner specified by the author or licensor.
Gadia, Davide
Scalabrin, Manlio
Ripamonti, Laura Anna
Maggiorini, Dario
Procedural generation of virtual scenes (like e.g., complex cities with buildings of different sizes and heights) is widely used in the CG movies and videogames industry. Even if this kind of scenes are often visualized using stereoscopy, however, to our knowledge, stereoscopy is not currently used as a tool in the procedural generation, while a more comprehensive integration of stereoscopic parameters can play a relevant role in the automatic creation and placement of virtual models. In this paper, we show how to use stereoscopic parameters to guide the procedural generation of a scene in an open-source modeling software. Virtual objects can be automatically placed inside the stereoscopic volume, in order to reach the maximum amount of parallax on screen, given a particular interocular distance, convergence plane and display size. The proposed approach allows to create again a virtual scene, given a particular context of visualization, avoiding problems related to excessive positive parallax in the final rendering. Moreover, the proposed approach can be used also to automatically detect window violations, by determining overlaps in negative parallax area between models and the view frustums of the stereoscopic camera, and to apply proper solutions, like e.g. the automatic placement of a floating window. 
 David Gatta, and he's going to be presenting Stereoscopy-based procedural generation of virtual environments. David has received his Master of Science and PhD in Computer Science from the University of Milan. Okay, thank you, Chris, and I love everyone. What I'm presenting today is an application of stereoscopic parameters inside computer graphics. In particular, in a particular field of computer graphics, which is procedural modeling and procedural generation of virtual scenes, you may have seen some examples of procedural generation in the 3D theater last on Monday. And it's something that is more and more used in movies and video games. The generation of a lot of models, trees, buildings in an automatic or semi-automatic way. These scenes are often visualized in 3D. The point is that often, to my knowledge at least, the stereoscopic parameters are not used as a direct parameter to generate the models inside the scene. So what I propose in this paper is to use, to generate a scene using stereoscopy since the beginning of the creation of the scene. We can go back to the comment Neil Dockson has done last Monday, the use of stereoscopy to create something creative, creative tools for creative stereoscopy. And to do that, we needed tools to accurately done to allow the designer of stereoscopic scenes to use all the settings in the scenes in the beginning. Just to give a brief introduction to procedural modeling, the procedural modeling is based on some equations, some set of rules applied to basic shapes. In order to create automatically a complex scene without having to model manually all the features in the scene. For example, very common examples, fractals, used to create some images or fractal terrains. L systems in which using some parameters and a set of rules, you can create complex shapes like trees. And more recently, in more complex systems, the procedural creation of cities. This is a work from 2001, based on the use of some images, giving some information regarding the elevation of the field, the population density, the presence of sea or lakes. You can generate a set of streets and on these streets, you can, using different rules, generate a different kind of buildings and creating something like this. Now in this paper, I try to consider the creation of some of these kind of scenes using stereo parameters to rule the creation of the geometry. The idea is to create a more effective and more pleasant stereoscopic scenes using the stereoscopic parameters since the beginning of the production stages. I present a few simple examples of integration of stereoscopic parameters in a procedural pipeline of a computer graphics production software. The first is very simple, the automatic geometry filling of the stereoscopic camera frustum. And the second one is the automatic detection of window violations and the application of the floating window. We have decided not to develop a system by scratch, but just rather to consider the integration of these techniques inside some already available tool. Opening also the discussion of what is provided by the production tools when we talk about stereoscopy. Now searching there are two sets of production tools, one very specific like the city engine, specific for creation of cities, but they often do not provide stereoscopy. For considering a general purpose tools we more or less go with Udini, which is a full production tool based on procedural generation. It provides stereoscopy, but the problem is that not all the parameters of the stereoscopic setup are provided as a tool inside the node based generation of the scenes. So you can set the stereoscopy camera, you can produce the stereoscopy image, but you cannot use the parameters of the stereoscopy setup in the production of the scene. So we have opted for a different approach. We have considered the blender, which is open source, it provides stereoscopy pipeline, it is not a procedural tool, but by use of this ad on as a version from a Russian developer it is possible to extend the node editor blender that is already present for creating material for compositor to use it as a Udini to create a geometry. In this case we have the maximum flexibility, we have all the source code of the blender, we can do whatever we want, we can check every step of operation done inside the blender. Obviously this is particularly true for Zvarchuk, Zvarchuk is heavily in development stages, so you may lose stability when the development goes on and new versions are available. But just to break the highs of the topic and to do some preliminary test we found it a better solution. Test scene, we have decided to build a very simple scene, not as complex as in the previous work, both because we didn't have enough computational power, we are talking about hundreds of thousands of triangles in the scene. So we have, now it's quite dark actually, but we have decided for a very simple rendering level because the techniques that we are proposing are independent of how much you push the rendering, you can do it in tune shading, photorealistic rendering, we are discussing about the creation of the geometry, so at the moment we have decided to stay with an acceptable range of rendering. These techniques can also be integrated with other kind of scenes, trees instead of buildings, particle systems, they don't matter, we are talking about the stereoscopic parameters and now we can use it. So I will not go into the details of the construction of the geometry because it's not the topic of the paper. But simply we start with a patch, we divide it with some scheme, some parameters, in this case some sort of diamond based shape to build the streets and lots, and then for each lot we calculated the height of the buildings, mainly randomly, but there are some parameters that the user can set. And with many blocks you can create a city, you can also select some blocks to be some sort of downtown with the scalper, with other, it's going down with Gavishan way, but again no more details. Let's go to the stereoscopic setup. First one is almost trivial, I was sure to find someone else I've considered it but I've not found people in it, maybe the production tools used in the production companies that are not publicly available, they maybe used this since years but nobody has discussed it about it. It's trivial, if I have to create a 3D computer graphics I have to decide the 3D position of an object in a scene. So let's use what is called in computer graphics camera space, let's create, let's decide the position using the cameras, the origin of the world, and let's decide the depth, the Z position of the objects considering the stereoscopic frustum. In order to have control of the final depth range of the scene, having the control of the final parallax on the screen, and using only one parameter you can also re-edit the scene in case the material must be edited or converted for other setups or other possible solutions. So the idea is to introduce a rule like this, to decide the depth, the Z coordinate of the geometry inside the stereoscopic frustum, limiting in a set where the minimum Z can be the near plane of the camera or some other value decided by the user, and the maximum is given by this, where this one is the distance from the camera to the maximum parallax plane. I can calculate it because it's based on the forward camera, the convergence, the distance of the convergence plane, the size of the sensor, so you can go to the magnification factor, the size of the final image on the screen, all these parameters are known in a computer graphics setup. So I can calculate what will be the maximum parallax on screen and where is the maximum distance leading to the maximum parallax plane. And with these simple parameters ranging from 0 to 1, I can feel it. So from top you see I've stopped at 0.5, you can see as a percentage 50%, 80%, 95%. It's quite simple and straightforward. But here before showing you some example, the problems. Blender but also the other tools providing stereoscopic software, they give you the tools, they let you set the interaction distance, they let you set the convergence plane, they provide you a visualization of the stereoscopic frustum of the planes in order to manually place the objects inside the frustum, but they don't give you back the values. There are no panels on the graphic interface telling you, okay, the maximum parallax plane is that far. If it's equal to the far plane of the camera, okay, you're lucky. But otherwise you have no way to know where it is, nor in the API if you want to develop a script, it's provided. So it's calculated inside the software, but they are not provided from the user. So you cannot use it since the beginning. So in this case, rather than modifying the whole code of Blender, that is something that can be done when it's needed because you have also to contact the developer of Blender and there is some policy, we have to develop a Python script to recalculate the position of the maximum parallax plane in order to have it available to use it in the generation. So we have to do something that is radical quality inside Blender, but it's not provided from the software. In Dantes, you can use it and you can apply the value in your generation script to create the geometry. So the problem is the production software do not provide a full consideration of the stereoscopic setup in all the stages of the production. It is something that we may discuss. So some, we have to switch to 3D, that's the song. They are just free, yeah, thank you. They are just free image, but then I have some other results in the hand. Okay, maybe we may have to switch the lights off, I'm sorry. This is our scene with SFF parameter of 0.5. Now if you see on the background now, now 0.80, and 0.95, so almost filling the volume. So with just one parameter, I can control the automatic creation of this. In this scene, we have 2700s of buildings and something like 170,000 of triangles. So all created procedurally. And the depth range controls about this parameter. There are some window violations, I don't know if they are noticeable, but we will address it in the second technique. So we can go back to the 2D, keep your glasses on, keep your glasses near to you because we have other results in the hand. Okay, so this was very simple. Second one, bit more sophisticated. We have created the scene procedurally. And this scene, it may happen that we have window violations because some objects may be placed in negative retinal areas. So the idea was to detect automatically these violations and to automatically place the lateral mask of the floating window technique as actual 3D objects inside this scene, including the geometry producing the violations. This technique has four steps. You already know how it works, the floating window principle. If we have an object in a retinal rivalry, negative retinal rivalry, we think to have the window tilted like this in order to introduce a mask in the final scene. Really the most common way to do it in post-processing, applying the lateral mask on the final image. We are considering to apply it in 3D. Again our approach is based on some operation, Boolean operation between the geometry of the scene and the frustum of the camera, stereo camera. Again same problem as before. The frustum of the camera, the stereo camera is shown as a visual head, but there is no way to assess it as an actual 3D model to use in the scene. So we add again to implement a Python script in Blender to recalculate the values of the vertices of the planes building the camera frustum, to use these vertices to create an actual 3D model to add in the graph of the scene. In order to use it for our purposes. Again all these calculations is already done in Blender but is not provided to you if not like a visualization of where to place objects in order to have an idea of what will be the final depth. It is not very complicated because we know the fob, we know where is the distance of the converters plane. We have calculated where is the maximum parallax plane so it is just some trigonometry and something more just to find the vertices. Having done this we can calculate, we can have actual models in this case considering that we are doing a detection of window violations. We are interested in these two solids, the two negative parallax frustums that are represented here. Let's go fast, top view, you do it in the both sides, you have the model, you do a Boolean operation between the model and the solid of the retinal negative frustum. You detect this one and in particular we need this point because we have to place the mask here and this vertex does not exist. So now you have the point, you find it simply doing a depth rendering pass in order to have a depth image, depth buffer, you search for the minimum one. It is trivial if you have a triangle, it is not trivial if you have thousands and thousands of triangles. Once you have this, you create an actual plane, a black plane in the scene, it is like all the field, in the beginning you can create as large as you want and then you do another Boolean intersection between the frustum and the plane and what you have is a patch in 3D placed in front of the geometry that occludes the geometry behind. This is a visualization in 3D of what is the result. And maybe I will switch to the final video and not to the image. I was sorry, I am running very late. Not sure I will provoke the same enthusiastic reaction of the audience shown there. The idea was this is the image of 0.95 without and with maybe with I don't know if it's with the lights that the floating window is not so dark. Again another view and again with the floating window automatically applied and finally this is a 20 seconds movie of our scene created with the floating window procedurally generated in each frame at the correct size. So to again more than 3,000 of buildings and 170 triangles created procedurally. Obviously you can create everything you want maybe apply the same techniques. Very final remarks, the techniques are promising you can do whatever you want so you have the tools. If you have the tools since the beginning you can do whatever you want. If you don't have a better integration of stereoscopy inside the production pipeline you will be limited. In case of the open source tool you can apply the modification or you can communicate with the community developing the tools. In case of a proprietary production tools there is the need of some discussion and collaboration with the developers. Thank you for your attention just finishing the joke.
 David Gatta, and he's going to be presenting Stereoscopy-based procedural generation of  virtual environments.  David has received his Master of Science and PhD in Computer Science from the University  of Milan.  Okay, thank you, Chris, and I love everyone.  What I'm presenting today is an application of stereoscopic parameters inside computer  graphics.  In particular, in a particular field of computer graphics, which is procedural modeling and  procedural generation of virtual scenes, you may have seen some examples of procedural generation  in the 3D theater last on Monday.  And it's something that is more and more used in movies and video games.  The generation of a lot of models, trees, buildings in an automatic or semi-automatic  way.  These scenes are often visualized in 3D.  The point is that often, to my knowledge at least, the stereoscopic parameters are not  used as a direct parameter to generate the models inside the scene.  So what I propose in this paper is to use, to generate a scene using stereoscopy since  the beginning of the creation of the scene.  We can go back to the comment Neil Dockson has done last Monday, the use of stereoscopy  to create something creative, creative tools for creative stereoscopy.  And to do that, we needed tools to accurately done to allow the designer of stereoscopic  scenes to use all the settings in the scenes in the beginning.  Just to give a brief introduction to procedural modeling, the procedural modeling is based  on some equations, some set of rules applied to basic shapes.  In order to create automatically a complex scene without having to model manually all  the features in the scene.  For example, very common examples, fractals, used to create some images or fractal terrains.  L systems in which using some parameters and a set of rules, you can create complex shapes  like trees.  And more recently, in more complex systems, the procedural creation of cities.  This is a work from 2001, based on the use of some images, giving some information regarding  the elevation of the field, the population density, the presence of sea or lakes.  You can generate a set of streets and on these streets, you can, using different rules, generate  a different kind of buildings and creating something like this.  Now in this paper, I try to consider the creation of some of these kind of scenes using stereo  parameters to rule the creation of the geometry.  The idea is to create a more effective and more pleasant stereoscopic scenes using the  stereoscopic parameters since the beginning of the production stages.  I present a few simple examples of integration of stereoscopic parameters in a procedural  pipeline of a computer graphics production software.  The first is very simple, the automatic geometry filling of the stereoscopic camera frustum.  And the second one is the automatic detection of window violations and the application of  the floating window.  We have decided not to develop a system by scratch, but just rather to consider the integration  of these techniques inside some already available tool.  Opening also the discussion of what is provided by the production tools when we talk about  stereoscopy.  Now searching there are two sets of production tools, one very specific like the city engine,  specific for creation of cities, but they often do not provide stereoscopy.  For considering a general purpose tools we more or less go with Udini, which is a full  production tool based on procedural generation.  It provides stereoscopy, but the problem is that not all the parameters of the stereoscopic  setup are provided as a tool inside the node based generation of the scenes.  So you can set the stereoscopy camera, you can produce the stereoscopy image, but you  cannot use the parameters of the stereoscopy setup in the production of the scene.  So we have opted for a different approach.  We have considered the blender, which is open source, it provides stereoscopy pipeline,  it is not a procedural tool, but by use of this ad on as a version from a Russian developer  it is possible to extend the node editor blender that is already present for creating  material for compositor to use it as a Udini to create a geometry.  In this case we have the maximum flexibility, we have all the source code of the blender,  we can do whatever we want, we can check every step of operation done inside the blender.  Obviously this is particularly true for Zvarchuk, Zvarchuk is heavily in development stages,  so you may lose stability when the development goes on and new versions are available.  But just to break the highs of the topic and to do some preliminary test we found it a  better solution.  Test scene, we have decided to build a very simple scene, not as complex as in the previous  work, both because we didn't have enough computational power, we are talking about hundreds of thousands  of triangles in the scene.  So we have, now it's quite dark actually, but we have decided for a very simple rendering  level because the techniques that we are proposing are independent of how much you push the rendering,  you can do it in tune shading, photorealistic rendering, we are discussing about the creation  of the geometry, so at the moment we have decided to stay with an acceptable range of  rendering.  These techniques can also be integrated with other kind of scenes, trees instead of buildings,  particle systems, they don't matter, we are talking about the stereoscopic parameters  and now we can use it.  So I will not go into the details of the construction of the geometry because it's not the topic  of the paper.  But simply we start with a patch, we divide it with some scheme, some parameters, in this  case some sort of diamond based shape to build the streets and lots, and then for each lot  we calculated the height of the buildings, mainly randomly, but there are some parameters  that the user can set.  And with many blocks you can create a city, you can also select some blocks to be some  sort of downtown with the scalper, with other, it's going down with Gavishan way, but again  no more details.  Let's go to the stereoscopic setup.  First one is almost trivial, I was sure to find someone else I've considered it but I've  not found people in it, maybe the production tools used in the production companies that  are not publicly available, they maybe used this since years but nobody has discussed  it about it.  It's trivial, if I have to create a 3D computer graphics I have to decide the 3D position  of an object in a scene.  So let's use what is called in computer graphics camera space, let's create, let's decide the  position using the cameras, the origin of the world, and let's decide the depth, the  Z position of the objects considering the stereoscopic frustum.  In order to have control of the final depth range of the scene, having the control of  the final parallax on the screen, and using only one parameter you can also re-edit the  scene in case the material must be edited or converted for other setups or other possible  solutions.  So the idea is to introduce a rule like this, to decide the depth, the Z coordinate of the  geometry inside the stereoscopic frustum, limiting in a set where the minimum Z can  be the near plane of the camera or some other value decided by the user, and the maximum  is given by this, where this one is the distance from the camera to the maximum parallax plane.  I can calculate it because it's based on the forward camera, the convergence, the distance  of the convergence plane, the size of the sensor, so you can go to the magnification  factor, the size of the final image on the screen, all these parameters are known in  a computer graphics setup.  So I can calculate what will be the maximum parallax on screen and where is the maximum  distance leading to the maximum parallax plane.  And with these simple parameters ranging from 0 to 1, I can feel it.  So from top you see I've stopped at 0.5, you can see as a percentage 50%, 80%, 95%.  It's quite simple and straightforward.  But here before showing you some example, the problems.  Blender but also the other tools providing stereoscopic software, they give you the tools,  they let you set the interaction distance, they let you set the convergence plane, they  provide you a visualization of the stereoscopic frustum of the planes in order to manually  place the objects inside the frustum, but they don't give you back the values.  There are no panels on the graphic interface telling you, okay, the maximum parallax plane  is that far.  If it's equal to the far plane of the camera, okay, you're lucky.  But otherwise you have no way to know where it is, nor in the API if you want to develop  a script, it's provided.  So it's calculated inside the software, but they are not provided from the user.  So you cannot use it since the beginning.  So in this case, rather than modifying the whole code of Blender, that is something  that can be done when it's needed because you have also to contact the developer of Blender  and there is some policy, we have to develop a Python script to recalculate the position  of the maximum parallax plane in order to have it available to use it in the generation.  So we have to do something that is radical quality inside Blender, but it's not provided  from the software.  In Dantes, you can use it and you can apply the value in your generation script to create  the geometry.  So the problem is the production software do not provide a full consideration of the  stereoscopic setup in all the stages of the production.  It is something that we may discuss.  So some, we have to switch to 3D, that's the song.  They are just free, yeah, thank you.  They are just free image, but then I have some other results in the hand.  Okay, maybe we may have to switch the lights off, I'm sorry.  This is our scene with SFF parameter of 0.5.  Now if you see on the background now, now 0.80, and 0.95, so almost filling the volume.  So with just one parameter, I can control the automatic creation of this.  In this scene, we have 2700s of buildings and something like 170,000 of triangles.  So all created procedurally.  And the depth range controls about this parameter.  There are some window violations, I don't know if they are noticeable, but we will address  it in the second technique.  So we can go back to the 2D, keep your glasses on, keep your glasses near to you because  we have other results in the hand.  Okay, so this was very simple.  Second one, bit more sophisticated.  We have created the scene procedurally.  And this scene, it may happen that we have window violations because some objects may  be placed in negative retinal areas.  So the idea was to detect automatically these violations and to automatically place the  lateral mask of the floating window technique as actual 3D objects inside this scene, including  the geometry producing the violations.  This technique has four steps.  You already know how it works, the floating window principle.  If we have an object in a retinal rivalry, negative retinal rivalry, we think to have  the window tilted like this in order to introduce a mask in the final scene.  Really the most common way to do it in post-processing, applying the lateral mask on the final image.  We are considering to apply it in 3D.  Again our approach is based on some operation, Boolean operation between the geometry of the  scene and the frustum of the camera, stereo camera.  Again same problem as before.  The frustum of the camera, the stereo camera is shown as a visual head, but there is no  way to assess it as an actual 3D model to use in the scene.  So we add again to implement a Python script in Blender to recalculate the values of the  vertices of the planes building the camera frustum, to use these vertices to create an  actual 3D model to add in the graph of the scene.  In order to use it for our purposes.  Again all these calculations is already done in Blender but is not provided to you if not  like a visualization of where to place objects in order to have an idea of what will be the  final depth.  It is not very complicated because we know the fob, we know where is the distance of the  converters plane.  We have calculated where is the maximum parallax plane so it is just some trigonometry and  something more just to find the vertices.  Having done this we can calculate, we can have actual models in this case considering  that we are doing a detection of window violations.  We are interested in these two solids, the two negative parallax frustums that are represented  here.  Let's go fast, top view, you do it in the both sides, you have the model, you do a Boolean  operation between the model and the solid of the retinal negative frustum.  You detect this one and in particular we need this point because we have to place the mask  here and this vertex does not exist.  So now you have the point, you find it simply doing a depth rendering pass in order to have  a depth image, depth buffer, you search for the minimum one.  It is trivial if you have a triangle, it is not trivial if you have thousands and thousands  of triangles.  Once you have this, you create an actual plane, a black plane in the scene, it is like all  the field, in the beginning you can create as large as you want and then you do another  Boolean intersection between the frustum and the plane and what you have is a patch in  3D placed in front of the geometry that occludes the geometry behind.  This is a visualization in 3D of what is the result.  And maybe I will switch to the final video and not to the image.  I was sorry, I am running very late.  Not sure I will provoke the same enthusiastic reaction of the audience shown there.  The idea was this is the image of 0.95 without and with maybe with I don't know if it's with  the lights that the floating window is not so dark.  Again another view and again with the floating window automatically applied and finally this  is a 20 seconds movie of our scene created with the floating window procedurally generated  in each frame at the correct size.  So to again more than 3,000 of buildings and 170 triangles created procedurally.  Obviously you can create everything you want maybe apply the same techniques.  Very final remarks, the techniques are promising you can do whatever you want so you have the  tools.  If you have the tools since the beginning you can do whatever you want.  If you don't have a better integration of stereoscopy inside the production pipeline  you will be limited.  In case of the open source tool you can apply the modification or you can communicate with  the community developing the tools.  In case of a proprietary production tools there is the need of some discussion and collaboration  with the developers.  Thank you for your attention just finishing the joke.
SD_A_2016__Stereoscopy-based_procedural_generation_of_virtual_environments_wCiqmDjl14g_0_335.png SD_A_2016__Stereoscopy-based_procedural_generation_of_virtual_environments_wCiqmDjl14g_336_1859.png SD_A_2016__Stereoscopy-based_procedural_generation_of_virtual_environments_wCiqmDjl14g_1860_2843.png SD_A_2016__Stereoscopy-based_procedural_generation_of_virtual_environments_wCiqmDjl14g_2844_3491.png SD_A_2016__Stereoscopy-based_procedural_generation_of_virtual_environments_wCiqmDjl14g_3492_3539.png SD_A_2016__Stereoscopy-based_procedural_generation_of_virtual_environments_wCiqmDjl14g_3540_3635.png SD_A_2016__Stereoscopy-based_procedural_generation_of_virtual_environments_wCiqmDjl14g_3636_3731.png SD_A_2016__Stereoscopy-based_procedural_generation_of_virtual_environments_wCiqmDjl14g_3732_4007.png SD_A_2016__Stereoscopy-based_procedural_generation_of_virtual_environments_wCiqmDjl14g_4008_4859.png SD_A_2016__Stereoscopy-based_procedural_generation_of_virtual_environments_wCiqmDjl14g_4860_4943.png SD_A_2016__Stereoscopy-based_procedural_generation_of_virtual_environments_wCiqmDjl14g_4944_5711.png SD_A_2016__Stereoscopy-based_procedural_generation_of_virtual_environments_wCiqmDjl14g_5712_6311.png SD_A_2016__Stereoscopy-based_procedural_generation_of_virtual_environments_wCiqmDjl14g_6312_7139.png SD_A_2016__Stereoscopy-based_procedural_generation_of_virtual_environments_wCiqmDjl14g_7140_8531.png SD_A_2016__Stereoscopy-based_procedural_generation_of_virtual_environments_wCiqmDjl14g_8532_9323.png SD_A_2016__Stereoscopy-based_procedural_generation_of_virtual_environments_wCiqmDjl14g_9324_9383.png SD_A_2016__Stereoscopy-based_procedural_generation_of_virtual_environments_wCiqmDjl14g_9384_10235.png SD_A_2016__Stereoscopy-based_procedural_generation_of_virtual_environments_wCiqmDjl14g_10236_11759.png SD_A_2016__Stereoscopy-based_procedural_generation_of_virtual_environments_wCiqmDjl14g_11760_12359.png SD_A_2016__Stereoscopy-based_procedural_generation_of_virtual_environments_wCiqmDjl14g_12360_12995.png SD_A_2016__Stereoscopy-based_procedural_generation_of_virtual_environments_wCiqmDjl14g_12996_15011.png SD_A_2016__Stereoscopy-based_procedural_generation_of_virtual_environments_wCiqmDjl14g_15012_16967.png SD_A_2016__Stereoscopy-based_procedural_generation_of_virtual_environments_wCiqmDjl14g_16968_19931.png SD_A_2016__Stereoscopy-based_procedural_generation_of_virtual_environments_wCiqmDjl14g_19932_22883.png SD_A_2016__Stereoscopy-based_procedural_generation_of_virtual_environments_wCiqmDjl14g_22884_23831.png SD_A_2016__Stereoscopy-based_procedural_generation_of_virtual_environments_wCiqmDjl14g_23832_24623.png SD_A_2016__Stereoscopy-based_procedural_generation_of_virtual_environments_wCiqmDjl14g_24624_26819.png SD_A_2016__Stereoscopy-based_procedural_generation_of_virtual_environments_wCiqmDjl14g_26820_27287.png SD_A_2016__Stereoscopy-based_procedural_generation_of_virtual_environments_wCiqmDjl14g_27288_28043.png SD_A_2016__Stereoscopy-based_procedural_generation_of_virtual_environments_wCiqmDjl14g_28044_28451.png SD_A_2016__Stereoscopy-based_procedural_generation_of_virtual_environments_wCiqmDjl14g_28452_28763.png SD_A_2016__Stereoscopy-based_procedural_generation_of_virtual_environments_wCiqmDjl14g_28764_29171.png SD_A_2016__Stereoscopy-based_procedural_generation_of_virtual_environments_wCiqmDjl14g_29172_29291.png SD_A_2016__Stereoscopy-based_procedural_generation_of_virtual_environments_wCiqmDjl14g_29292_31163.png SD_A_2016__Stereoscopy-based_procedural_generation_of_virtual_environments_wCiqmDjl14g_31164_32051.png SD_A_2016__Stereoscopy-based_procedural_generation_of_virtual_environments_wCiqmDjl14g_32052_32481.png