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 axisparallel 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 xyrange of the rectangle can be specified.
JavaView converts a Raster to a colored planar xymesh.
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 xyrange of the rectangle can be specified.
JavaView converts a RasterArray to a colored planar xymesh.
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 zcoordinates to visualize a graph over a rectangular xydomain 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 threedimensional 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[x^{2} + y^{2}] + 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 