2. Working with Graphics Objects and Primitives

Graphics Primitives

Graphics primitives are simple geometric items which are often used to built more complex shapes. In Mathematica the primitives must be converted to a Graphics[] respectively Graphics3D[] object for visualization with the Show[] command.

Point

The primitive Point[{x,y}] respectively Point[{x,y,z}] represents a single point.

A point may have a diameter and color. The size and color attributes apply to all points following the attribute setting.

Three vertices of a planar triangle.	In[1]:= pt = Graphics[{PointSize[0.1], Point[{3, 0}], Point[{1, 0.3}], RGBColor[0, 1, 0], Point[{2, 1}]}]; In[2]:= JavaView[pt]
	Compare with Mathematica

Three vertices of a triangle in 3D.	In[1]:= pt3D = Graphics3D[{PointSize[0.1], Point[{3, 0, 0}], Point[{1, 0.3, 1}], RGBColor[0, 1, 0], Point[{2, 1, 0}]}]; In[2]:= JavaView[pt3D]
	Compare with Mathematica

Generate dots on a function curve from a set of points.	In[1]:= ptc = Graphics[Table[Point[{x, 2Sin[1/x]}], {x, -Pi, Pi, .01}], Axes -> Automatic] In[2]:= JavaView[ptc]
	Compare with Mathematica

Line

The primitive Line[{x1,y1},{x2,y2}] respectively Line[{x1,y1,z1},{x2,y2,z2}] connects two or more points with one or more straight line segments.

A line may have a thickness and color. The thickness and color attributes apply to all segments of a line.

Three lines form a planar triangle.	In[1]:= ln = Graphics[{Thickness[0.01], Line[{{3, 0}, {1, 0.3}, {2, 1}}], RGBColor[1, 0, 0], Line[{{2, 1}, {3, 0}}]}]; In[2]:= JavaView[ln]
	Compare with Mathematica

Use Line[] to generate a function curve as polygon.	In[1]:= lnc = Graphics[{RGBColor[1, 0.7, 0], Line[Table[{x, 2Sin[1/x]}, {x, -Pi, Pi, .01}]]}, Axes -> Automatic]; In[2]:= JavaView[lnc]
	Compare with Mathematica

Rectangle

The primitive Rectangle[{x1,y1},{x2,y2}] represents a filled axis-parallel rectangle.

A rectangle may have a color. The color attribute applies to all rectangles following the attribute setting.

Two overlapping colored rectangles in the plane.	In[1]:= rct = Graphics[{Rectangle[{0, 0}, {5, 1}], Hue[.3], Rectangle[{3, 0}, {4, 2}]}]; In[2]:= JavaView[rct]
	Compare with Mathematica

Polygon

Polygon[{x1,y1},{x2,y2},...] respectively Polygon[{x1,y1,z1},{x2,y2,z2},...] represents a closed filled polygon where the last vertex is automatically joined with the first. Polygons are a basic primitive to describe surfaces.

In 3D polygons are affected by lighting. A polygon has a front and back side where the orientation is determined by the ordering of the vertices.

Three vertices of a planar triangle shown with default color black.	In[1]:= pol = Graphics[{Polygon[{{3, 0}, {1, 0.3}, {2, 1}}]}]; In[2]:= Show[pol, AspectRatio->Automatic] In[3]:= JavaView[pol]
	Compare with Mathematica

Two polygons, one of them has green surface color.	In[1]:= wedge = Graphics3D[{Polygon[{{0, 0, 0}, {0, 1, 0}, {0, 1, 1}, {0, 0, 1}}], {SurfaceColor[RGBColor[0, 1, 0]], Polygon[{{0, 0, 0}, {1, 0, 0}, {1, 1, 0}, {0, 1, 0}}]}}]; In[2]:= JavaView[wedge]
	Compare with Mathematica

Cuboid

The primitive Cuboid[{x,y,z}] represents a square block in 3D with edge size 1 and given lower left corner. A cubical with different size can be generated by specifying the upper right corner too.

Cuboids are handled as polygons by Mathematica and rendered with default lighting.

Several cuboids, and additional cuboid with different surface color.	In[1]:= cub = Graphics3D[{Cuboid[{0, 0, 0}], Cuboid[{0, 0, 1}], Cuboid[{0, 1, 1}], Cuboid[{1, 1, 1}], {SurfaceColor[RGBColor[0, 1, 0]], Cuboid[{1.25, 0.25, 0.25}, {1.75, 0.75, 0.75}]}}]; In[2]:= JavaView[cub]
	Compare with Mathematica

Circle

The Circle[{x,y}, r] primitive is a circle with given radius, or with more arguments it describes a circle arc or an ellipse. The command is similar to the command Disk[ ].

A circle with given radius.	In[1]:= cs = Graphics[Circle[{1, 1}, 1.5], AspectRatio -> Automatic, Axes -> Automatic]; In[2]:= JavaView[cs]
	Compare with Mathematica

A sequence of circles with increasing radius.	In[1]:= a = 0.07; In[2]:= csp = Graphics[Table[Circle[Exp[a x]{Cos[x], Sin[x]}, Exp[a x]/4], {x, 0, 10Pi, .5}], AspectRatio -> Automatic]; In[3]:= JavaView[csp]
	Compare with Mathematica

The three different Circle[] commands in action.	In[1]:= cc = Graphics[{Circle[{0, 0}, 1], Circle[{0, 0}, {2, 1}], Circle[{0, 0}, 2, {0, 1}]}, AspectRatio -> Automatic, Axes -> Automatic]; In[2]:= JavaView[cc]
	Compare with Mathematica

Disk

The Disk[{x,y}, r] primitive is a filled disk with given radius, or with more arguments it describes a filled circle arc or a filled ellipse. The command is similar to Circle[].

A disk with given radius and color.	In[1]:= ds = Graphics[{RGBColor[0, 1, 0], Disk[{1, 1}, 1.5]}, AspectRatio -> Automatic, Axes -> Automatic]; In[2]:= JavaView[ds]
	Compare with Mathematica

A sequence of disks with increasing radius.	In[1]:= a = 0.07; len = 10 Pi; In[2]:= dsp = Graphics[ Table[{Hue[x/len], Disk[Exp[a x]{Cos[x], Sin[x]}, Exp[a x]/4]}, {x, 0, len, .5}], AspectRatio -> Automatic]; In[3]:= JavaView[dsp]
	Compare with Mathematica

The three different Disk[] commands in action.	In[1]:= dc = Graphics[{{RGBColor[0, 0, 1], Disk[{0, 0}, {2, 1}]}, {RGBColor[0, 1, 1], Disk[{0, 0}, 1]}, {RGBColor[1, 1, 0], Disk[{0, 0}, 2, {0, 1}]}}, AspectRatio -> Automatic, Axes -> Automatic]; In[2]:= JavaView[dc]
	Compare with Mathematica

Raster

Raster[] produces an array with grayscale cells. Optionally, the xy-range of the rectangle can be specified.

JavaView converts a Raster to a colored planar xy-mesh.

Generate a grayscale image as rectangular grid.	In[1]:= rs = Graphics[Raster[Table[.1Mod[i, j], {i, 10}, {j, 10}]]]; In[2]:= JavaView[rs]
	Compare with Mathematica

RasterArray

RasterArray[] produces an array with colored cells. Optionally, the xy-range of the rectangle can be specified.

JavaView converts a RasterArray to a colored planar xy-mesh.

Generate a color image as rectangular grid.	In[1]:= rsc = Graphics[RasterArray[Table[Hue[.1*Mod[i, j]], {i, 2, 10}, {j, 2, 10}]], AspectRatio -> Automatic]; In[2]:= JavaView[rsc]
	Compare with Mathematica

PostScript

The PostScript[] command allows the inclusion of native PostScript methods into a graphics.

A line rendered with PostScript. Probably the command will never be supported by JavaView.

In[1]:= ps = Graphics[{PostScript[".005 setlinewidth"], PostScript[".1 .1 moveto"], PostScript["1.1 .6 -.1 .6 .9 .1 curveto stroke"]}, Frame -> True];

Text

The primitive Text["string",{x,y}] and Text["string",{x,y,z}] shows the string centered at the given position. Optionally, an offset can be used to change the alignment in 2D.

Different options exist to change the color, alignment, direction, font etc of a text. JavaView currently supports neither of the additional options.

Four strings around a center point.	In[1]:= txt = Graphics[{Text["Left", {-1, 0}, {-1, 0}], {RGBColor[0, 1, 0], Text["Right", {1, 0}, {1, 0}]}, Text["Above", {0, 1}, {0, -1}], Text["Below", {0, -1}, {0, 1}], {PointSize[.075], RGBColor[1, 0, 0], Point[{0, 0}]}}, PlotRange -> All]; In[2]:= JavaView[txt]
	Compare with Mathematica

Labels in 3D.	In[1]:= txt3D = Graphics3D[{Text["LeftUp", {-1, 0, 0.5}], Text["RightUp", {1, 0, 0.5}], Text["BackLow", {0, 1, -0.5}], Text["FrontLow", {0, -1, -0.5}], {PointSize[.075], RGBColor[1, 0, 0], Point[{0, 0, 0}]}}, PlotRange -> All]; In[2]:= JavaView[txt3D]
	Compare with Mathematica

Arrow

Arrow[{x1,y1},{x2,y2}] specifies base and end point of an arrow in the plane or in space. Different options allow to change the size and appearance of the arrow head.

Arrows are converted to a point set with vectors in JavaView. Currently, individual coloring of vectors is not enabled in JavaView.

Two arrows in different colors.	In[1]:= << Graphics`Arrow` In[2]:= arr = Graphics[{Arrow[{0, 0}, {1, 1}], Hue[0], Arrow[{.75, .25}, {.25, .75}]}]; In[3]:= JavaView[arr]
	Compare with Mathematica

You can even place arrows in options.	In[1]:= << Graphics`Arrow` In[2]:= pa = Plot[2 Sin[x], {x, 0, 2Pi}, Epilog -> {Arrow[{4, .25}, {Pi/2, 1}], Text["Here", {4, .15}, {0, -1}]}]; In[3]:= JavaView[pa]
	Compare with Mathematica

Spline

The Spline[{{x1,y1},..}] primitive describes a cubic polynomial, a Bezier or a composite Bezier curve based on a set of given control points.

Splines will soon be enabled in JavaView. Currently JavaView renders the polygon only.

This is a graph of the cubic Spline primitive combined with other primitives. Here a line of a different color connects the points making up the spline. Partially supported only.	In[1]:= << Graphics`Spline` In[2]:= pts = {{0, 0}, {1, 2}, {-1, 3}, {0, 1}, {3, 0}}; In[3]:= spl = Graphics[{Spline[pts, Cubic], Hue[0], Line[pts]}]; In[4]:= JavaView[spl]
	Compare with Mathematica

ContourGraphics Object

ContourPlot[] is used to produce level lines. The command generates a ContourGraphics[] objects containing a rectangular array of scalar values. The contour lines itself are produced in a subsequent Show[] command or by a conversion to a Graphics[] object. The command produces both flat faces and the level curves.

Before being passed to JavaView a ContourGraphics will be casted to Graphics in Mathematica. The received Graphics object consists of Lines[] as contour lines and of Polygons[] as level regions. The first polygon is a rectangle of GrayLevel 0.5 filling the whole display. It is followed by polygons in falling and ascending order of GrayLevel, each bright polygon is part of each darker polygon surrounding it down to GrayLevel 0.5, and each dark polygon is part of each brighter polygon surrounding it up to GrayLevel 0.5.

In the JavaView display SORTING must be disabled in order to keep the original order of faces. All faces are in the same plane and would otherwise not correctly ordered.

This gives a contour plot of the function sin(x)sin(y). Assure that SORTING is disabled in the JavaView display inspector.	In[1]:= c = ContourPlot[Sin[x] Sin[y], {x, -2, 2}, {y, -2, 2}] In[2]:= JavaView[c]
	Compare with Mathematica

Switches off the shading avoids the problem of overlapping faces in JavaView.	In[1]:= gcns = ContourPlot[Sin[x] Sin[y], {x, -2, 2}, {y, -2, 2}, ContourShading -> False] In[2]:= JavaView[gcns]
	Compare with Mathematica

Switches off the contours and views just the shading.	In[1]:= gcnl = ContourPlot[Sin[x] Sin[y], {x, -2, 2}, {y, -2, 2}, ContourLines -> False] In[2]:= JavaView[gcnl]
	Compare with Mathematica

DensityGraphics Object

DensityGraphics[] shows a the values of a scalar function over a rectangular array of points in the plane as grayscale image. Lighter regions have higher values.

Density plot of an array of scalars.	In[1]:= gd = DensityPlot[Sin[x] Sin[y], {x, -2, 2}, {y, -2, 2}] In[2]:= JavaView[gd]
	Compare with Mathematica

Suppresses the grid lines.	In[1]:= gdnm = DensityPlot[Sin[x] Sin[y], {x, -2, 2}, {y, -2, 2}, Mesh -> False] In[2]:= JavaView[gdnm]
	Compare with Mathematica

SurfaceGraphics Object

The Plot3D[] command evaluates a function over a rectangular domain and shows the graph as SurfaceGraphics.

Show the graph of a function over a rectangular planar domain.	In[1]:= plt = Plot3D[Sin[x y], {x, 0, 4}, {y, 0, 4}]; In[2]:= JavaView[plt]
	Compare with Mathematica

The SurfaceGraphics[] command takes a height field of z-coordinates to visualize a graph over a rectangular xy-domain with given size. Note, the size of the domain must be specified explicitly using the option MeshRange, otherwise Mathematica puts grid values for x and y to the values 1, 2, 3 ...

JavaView parses the height field and automatically calculates the mesh based on the size of the domain and the number of grid points.

Use the option MeshRange to show the x and y coordinates at that values where the z coordinates are computed.	In[1]:= sgM = SurfaceGraphics[ Table[Sin[x]*Cos[y], {x, -Pi, Pi, Pi/4.}, {y, -Pi, Pi, Pi/4.}], MeshRange -> {{-Pi, Pi}, {-Pi, Pi}}, Axes -> True]; In[2]:= JavaView[sgM]
	Compare with Mathematica

A SurfaceGraphics object where MeshRange is not defined. Note the wrong tick values.	In[1]:= sg = SurfaceGraphics[Table[Sin[x]*Cos[y], {x, -Pi, Pi, Pi/4.}, {y, -Pi, Pi, Pi/4.}], Axes -> True]; In[2]:= JavaView[sg]
	Compare with Mathematica

ListPlot3D[array] generates a three-dimensional plot of a surface representing an array of height values. ListPlot3D[array, shades] generates a plot with each element of the surface shaded according to the specification in shades.

Here is a 3D plot made from a perturbed list of data.	In[1]:= lp = ListPlot3D[ Table[5 (Sin[x*y] + Random[Real, {-0.15, 0.15}]), {x, 0, 3 Pi/2, Pi/15}, {y, 0, 3 Pi/2, Pi/15}]] In[2]:= JavaView[lp]
	Compare with Mathematica

GraphicsArray Object

Several graphics objects can be combined into a single image using GraphicsArray[].

Take a simple surface graphics and draw its height as grayscale image. Combine the surface and the height image into a single image. Partially supported only.	In[1]:= gp = Plot3D[Sin[x] Sin[y], {x, -2, 2}, {y, -2, 2}] In[2]:= dp = DensityPlot[Sin[x] Sin[y], {x, -2, 2}, {y, -2, 2}] In[3]:= ga = GraphicsArray[{gp, dp}]; In[4]:= JavaView[ga]
	Compare with Mathematica

This generates a list of graphics objects. Setting DisplayFunction -> Identity stops Plot3D from rendering the graphics it produces. Explicitly setting PlotRange ensures that the scale is the same in each piece of graphics. The command GraphicsArray[] partitions the graphics into three rows, and shows the resulting array of images. Partially supported only.	In[1]:= table = Table[ Plot3D[BesselJ[0, Sqrt[x2 + y2] + t], {x, -10, 10}, {y, -10, 10}, Axes -> False, PlotRange -> {-0.5, 1.0}, DisplayFunction -> Identity], {t, 0, 8}] In[2]:= gt = GraphicsArray[Partition[table, 3]]; In[3]:= JavaView[gt]
	Compare with Mathematica