user_guide:tutorials:visual_tutorial

This tutorial is probably also available as a Jupyter notebook in the demo folder in the polymake source and on github.

Different versions of this tutorial: latest release, release 4.11, release 4.10, release 4.9, release 4.8, release 4.7, release 4.6, release 4.5, release 4.4, release 4.3, release 4.2, release 4.1, release 4.0, release 3.6, nightly master

Tutorial for Visualization

This tutorial contains some examples for the visualization of the different objects dealt with in polymake.

Intro

The most straightforward way of visualizing things in polymake is by using the VISUAL method that visualizable objects provide. For example, you can look at the 3-simplex by doing this:

> simplex(3)->VISUAL;
unnamed
Transparency
depthWrite
Rotation
x-axis
y-axis
z-axis
Rotation speed
Display
Objects
Camera
SVG
Download
New tab

By default, this will open jReality and show you a tetrahedron in a pretty color. See the visual_tutorial#Backends section for more information on using other backends.

To get a list of visualization methods available, you can use the build-in help system. To obtain the visualization possibilities for, e.g., Polytopes in application polytope, type:

> help 'objects/Polytope/methods/Visualization';
 These methods are for visualization.
 
-------------------
Subtopics of polytope/objects/Polytope/methods/Visualization:
GALE, SCHLEGEL, VISUAL, VISUAL_BOUNDED_GRAPH, VISUAL_DUAL, VISUAL_DUAL_FACE_LATTICE, VISUAL_DUAL_GRAPH, VISUAL_FACE_LATTICE, VISUAL_GRAPH, VISUAL_ORBIT_COLORED_GRAPH, write_stl
Subtopics of objects/Polytope/methods/Visualization:
GALE, SCHLEGEL, VISUAL, VISUAL_BOUNDED_GRAPH, VISUAL_DUAL, VISUAL_DUAL_FACE_LATTICE,
VISUAL_DUAL_GRAPH, VISUAL_FACE_LATTICE, VISUAL_GRAPH, VISUAL_TRIANGULATION_BOUNDARY

Most visualization methods provide a variety of parameters. Get a list for the method of yout choice (here: VISUAL) by typing

> help 'objects/Polytope/methods/Visualization/VISUAL';
VISUAL(Options) -> Visual::Polytope
 
 Visualize a polytope as a graph (if 1d), or as a solid object (if 2d or 3d),
 or as a Schlegel diagram (4d).
 
Options:  Attributes modifying the appearance of a set of polygons (like a polygonal surface).
  __FacetColor__ => Flexible<Color> filling color of the polygons
  __FacetTransparency__ => Flexible<Float> transparency factor of the polygons between 0 (opaque) and 1 (completely translucent)
  __FacetStyle__ => Flexible<String> if set to "hidden", the inner area of the polygons are not rendered at all
  __FacetLabels__ => String if set to "hidden", the facet labels are not displayed (in the most cases this is the default behavior)
  __EdgeColor__ => Color color of the boundary lines
  __EdgeThickness__ => Float scaling factor for the thickness of the boundary lines
  __EdgeStyle__ => String if set to "hidden", the boundary lines are not rendered
  __Title__ => String the name of the drawing
  __Name__ => String the name of this visual object in the drawing
  __Hidden__ => Bool if set to true, the visual object is not rendered
    (useful for interactive visualization programs allowing for switching details on and off)
  __PointLabels__ => String if set to "hidden", no point labels are displayed
  __VertexLabels__ => String alias for PointLabels
  __PointColor__ => Flexible<Color> color of the spheres or rectangles representing the points
  __VertexColor__ => Flexible<Color> alias for PointColor
  __PointThickness__ => Flexible<Float> scaling factor for the size of the spheres or rectangles representing the points
  __VertexThickness__ => Flexible<Float> alias for PointThickness
  __PointBorderColor__ => Flexible<Color> color of the border line of rectangles representing the points
  __VertexBorderColor__ => Flexible<Float> alias for PointBorderColor
  __PointBorderThickness__ => Flexible<Float> scaling factor for the thickness of the border line of rectangles representing the points
  __VertexBorderThickness__ => Flexible<Float> alias for PointBorderThickness
  __PointStyle__ => Flexible<String> if set to "hidden", neither point nor its label is rendered
  __VertexStyle__ => Flexible<String> alias for PointStyle
  __ViewPoint__ => Vector<Float> ViewPoint for Sketch visualization
  __ViewDirection__ => Vector<Float> ViewDirection for Sketch visualization
  __ViewUp__ => Vector<Float> ViewUp for Sketch visualization
  __Scale__ => Float scale for Sketch visualization
  __LabelAlignment__ => Flexible<String> Defines the alignment of the vertex labels: left, right or center
 
Options:  Attributes modifying the appearance of "wire frameworks".
 Unlike the rest, the flexible edge attributes are retrieved using the __edge iterator__ as an index/key/argument.
  __EdgeColor__ => Flexible<Color> color of the lines representing the edges
  __EdgeThickness__ => Flexible<Float> scaling factor for the thickness of the lines representing the edges
  __EdgeLabels__ => EdgeMap<String> textual labels to be placed along the edges
  __EdgeStyle__ => Flexible<String> if set to "hidden", neither the edge nor its label is rendered
  __Title__ => String the name of the drawing
  __Name__ => String the name of this visual object in the drawing
  __Hidden__ => Bool if set to true, the visual object is not rendered
    (useful for interactive visualization programs allowing for switching details on and off)
  __PointLabels__ => String if set to "hidden", no point labels are displayed
  __VertexLabels__ => String alias for PointLabels
  __PointColor__ => Flexible<Color> color of the spheres or rectangles representing the points
  __VertexColor__ => Flexible<Color> alias for PointColor
  __PointThickness__ => Flexible<Float> scaling factor for the size of the spheres or rectangles representing the points
  __VertexThickness__ => Flexible<Float> alias for PointThickness
  __PointBorderColor__ => Flexible<Color> color of the border line of rectangles representing the points
  __VertexBorderColor__ => Flexible<Float> alias for PointBorderColor
  __PointBorderThickness__ => Flexible<Float> scaling factor for the thickness of the border line of rectangles representing the points
  __VertexBorderThickness__ => Flexible<Float> alias for PointBorderThickness
  __PointStyle__ => Flexible<String> if set to "hidden", neither point nor its label is rendered
  __VertexStyle__ => Flexible<String> alias for PointStyle
  __ViewPoint__ => Vector<Float> ViewPoint for Sketch visualization
  __ViewDirection__ => Vector<Float> ViewDirection for Sketch visualization
  __ViewUp__ => Vector<Float> ViewUp for Sketch visualization
  __Scale__ => Float scale for Sketch visualization
  __LabelAlignment__ => Flexible<String> Defines the alignment of the vertex labels: left, right or center
 
Options:  Common attributes modifying the appearance of PointSets and all visual objects derived thereof.
 Please be aware that no one visualization program interfaced to polymake supports all of them.
 Unsupported options are normally ignored.
  __Title__ => String the name of the drawing
  __Name__ => String the name of this visual object in the drawing
  __Hidden__ => Bool if set to true, the visual object is not rendered
    (useful for interactive visualization programs allowing for switching details on and off)
  __PointLabels__ => String if set to "hidden", no point labels are displayed
  __VertexLabels__ => String alias for PointLabels
  __PointColor__ => Flexible<Color> color of the spheres or rectangles representing the points
  __VertexColor__ => Flexible<Color> alias for PointColor
  __PointThickness__ => Flexible<Float> scaling factor for the size of the spheres or rectangles representing the points
  __VertexThickness__ => Flexible<Float> alias for PointThickness
  __PointBorderColor__ => Flexible<Color> color of the border line of rectangles representing the points
  __VertexBorderColor__ => Flexible<Float> alias for PointBorderColor
  __PointBorderThickness__ => Flexible<Float> scaling factor for the thickness of the border line of rectangles representing the points
  __VertexBorderThickness__ => Flexible<Float> alias for PointBorderThickness
  __PointStyle__ => Flexible<String> if set to "hidden", neither point nor its label is rendered
  __VertexStyle__ => Flexible<String> alias for PointStyle
  __ViewPoint__ => Vector<Float> ViewPoint for Sketch visualization
  __ViewDirection__ => Vector<Float> ViewDirection for Sketch visualization
  __ViewUp__ => Vector<Float> ViewUp for Sketch visualization
  __Scale__ => Float scale for Sketch visualization
  __LabelAlignment__ => Flexible<String> Defines the alignment of the vertex labels: left, right or center
 
Options:  Options for visualizing objects with homogeneous coordinates like Polytope, PolyhedralComplex, SubdivisionOfPoints and PointConfiguration.
  __BoundingFacets__ => Matrix useful for unbounded polyhedra
  __Transformation__ => Matrix<Float> linear transformation, to be applied after dehomogenization
  __Offset__ => Vector<Float> shift, to be applied after dehomogenization and the linear transformation
 
Returns Visual::Polytope

The syntax for passing parameters can be seen in this example:

simplex(3)->VISUAL(EdgeThickness => 10);

It visualizes a tetrahedron with really thick edges. See the section on visual_tutorial#application polytope for more.

Specifying colors

Some visualization methods requite you to specify colors. There are various ways of doing this in polymake, i.e. the color red may be given by

  • the String 'red', which will be looked up in rgb.txt to obtain the rgb values,
  • the String '1 0 0', which contains three decimal values in the interval [0,1] corresponding to the 'r g b'-values of the color,
  • the String '255 0 0', which contains three integer values in the interval [0,255] corresponding to the 'r g b'-values of the color,
  • an object new RGB(1,0,0) of polymake's RGB class.

application polytope

The application 'polytope' contains a large amount of visualization routines. Most of them allow you to change the way things look a various ways. See the following subsections for examples.

Changing vertex attributes

It is possible to change the way the vertices are displayed directly from the command line. In the following we will explain how to change the color, labels, and size of the vertices.

Colors

There are different ways to specify the colors of the vertices. You may choose a single color for all vertices or set each vertex color individually.

Single color: To specify one color for all vertices use the VertexColor attribute of the VISUAL method:

> simplex(3)->VISUAL(VertexColor=> '0 100 200');
unnamed
Transparency
depthWrite
Rotation
x-axis
y-axis
z-axis
Rotation speed
Display
Objects
Camera
SVG
Download
New tab

You can also change the colors in the visualization backends (e.g. jReality). How to do this is explained below.

To set the colors of the vertices individually, you can either specify an array that contains a color for each of the vertices or a perl function, i.e. sub {...}, that returns a color depending on the vertex index.

Array of colors: Instead of passing one color to the VertexColor attribute, you can pass an array of colors:

> simplex(3)->VISUAL(VertexColor=>['red','green','blue','yellow']);
unnamed
Transparency
depthWrite
Rotation
x-axis
y-axis
z-axis
Rotation speed
Display
Objects
Camera
SVG
Download
New tab

The following line produces the same picture but each color is specified using a different color format:

polytope > simplex(3)->VISUAL(VertexColor=>['red','0 1 0',new RGB(0,0,1),'255 255 0']); 

See Specifying Colors for different ways to specify colors.

Function: You may also pass a function, i.e. a perl sub, to the VertexColors attribute that returns a color depending on the vertex index. The following line produces a tetrahedron with colors ranging from black for vertex 0 to yellow for vertex 3:

> simplex(3)->VISUAL(VertexColor=> sub { $x=shift; new RGB($x*0.33,$x*0.33,0); });
unnamed
Transparency
depthWrite
Rotation
x-axis
y-axis
z-axis
Rotation speed
Display
Objects
Camera
SVG
Download
New tab

Labels

The labels can be specified either by an array or a function that returns a label depending on the index of the vertex.

Array of labels: To label the vertices of a tetrahedron by A, B, C, and D we just pass the array ["A", "B", "C", "D"] to the VertexLabels attribute:

> simplex(3)->VISUAL(VertexLabels=>["A", "B", "C", "D"]);
unnamed
Transparency
depthWrite
Rotation
x-axis
y-axis
z-axis
Rotation speed
Display
Objects
Camera
SVG
Download
New tab

If you want to set only one label for example, you can do so by passing the empty string "" for the other vertices:

> simplex(3)->VISUAL(VertexLabels=>["", "", "My favorite vertex", ""]);
unnamed
Transparency
depthWrite
Rotation
x-axis
y-axis
z-axis
Rotation speed
Display
Objects
Camera
SVG
Download
New tab

Function: We may also write a perl function that returns a label depending on the index of the vertex. For example, if we want to label the vertices by their coordinates, we can use the following commands:

> $tet = simplex(3);
> $tet->VISUAL(VertexLabels=> sub { my $i = shift; return $tet->VERTICES->[$i]; });
tet
Transparency
depthWrite
Rotation
x-axis
y-axis
z-axis
Rotation speed
Display
Objects
Camera
SVG
Download
New tab

If you prefer dehomogenized float coordinates, then you need to use:

> $tet->VISUAL(VertexLabels=> sub { my $i = shift; return convert_to<Float>(dehomogenize($tet->VERTICES->[$i]));});
tet
Transparency
depthWrite
Rotation
x-axis
y-axis
z-axis
Rotation speed
Display
Objects
Camera
SVG
Download
New tab

Vertex Size

Similar to changing the colors using the VertexColor attribute you are able to change the sizes of the vertices via the VertexThickness attribute. Again, you may set the sizes of all vertices by a single value or use an array or a function to specify individual sizes.

Single size: To increase the size of the vertices, just pass a number larger than 1 to the VertexThickness

> simplex(3)->VISUAL(VertexThickness=>2);
unnamed
Transparency
depthWrite
Rotation
x-axis
y-axis
z-axis
Rotation speed
Display
Objects
Camera
SVG
Download
New tab

Array of sizes: As in the case of colors and labels, you may also specify individual sizes using an array:

> simplex(3)->VISUAL(VertexThickness=>[1,2,3,4]);
unnamed
Transparency
depthWrite
Rotation
x-axis
y-axis
z-axis
Rotation speed
Display
Objects
Camera
SVG
Download
New tab

Function: You may define a function that returns the size of the vertex depending on the vertex index. The following example sets the size of the odd vertices to 1 and the sizes of the even vertices to 2:

> cube(3)->VISUAL(VertexThickness=> sub { my $i = shift; if($i%2 == 0) { return 2; } else {return 1;} });
unnamed
Transparency
depthWrite
Rotation
x-axis
y-axis
z-axis
Rotation speed
Display
Objects
Camera
SVG
Download
New tab

If you do not want to display the vertices at all, you can use the VertexStyle attribute and set it to hidden:

> cube(3)->VISUAL(VertexStyle=>"hidden");
unnamed
Transparency
depthWrite
Rotation
x-axis
y-axis
z-axis
Rotation speed
Display
Objects
Camera
SVG
Download
New tab

Visualizing multiple polytopes

The following sequence creates a 0/1-cube and a translate. The final command triggers the joint visualization of both.

> $c1=cube(3,0);
> $c2=transform($c1,new Matrix<Rational>([[1,-1,0,0],[0,1,0,0],[0,0,1,0],[0,0,0,1]]));
> compose($c1->VISUAL,$c2->VISUAL);
c1
Explode
Automatic explosion
Exploding speed
Transparency
depthWrite
Rotation
x-axis
y-axis
z-axis
Rotation speed
Display
Objects
Camera
SVG
Download
New tab

If JavaView is used for visualization then Method:Effect:Explode Group of Geometries... allows to show an explosion.

application topaz

For information on how to visualize simlicial complexes and other topology-related objects, see here.

Backends

'polymake' provides different visualization backends: threejs, svg, jReality, JavaView, povray, postscript and even TikZ and Sketch are supported.

TikZ and Sketch

Sketch is a script language which produces TikZ output. It is quite sophisticated. There is a interface from polymake to Sketch.

> $my_polytope = cube(3);
> sketch($my_polytope->VISUAL,File=>"myfile.sketch");

When you downloaded the Sketch interpreter (link) you can use it to create your TikZ file via:

sketch myfile.sketch > myfile.tikz

The drawback is that the produced TikZ code is quite cryptic and not really readable or editable anymore. If you do want to create TikZ code which is easier to edit afterwards, you might want to use polymake's TikZ interface via:

> tikz($my_polytope->VISUAL,File=>"myfile.tikz");

For a different viewing angle you may use jReality. Rotate the polytope into the position you want and click the 'save view' button on the bottom of the jReality window. Then produce the TikZ or Sketch output.

jReality

The jReality viewer offers a versatile perspective for your favourite tools on 4 Panel which may be enabled/disabled on the toolbar or using the keyboard shortcuts Alt+Shift+(Up|Down|Left|Right) or the window menu. The “Visualization”, “Split geometries”, “Content Appearance”, and “Navigator” Plugin(usually in the Left- resp. Right-Slot) may be used to change the appearance of the displayed geometry. How to achieve your desired parameters is explained in the following section.

Appearance

There are several objects which control the appearance of a geometry in jreality:

  1. geometry attributes,
  2. appearances at a specific scene graph nodes, and
  3. the content appearance.

The most versatile point to set different parameters for the appearance is via geometry attributes. This is needed, for example, if every vertex of the displayed geometry should have its own thickness or color like in VISUAL_GRAPH→VERTEX_COLORS. These may only be edited via jreality's bean-shell, which requires knowledge of the jreality API and in particular the attribute handling.

An appearance at a scene graph node (every VISUAL object is put into one of these) may have its own appearance which stores single values for colors/thicknesses of vertices/edges/faces. Hence this does not allow, e.g., to assign a different color to each vertex. But editing is a little easier, since it is possible to use jreality's navigator. The navigator displays the entire scene graph. The polymake part of the scene graph starts with “root→content→Polymake Root”. The VISUALs are stored in separate geometry nodes with its appearances. In each of the appearance you find the RenderingHints and Shader that either inherit properties of the content appearance or override them with their own values. This is already much less tedious than using the beanshell.

The content appearance comes into play if no other appearances exist in the content subtree, i.e. neither specific node appearances nor geometry attributes. The sizes/thicknesses set in the content appearance are multiplied with the values of the specified values deeper in the tree, but colors will only apply if nothing else is set.

So to be able to change the colors of the faces/edges/vertices of the geometry using the content appearance you need to get rid settings in the other appearances and geometry attributes. This may be done using the “clear attributes” and “clear appearance” item of the polymake menu.

Save View

Clicking the “Save View” button on the bottom of the jReality window attaches a “ViewTransformation” matrix to your object (read this if you don't know how attachments work). It contains the transformaiton necessary to convert the coordinates of your object to the coordinates of the (possibly rotated, translated etc. by you in the interactive visualization) object as you currently see it. This information is then used by jReality and Sketch to display the object in exactly that way if you visualize it the next time.

ThreeJS

This is the default backend for 3D visuals and their only one in Jupyter-Notebooks. Due to ThreeJS's way of sorting objects in the z-buffer there are some unavoidable glitches for certain compositions when changing the camera position. Enabling the depthWrite option can help reducing them but it can also make things look worse for transparent objects. All other options are pretty self explanatory.

  • user_guide/tutorials/visual_tutorial.txt
  • Last modified: 2019/02/04 22:55
  • by 127.0.0.1