Today in class I presented a project which I have been working on, on and off, for several years. It is a visualization of the Schatz linkage. You can access the webstart I showed here. The video I showed at the beginning of the class can be seen here. The pictures of the wooden oloid which Thomas Neukirchner made can be found here. Thomas’s diagrams and plywood models of the oloid can be found here. The latest edition of Paul Schatz’s book Die Welt ist Umstülpbar: Rhythmusforschung und Technik can be found here on Amazon. If you are interested in this theme then mark your calender for April 4-6, when there will be a weekend event in Berlin devoted to themes related to Paul Schatz’s research. A few more details can be found here.
On Thursday, Jan. 9, we will take some time to evaluate this “project presentation” in regard to the various criteria mentioned in the evaluation handout. Be there or be square! I will also discuss the half-edge data structure and demonstrate some advanced features of the discretegroup package, and, if time permits, more!
Assignment 6: As discussed in class on our final meeting before the holidays, the next assignment is not a programming assignment but rather a planning assignment. I ask you to enter a description of your project as a comment to this blog post. Use the account name studentmv with the clever password. Please sign your comment with either your name(s) or with your student number(s). Your comments are due as usual on Friday at midnight. (That’s Friday Jan. 10). The details of the description are provided below, but first comes a “news flash” regarding a change in the way property files are handled in the basic template.Assignment class.
Improved way to provide property files. Although I didn’t do much work over the holiday break, I did play around some with webstarts — enough to realize that the current way that property files are handled doesn’t work with webstart technology. So I’ve figured out a new way to handle property files that does work with webstarts, and has other advantages. Here’s how it works:
- If you have a class named MyAssignment.java that inherits from template.Assignment, then store off the properties in a file named myAssignment.xml (note the leading lower case letter!) in the same folder as MyAssignment.java. Implement the method getPropertiesFile() to return null. Or, remove your implementation of the method, it’s no longer an abstract method and by default it returns null.
- That’s all you have to do. Now your class should read the property file correctly whether run “normally” or as a webstart application (which your project application will ultimately need to do).
- Please try this out to make sure it works for you — if you don’t change anything the old code will continue to work but you should get used to using the new approach.
What to include in your description.
- Mathematics. The description should begin with the mathematical content of the project. Try to be as precise and accurate. Zoom in gently — make clear to which domain of mathematics this content belongs. Use technical language if necessary to specify this. If possible, include one or two references (either articles or books) which provide a more detailed description of the context of your project. None of the projects exists “in a vacuum”, give a pointer to your point(s) of departure.
- Software design. Begin this section by a statement describing the concrete goal of your project. For example, “We intend to create an application to allow the user to explore the 3-dimensional kaleidoscopes introduced above [in the mathematical section].” Describe then the software tools and building blocks you think you will need in order to realize this aim, and how they will be put together. For example, building blocks might include “jReality geometry factories, the de.jtem.halfedge package, and the de.jtem.discretegroup package”; additionally indicate which parts of these building blocks you will use and how they will be combined. Think if this as the blueprint for your project. Of course at this stage of the planning it shouldn’t be too detailed.
- User experience. Finally, briefly indicate how you envision a typical “usage cycle” of your program. What choices does the user have, how can he/she interact with the software sketched in the previous section? Can the user save the state of the program from one invocation to the next? Will you rely on sliders and dials, or have you ideas for innovative interactive tools? Will your application be particularly aimed at the PORTAL? Will there be a connection to 3D printing?
Our aim is to write a program which gives the user the opportunity to create Escher tiles out of a simple chess pattern and additionally color them.
The Mathmatics behind it is similar to the mathmatics behind assignment 4 with the discrete groups and the problem that the brush will have to paint across tiles, what will be more complicated to solve because the boundaries will no longer be fixed, nor straight lines.
The software will probably use the wallpaper class, the discrete groups class, a tool for checking what the mouse clicks and dragging points and connecting the points with a line to represent the boarder of the tile.
Like stated above the user will click to drag the boundary or click to paint the tiles to form any desired form of not-to-complex and colored Escher pattern.
By Sophia (No. 18) and Martin (No. 28)
MATHEMATICAL BACKGROUND
We want to engange into stereograms.
To some extend stereograms belong to the wallpaper group. However the repetative patterns are distorted such that – staring at it in the right way – one gets the impression of depth in space.
This is a simple example:
http://www.3dwonderstuff.com/Images/optical_illusions/stereogram_oi_dots_l.jpg
When focusing on a distant point while looking at the screen, neighboring columns of red dots will overlap and each second dot appears to be elevated from the screen. This phenomena can be applied to more complex figures:
http://hidden-3d.com/img/posters/lot-02/guardian_of_past_sm.jpg
In mathematical terms we will be dealing with maps between the three dimensional JReality space and the two dimensional stereograms. A special challenge of our project is to not only find this map but also to visualize correct physical behavior within stereograms.
SOFTWARE DESIGN
We aim at developing a game which can be enjoyed using stereogram view. The goal of the game is to balance a ball on a plane, controlled by the player.
To implement motions of the ball and plane it will be necessary to render stereograms in real-time, which can only be achieved with a graphics accelerator (GPU). This graphics accelerator has its own programming language which we will have to learn and combine with JReality.
USER EXPERIENCE
We have many ideas to improve the game for user experience which we would attempt once we finished developing the basic game.
The game is supposed to start with a welcoming screen that offers different options:
> game start
> configuration menu (multiplayer mode, different skill levels et cetera, enable/disable stereogram mode)
> tutorial mode (how to see stereograms and play the game)
> more information about stereograms
To increase gaming difficulty the game may include:
> holes in the plane
> bumps on the plane
> FogOfWar (limited sight)
> dangerous monsters that may eat the ball
> winds
> special fields such as SpeedBoost, ReversedArrowKeys, random effects and combined with music
> and much much more…
There will be no connection to PORTAL, 3D printing or data saving.
Cheers, Hardy (No. 09) and André (No. 26)
Tessalations and Caleidoscopes
We want to explore how one can create space-filling Tessalations with the help of techniques to fill out the Eucledian space with space groups, for example the 3D Kaleidoskop. It is generated by 4 mirror planes arranged in the right angles.
The math part includes finding out which geometric forms allow for this approach as a fundamental region.
How can this region be filled/divided in order to obtain neat quasi-regular (maybe the whole) space-filling patterns.
See https://de.wikipedia.org/wiki/Parkettierung#Arten_der_3D-Parkettierung for a list of examples for these space filling patterns.
We plan to create the necessary fundamental domains by bounding regions with cutting planes. Then we take advantage of the DiscreteGroup class and let it do the rest.
User experience:
The user should be able to learn more more about space-filling patterns and the space symmetry group they are based on.
Gerald Bartz and Peter Kleisinger
Mathematics:
We want to group discrete mathematical objects by their symmetries.
Given:
– a mathematical object (e.g. a cube) X
– a number of colours C
– generators of a symmetry group G
We seek to colour the mathematical object in all possible ways with the given number of colours and group them in such a way, that objects differing by group action of the given symmetry group are equivalent.
Algebraic way to express: We seek the orbits of C^X under the action of G.
Example: Consider we want to colour the 6 faces of a cube in 2 different colours. There are 2^6 different possibilities to colour the cube. As group action we allow to turn the cube by 180 degree. This corresponds to a rotation of order two around one of the three axes connecting the middle points of two opposite faces. Now we group the coloured cubes. We find, for example, in the same group the cube that has all faces coloured in colour 1 and the front face in colour 2 and the cube with all faces in colour 1 and the back face in colour 2, since they are equivalent by turning the cube.
Polya theory allows us to calculate the number of groups (orbits). We want to visualize the orbits and the elements of each orbit. We plan to encode the mathematical object as a permutation and apply a certain group action by changing the permutation. Two elements are equivalent, iff the permutations are the same.
Objects we plan to consider:
– Colouring of vertices and edges of “necklaces”
– Colouring of vertices, edges and faces of a cube
http://en.wikipedia.org/wiki/Pólya_enumeration_theorem
Software Design:
We aim to create an application to allow the user to explore the different orbits of a given mathematical object under a certain group action. Concerning the layout, we plan to start with the application for the platonic solids introduced by Dr. Gunn and adapt it to our wishes. The details will be given at a later stage of our project.
User experience:
The user is allowed to chose a specific mathematical object, to chose among given group actions for this object and a set of colours. Then she will see the different orbits represented by one element each. Clicking on one of them, the user will experience the wide range of different elements within. Further he can be shown how each of the elements will be transformed into the representative element.
It might be, that the user has to be well, a bit patient…
students 15 & 22
Packing circles on a cylinder
A common optimization problem is to fit shapes onto a plane, such that the encompassing area is minimal. Consider, for example, a trailer on which logs (assumed to be perfectly round) are to be placed. The trailer is of a fixed width, but open topped. The logs have different radii. The problem is to minimize the height, while also storing all the logs. A “dual” problem is cutting shapes out of a rectangular sheet while minimizing residuing material. Instead of the box or rectangle considered in the above examples, we intend to place randomly generated sets of circles on a cylinder and minimise its height. To our knowledge this hasn’t been done, but similar topics have been studied, e.g. by Huang et al. (2005) [1].
In nature, structures are often optimal in a sense of space conservation, hence we assume the solutions of the studied problem to be aesthetically pleasing.
By materializing the arising shapes through 3D printing, we hope to create decorative objects that could serve as lamp shades or vases.
It is our intention to enable the user to set the expected sizes of the circles by specifying a random distribution. Then, after running the optimizer, the packing is presented both in 2D and 3D and can be stored for later access.
In a typical use case, the user first specifies the distribution and then lets the algorithm run. Since the computation can take quite some time, there shall be the option for the program to keep packing ever new sets of circles, until told to stop. Thereby the program can work overnight. Subsequently the user can look at the generated packings without delay and can store some for later use.
Technically, the optimization algorithm is at the core of the project. The resulting patterns shall be visualized in 3D and 2D using the viewing facilities from jReality. Besides that, there are features like the storage of the patterns, the preparation for printing by giving the circles volume, removing intersections and finally the export to the STL 3D format (provided by jReality).
[1] Huang et al. (2005), Fulltext
Michael (08) & Nick
Sphere-Handling Interface of Escher-Like Drawings
by the Agents 17 & 23, Viktoria and Juliane
Mathematics:
The graphic Artist M.C. Escher is well known amongst mathematicians for his artistic visualization of symmetry groups by tessellating a plane with known objects like fish or lizards leaving no gaps or overlaps.
We want to focus on another, less known part of Escher’s work: three-dimesional tessellations of a sphere where one can change the boundaries of a fundamental domain in order to create own Escher-like tilings.
As in the plane there are many different symmetry groups on spheres. The basic knowledge on this topic may be found in „The Symmetries of Things“ by John Conway.
We will restrict ourselfes to the spherical groups based on platonic solids and the sperical friese groups which have no mirror symmetries as these are very uninteresting in our context (you can‘t change a boundary which is a mirror without violating the nature of a tessellation). If you change the boundary of a fundamental domain at some point this has consequences for other areas of the boundary as these may change as well according to the chosen symmetry group.
In „Escher Sphere Construction Kit“ (www.cs.utah.edu/npr/papers/Yen_I3D.pdf), Jane Yen and Carlo Séquin already faced this challenge for spherical groups based on platonic solids by changing the basic tiles to arbitrary polygons. We want to go further and thought about the use of Bézier-curves to interpolate the point wise defined edge of our fundamental domain to smooth it. Therefore we have to learn about three-dimensional Bézier-curves and how to restric them to lie on the sphere.
Software design:
We intend to build an interactive program allowing the user to make his own changes to a given fundamental domain. The changes are then applied to the whole tessellation of the sphere with this particular fundamental domain – changing one means changing all. We thought about using the scene graph component package of jReality to realize the cloning for the tessellation. As a basis we want to use Assignment 5 from Dr. Gunn for symmetry groups on spheres. We are not sure yet how to implement Bézier-curves on a sphere, maybe with the bezier-triangle patch.
User experience:
With our Sphere-Handling Interface of Escher-Like Drawings we want to explain the problem to users, who never worked with the mathematical aspect of this kind of art before. We start with a short written guide beforehand as well as a simple step-by-step explanation of our interface. The user then chooses the symmetry group he or she wants to work with and changes the given fundamental domain arbitrarily, either directly on the sphere or in an extra area displaying only one single tile for a better view. Whilst manipulating a fundamental domain the whole tessellation adjusts automatically. There will be an option whether to use piecewise linear defined curves or smooth Bézier-curves for the changed edges. Once the user has finished he or she is given the possibility to save the progress so it is possible to get back and work on that specific object later. We hope to print the created Escher-sphere as a three-dimensional object.
This project will create an interactive learn tool aimed at undergraduate
students studying complex analysis and being confronted with the many faceted concepts of function theory for the first time. The tool will focus on visualising complex functions through the method of Domain Colouring, helping students explore some of their fundamental properties, in particular the behaviour near singularities.
1 Mathematics:
Most of the mathematical background and the inspiration of the project is found in the paper by Konstantin Poelke and Konrad Polthiery entitled Lifted Domain Coloring from the Freie Universit¨at Berlin. The idea is to encode information of a complex function by mapping the function value to a point in HSB-space, and plotting this onto the function domain. A point in HSB-space, meaning hue,saturation and brightness can be associated with a point in the solid sphere B1( 1), the coordinates (r, , ) give values for saturation, hue and brightness. By using a suitable projection from the complex plane to the sphere and then to HSB-space one defines a mapping from the image of the domain under a fuction to point in the colour space.
B1 = {r(cos cos ; cos sin ; sin )|0 <= r C ( the complex function), col : B1 –> HSB the mapping
from the sphere to the colour space and p : f(D) –> B1 the projection. For
our purposes we will consider the stereographic projection (so r = 1) and would like to incorporate a visualisation tool, allowing the user to understand the intermediate step, from the complex plane to the sphere- Since the end image depends upon the projection used if time allows we would like to explore other projections. Additionally the function col should not necessarily be fixed, so that the user has an opportunity to simplify or customise the image as necessary.
Over the aspects of actually creating the image we would like the software
tool to have a strong didactic focus. This means for a given f : D –> C
the Laurent expansion would be calculated, singularities categorised and conformity investigated. Mathematically speaking many fundamental definitions and properties or meromorphic functions and complex functions in general will be handled.
2 Software Design
Our project on a basic level will need to be able to read in a function given
by the user. Calculate the function values on a given domain, i.e. on the part
which will be plotted. Then, project these values onto the solid sphere using (for starters) the standard sterographic projection, display the sphere with this projection.
Map the stereographic projected function values onto the HSB-Space,
plot these values onto the display frame. Reading in a given function could be rather challenging and could mean accepting several restiction to the functions which the tool can interpret. Within the package jtem complex addition and multiplication etc. are already defined so we will use this package to evaluate the functions. On the jRelaity webpage there is a demo to the stereographic projection, so we are hoping that most of this part can be ”stolen” from Dr. Gunn. We will need the jReality scene graph, in particualar the CommonAttributes class with texture coordinates, to help describes the points on the plot. I imagine each point to have a series
of attributes, function value HSB-Space coordinates etc. Of course the general aspects of the scene graph we will also need such a camera and lighting aspects. We want the software to be interactive so will need a tool bar- there should be for example a zoom tool. Addtionally for the beginning demos it would be nice to have some animation and timed prompts. The picture itself should be interactive and for this we start with the de.jreality.tools package.
3 User experience
As already stated, this project will be to create an interactive learn applet for
use by undergraduate mathematics student. There are aspects of the program the user must learn in order to firstly understand the pictures displayed and secondly use the software tool itself. For the first hurdle, we want to include a window displaying the domain colouring of the unit sphere, this will be essentially displaying the col function and will be a point of reference for beginner users, it will also allow the experienced user to visualise customised col functions. The tool will include several examples with which the user can understand the domain coloring map, these example will be given in a tutorial style whereby the user can be prompted to look at particular aspects of the picture and how this relates to the function. For example the function f(z) = 1/(z−i)2 has a double
pole at z = i, how can this be seen from the domain colouring map? (The
colour shades wrap around the point z = i on the domain twice, i.e. one see
each colour twice along a loop around this point). Types of singularities and
conformity will be discussed here with respect to their corresponding affect on the domain colouring image.
The tool will also function interactively. The user will see the domain colouring map, stereographic projection of the image of the function, tool display and additionally the domain colouring map of the col function if required. For the tool display we wish to include the given function and its type, the positions of any zeros or poles and their order, branch cuts and the Laurent series. The user can change the function as is wished, new functions can be plotted additionally so that the domain colouring maps could be compared. The user can use the Laurent series expansion about a point and choose to plot this for a given maximum and minimum index.
If time permits we would like to make the domain colouring maps themselves interactive. The user could choose on the map points to be poles or zeros and from this create and image from a simple rational function having these properties. Alternatively it could be possible to drag function values across the domain, i.e. with the mouse physically drag a singularity to another position. How far this makes sense or is possible is still to be considered but we are interested in going in this direction!!
Student 003&25 (Rhoslyn & Lisa)
Conway’s Game of Life
In our project we want to implement Conway’s Game of Life on a fundamental region and want to give the user the ability to experience how different symmetry groups of this region affect the behavior of the game.
Mathematics
Conway’s Game of Life is a cellular automaton where every cell can either be alive or dead. Given an initial state the evolution of the cells is determined by rules telling when a cell gets alive or stays alive (or is dead). These rules only depend on the states of the neighbors of each cell. Read more: http://en.wikipedia.org/wiki/Conway's_Game_of_Life
The interesting part is to figure out where the neighbors of a cell next to the boundary are. Therefore we will use different wallpaper symmetries, which will cause different neighbors, of course. It is similar to the painting tool in Assignment 4.
Software design
The main part of our project will be to create a data structure that handles the different wallpaper symmetries in a nice and easy way, i.e. a structure that can calculate the neighbors of a cell.
User experience
The user should have as many options as possible to select various settings to figure out how Conway’s Game of Life can be changed and how it will behave with different settings.
Therefore the user will probably be able to select/change the rules for a cell. (When will it stay alive, when will it get alive? Possibly a cell can have more states than just dead/alive?)
Surely he/she will have the option to select the different wallpaper symmetries as well as the initial state of the cells.
A nice feature would also be that the user can put different precast patterns onto the grid.
Students 11 & 21
Our project focuses on tilings of the plane
Strange attractors
————————
Students 20 and 24 (Alex and Peter)
Mathematics:
We want to clarify, when an attractor can be called strange. Our intention is to visualize some (strange) attractors and characterize their different properties (e.g. the Ljapunow exponent or the dimension). Maybe animations can help to show, why they are called so.
Software design:
Our data structure can’t be that complex, because jReality can’t handle too much information fast enough (like thousands of vertices). Given that knowledge, we’re going to use simple and small classes like IndexedLineSet for lower memory usage and faster rendering.
As we want quick calculations of the differential equation systems, we are going to test some librarys considering their calculation time.
Maybe we will add support for strange attractors that are not based on differential equation systems like the Hénon attractor.
User experience:
The topic should be presented as easy as possible to the user, although he should have lots of capabilities: different attractors, freely selectable parameters (within given bounds), …
The user should be able to interact with the dynamical system and explore the mathematical chaos without a complex GUI.
We are not planning the usage of the PORTAL or 3D printing.
Unfolding textured polyhedra
Our program is supposed to be a practical application using mathematical methods and algorithms. The function is roughly described as follows: the user chooses one of his beloved 360° degree pictures that he/she will then see mapped on a sphere. After choosing one of the offered convex polyhedra, the image will be mapped 1-to-1 onto it. Now comes the clou – our application will unfold this polyhedron into the plane! As well, our goal is to provide little pieces of new white faces so that the user can print out his/her net of the polyhedron with the own picture on it and get a three-dimensional polyhedron back by cutting and gluing with the help of the new white faces.
Researching for the project we found out that the mathematics behind it is really interesting and quite extensive! Using already existing code to map the picture onto the sphere, the first problem is how to map the sphere with the picture accurate onto the polyhedron. The next problem is how to enfold it. We found out, that it isn’t even proven yet, that this is always possible (but it is expected to be so). There is an algorithm which handles most of the cases – the construction of an example where it failed wasn’t easy. However, since the user is only able to choose between the more or less “famous” convex polyhedra which we will offer, this problem shouldn’t bother us too much. Luckily the algorithm needs an “objective function” as an input which we will use to allow the user to write as an input (or randomly chosen). In that way, the randomness will produce different unfolding for the same polyhedron – or maybe even not an unfolding at all because of overlaying parts.
Since we are dealing with projections, polyhedra and nets/trees, the mathematical background is rather wide. The algorithm we will use was presented in the diploma thesis “Nets of Polyhedra” by W. Schlickenrieder at the TU Berlin (!) in 1997. We expect to use geometry factories, half-edge data structure and matrices for the unfolding to realise our project. All in all, we are already looking forward to hold our first printout in our hands!
— students 06 & 29
A tiling of R^2 is a collection of subsets {T_1,T_2,…}, of R^2, the tiles, s.t.
1. Each tile is homeomorphic to the closed unit disc.
2. Every point of R^2 is contained in at least one tile.
3. The interiors of the tiles are pairwisely disjoint.
4. The tiles are uniformly bounded.
This is a very general definition. We want to focus on tilings with only a finite number of “prototiles”, to which all tiles of the tiling are congruent. The most simple such tiling is probably the tiling consisting of rectangles.
If the rectangles have a 2:1 sidelength ratio such tilings are also called brick patterns.
In our application we would like to restrict ourselves to a certain number of prototyles which the user can choose from. After choosinf the prototile(s), the user shall try to put them next to each other such that they cover the plane without overlapping. When he has managed to do that, he shall be given the possibility to detect symmetries in the ocurring pattern.
We want to use the existing package for the wallpaper groups and also maybe parts of last year’s project OrbiTrain where one could guess the symmetry group of a given wallpaper pattern.
Ingo Güring and Michael Joos
The ´sounding room`
Imagine that you find yourself blindfolded and standing in the middle of a room; your first option would be shouting (“is anybody here?”) and waiting the walls to reflect your words, sooner or later. Imagine also that the four walls are not usual solid walls, but “magical walls” that are, somehow, mutually identified, which transform our room into a fundamental domain of some identification space. How would you hear the reflection of your own words? This is the aim of our project: the real-time simulation of the sound propagation inside an identification space.
A few specifications of our “room model” are firstly required. Regarding the mathematical background, we propose a bidimensional model as initial approaching. Since we are only interested on standard four-wall rooms, the algebraic structure of our spaces will be given by the six wall-paper groups whose fundamental domain can be shown as a square, namely o, 22X, *2222, **, xx and 22*, in orbifold notation. Hence, with the support of the discretegroup library, we will construct the 3D visualization of our room as the product of each domain and a closed interval, additionally equipped with a set of textures that would give us visual information about the chosen space, whereas the stereo sound panorama will only come from the 2D identification properties.
With respect to the sound propagation, let us consider separately the sound source and the microphone, i.e. “our ears”. Since an explicit calculation of the sequence of theoretical reflections and/or identifications of a wave inside the room where we live would be at least hard to get, our construction will use the fact that this model can also be thought as an unique sound wave from an unique source located in a chosen “main room” and traveling freely through the consequently tessellated plane, with a correctly located microphone inside each room. According to this, the sound we perceive at a time will be obtained as the “sum” of the sound perceived by “all the copies of our ears” at this time along the tessellation, with a proper attenuation. The discretegroup library should be the responsible for the appropriate location of the set of microphones along the tessellation, and the classes DistanceCue and DelayPath should manage the panorama and amplitude of the signal recorded by each microphone.
According to this construction, a typical user of our program will be firstly required to choose a group, election that apparently will only determinate the texture of the walls of the unique room he can see, the so-called main room. Then, he will be able to move himself and/or the sound source (which could be also himself or an independent element) freely inside this room, while hearing the reflected and/or identified sound propagation. Additionally, the user could be allowed to leave the main room and wander around the “labyrinth” of rooms formed by the tessellation.
Luis Vera
Assignment 6 Project: Shadows
Student07
Mathematics.
In this project, as part of Differential Geometry, I will work on “shadow boundaries”. If one puts a light source vector on a smooth 3-d surface, then the surface is divided in two regions: the region that contains points that face away from light source, the ones within the light source, and the shadow frontier, i.e. the points on the surface that contain the light vector in their tangent plane. \\
Formally, let $M$ be a closed oriented $2-$dimensional manifold, $f:M\rightarrow \mathbb{R}^3$ be a smooth immersion into Euclidean $3-$space and $n:M\rightarrow S^2$ be a unit normal vector field, or the Gauss map, induced by $f$. Then for every unit vector $u\in S^2$ (corresponding to the direction of light) the shadow, $S_u$, is defined by
$$S_u=\{p\in M: > 0\}$$
where $$ denotes the dot product.
We will explore the problem set by H. Wente on 1978 and the paper “SOLUTION TO THE SHADOW PROBLEM IN 3-SPACE” by Mohammad Ghomi.
Software design \\
With this project we will visually see some examples that $f$ is a convex embedding, i.e. $f$ maps M homeomorphically to the boundary of a convex body, if and only if $S_u$ is simply connected for each $u$. We will use jReality geometry factories, in particular ParametricSurfaceFactory, and we will
dynamically generate textures using a bitmap drawing library to create a texture that will reflect a shadow boundary on a parametrized surface.
User experience \\
The user can choose the light vector direction, a surface from a list and rotate the view of the surfaces, while seeing the results of the shadow and the boundary of this set. The user will see examples of surfaces that create simple connected shadow boundaries and surfaces that doesn’t.
S_u=\{p\in M: > 0\}.
3D-Kaleidoscope (spherical / hyperbolical Version)
User experience:
We would like to create a 3D-kaleidoscope which uses spherical and hyperbolic geometry. The kaleidoscope should mirror a certain 3-dimensional region (the interior of a tetrahedron) such that it creates an infinate space containing interesting objects. The user can discover how it would be like to live in a hyperbolic/spherical world, therefore it might be great to use the portal. When will you ever get the chance to be in a hyperbolic/spherical room again?!
We want to integrate different kinds of kaleidoscopes the user can choose from and a list of special positions. A rotate tool and maybe a tool to deform the object inside the kaleidoscope would be an interactive feature.
Math:
– spherical and hyperbolic geometry / trigonometry
– To get different kaleidoscopes we need to show different groups, we have to calculate 4 mirror planes per group
– We would like to give the possibility to put a piece of pipe into the fundamental domain and discover which curves can be produced and which properties they have.
– With the pipes one can visulize interesting properties of those spaces.
Software design:
– We want to use the classes DiscreteGroup, SceneGraphComponent and a starting version we got from Mr Gunn
– The user can choose predefined objects to put inside and we want to make up a way how one could deform them (that might be a piece of a pipe)
– we would like to have different camera positions and maybe a “flight” through the created space.
Lina (12) & Lisa (05)
Students 04 & 19
Our project can be seen as a generalization of assignment 4.2. where we had to adapt the behaviour of the PaintBrush, when it came next to the boundaries of the fundamental region.
The symmetry groups were frieze groups. In our project we use spherical groups instead. This leads to a fundamental region with the shape of a pillow.
For each group we will provide a visualization of the fundamental domain and one of the whole solid. The user is then able to draw on the f.d. and this is projected to the solid or vice versa.
The most complicated part (mathematically) is going to be the 3D Visualization of the fundamental domains.
We will use the PaintBrushTool to draw on the figures, the RotateTool so that the user can see how the drawings are multiplied, and to create the 3D model of the fundamental domain we will work with a u-v-space similar to how we worked in assignment 3.
At this point, we plan to implement the seven polyhedral groups.
Perhaps, we could 3d-print one of the solids.
Pingback: Course Log | Mathematical Visualization