The first part of this appendix describes the types and formats of data supported by the Scatter Visualizer. Data input to the Scatter Visualizer must be provided as a single file containing raw data, usually in a tab-separated ASCII text form.
The second part discusses the configuration file, which describes how the Scatter Visualizer reads in, and displays, the data file.
Both the data and configuration files can be generated automatically by the Tool Manager (see Chapter 3).
In its simplest form, the data file consists of a list of lines, each containing a set of fields separated by one tab. (Other separators are also allowed, but only one can separate each field. See “Input Options”.) All lines must contain the same fields. The interpretation of the fields is specified by the configuration file, described in the next section. Using the store sales data provided as part of the Scatter Visualizer package (file /usr/lib/MineSet/scatterviz/examples/store-type.data), the first few lines of the input file appear as:
LIQUOR STORE 4300,4460,4800,4900,4700,4200,4250,4200 2700,2800,2750,3000,2900,2600,2500,2650 1600,1650,1900,1950,2000,2200,2300,2300 GROCERY STORE 700,900,600,800,877,755,800,600 3000,2900,3100,2800,2899,2950,3400,3300 10000,11000,9000,9800,9700,9650,9770,9700 |
In this sample file listing, each line consists of four fields, separated by tabs. The first field is a string that identifies a store type. The second field is an array of eight numbers, separated by commas, which might be sales of alcohol over an eight-day period. The third and fourth fields are also arrays of eight numbers that could represent sales of tobacco and food, respectively, over the same eight-day period.
The sample data file has other fields in the same format, but these are not shown. These additional fields correspond to sales of other products (see the configuration file /usr/lib/MineSet/scatterviz/examples/store-type.scatterviz for a listing of all the fields).
The data file cannot contain blank lines or comments. Missing or extra data on a line causes an error.
The Scatter Visualizer supports integer, floating-point number, and string data types, as well as arrays of these types. The following five data types are supported:
float represents a single-precision floating point number. The decimal point is optional. Numbers in exponential “e” notation are also accepted.
double represents a double-precision floating point number. The decimal point is optional when representing a floating point number. Numbers in exponential “e” notation are also accepted. The superior precision of double can be useful for accurately representing large numbers, since float can represent only seven or eight significant digits accurately. This superior accuracy, however, consumes twice the memory space of float.
dataString represents a string that is unlikely to appear multiple times. If it appears multiple times, several copies are made. A dataString is typically used to store an address. Addresses are unlikely to be compared, and each record can have a different address.
string represents a string of characters that can appear multiple times in the data file. Unlike a dataString, only a single copy of a given string is stored in memory, no matter how many times it appears in the data. This saves much memory for strings appearing many times.
Comparing strings is also much quicker than comparing dataStrings. Processing is somewhat slower when looking for duplicate strings as they are read in. An example of string use is for a division name that appears once for each department in the division. If you are unsure whether to use a string or a dataString, use a string.
With the Scatter Visualizer, you can use fields that are one- or two-dimensional arrays of fixed size. In a fixed-sized array field, all entries of the given field are arrays with the same number of values. Arrays contain the data values across one or two independent variables (those dimensions controlled by the sliders). In the listing from the file store-type.data, the second, third, and fourth fields are arrays.
Any field or array element in the data file can also have the value “?” (question mark), indicating an unknown or null value (see the discussion of nulls in Appendix G).
The configuration file format is flexible. Words in it must be separated by spaces, and it is case-sensitive. Except for the include statement and text within quoted strings, spacing and line breaks are irrelevant.
The configuration file consists of a series of sections, each of which has the form:
sectionKeyword
{
statements...
}
|
where sectionKeyword names the section. The order of the sections is significant, since sections can refer to variables defined in previous sections.
As each section is encountered, a special configuration file (referred to as a defaults file) is also read in. Defaults files normally contain options statements. These files are searched in the following order:
Files with the same name can appear in more than one of the above-named directories; in this case, the order given is the one in which the directories are read. If the same option is found in multiple files, the last option read is used. Note that the appropriate section in the configuration file is read after all the defaults files; thus, options in the configuration file override those in the defaults files.
A statement has the following form:
statementKeyword info ; |
where statementKeyword defines the statement, and info varies according to the keyword.
A variable name can appear in two formats:
In the first format, it is a letter followed by a number of letters, digits, or underscores. It cannot be a keyword, and should not be quoted.
In the alternate form, the variable name should be surrounded by back quotes (`). In this form, the variable name can match a keyword, and can contain even non-alphanumeric characters. The primary purpose of this second form is for configuration files generated automatically by the Tool Manager.
There is no scoping of variable names; a given variable name can only be declared once in the configuration file.
Many sections have options statements, which have the form
options optionName info, optionName info... ; |
where optionName defines the specific option, and info depends on the option. In some cases, optionName can be more than one word. To maximize the number of allowable variable names, most option names are meaningful only within the appropriate options statement; option names do not conflict with variable names. You can declare several options on the same line, separating them by commas or placing them in several options statements. If two conflicting values for the same option appear, the last value is taken.
The configuration file can contain lines of the form
include "filename" |
These lines can appear anywhere in the configuration file, but each must be on its own line. The filename must be in quotation marks; anything after the closing quote is ignored. The number of nested includes is unlimited. If a relative pathname (one not beginning with a slash) is specified, the file is first sought in the directory containing the current configuration file. If include statements are present, this might not be the same as the initially loaded configuration file. If it is not found in the current configuration file, the include is sought in the current directory.
A statement similar to an include is sinclude, which has the form
sinclude "filename" |
This is identical to the include statement, except that no error is given if the file does not exist; instead, the sinclude statement is ignored.
Strings and characters in the configuration file follow C conventions. Strings are in double quotation marks ("), and characters are in single quotation marks ('). All standard backslash conventions are followed (for example, \n represents a new line).
Comments begin with a pound (#) symbol at the beginning of a line; anything after this symbol to the end of the line (80 characters) is ignored, up to the end of the line.
The keywords recognized by the Scatter Visualizer are listed in Table C-1. Variables cannot have these names unless they are surrounded by back quotes (`). Tokens appearing only in option statements are not keywords, and can be used for variable names.
Table C-1. Scatter Visualizer Keywords
across | average | axis | buckets |
by | color | colors | dataString |
date | divide | double | entity |
execute | expressions | file | float |
from | include | input | int |
key | label | legend | max |
message | min | modulus | monitor |
off | on | options | scale |
separator | sinclude | size | slider |
string | sum | summary | time |
to | view |
|
|
Currently, the keywords execute, min, monitor, and time are not used by the Scatter Visualizer.
Expressions are accepted in several places in the input. Expressions follow the syntax of C. The following operations are supported:
+ - * / % == != > < >= <= && || ! & | ^ ?:
Also, the following functions are available:
Type handling is similar to that in C. Expressions using int and float promote both sides to float. Expressions using int and double, or float and double promote both sides to double. The result of a relational expression (for example, ==, <) is always an int. Type casting is also supported.
Unlike in C, strings can be compared using relational expressions; the strings are compared lexicographically.
The first section of a configuration file is normally the input section. It defines the name and format of the data file. A typical input section might look like this:
input {
file "company.data";
string company;
slider int income from 20000 to 60000 by 10000;
slider date “%N %Y” purchaseDate from “Jan 1990” to “Dec
1992” by “1 month”;
options array separator `,';
float lifeSales[income][purchaseDate];
float autoSales[income][purchaseDate];
float homeSales[income][purchaseDate];
string location;
}
|
This example states that the input file is called company.data, and that there are five fields: company, lifeSales, autoSales, homeSales, and location. The company and location fields are of type string, while the other three fields are two-dimensional arrays of type float. Two slider dimensions are declared:
income, which is of type int, ranges from 20000 to 60000 in increments of 10000; and
purchaseDate, which is of type date and ranges from January 1990 to December 1992 in increments of 1 month.
The arrays lifeSales, autoSales, and homeSales contain values for each income and purchase date. Individual values within the arrays are separated by commas.
When the input section is entered, the defaults file inputDefaults is read in.
The file statement names the data file to be read. This statement is required. Its form is:
file "filename"; |
filename must be in double quotation marks. If it is a relative pathname (no leading slash), it is first sought in the directory containing the current configuration file. If include statements are present, this might not be the same as the initially loaded configuration file. If it is not found in the current configuration file's directory, the file is sought in the current directory.
Enumeration statements declare enumerations, or enums, that index into array fields. The enum statement has three forms.
The first enum statement form is
enum type name from value1 to value2 by increment;
This declares an enum with values starting at value1 and incremented by increment until they reach or exceed value2. For example, the statement
enum int age from 20 to 70 by 10;
declares age as an enum with the values 20, 30, 40, 50, 60, and 70.
Type must be a number type (int, float, or double) or date (see “Dates”).
The second enum statement form is
enum type name from value1 to value2 across numberOfValues;
This declares an enum with values ranging from value1 to value2. The numberOfValues is an integer specifying the number of values. For example, the statement:
enum int age from 20 to 70 across 6;
declares age as an enum with the values 20, 30, 40, 50, 60, and 70.
Type must be a number type (int, float, or double) or date (see “Dates”).
The third enum statement explicitly lists the enum values. Its form is:
enum type name { value1, value2, ..., valueN };Type can be any type or date (see “Dates”).
The enum statement includes special support for a date type that handles date and time values starting Jan 1, 1753. The date type is valid only within enum statements. A date enum statement can have the following syntaxes:
enum date “format” name from “value1” to “value2” across numberOfValues;
enum date “format” name { value1, value2, ..., valueN };
enum date “format” name from “value1” to “value2” by “increment”;
|
The format string specifies the format of the values; it is useful for controlling how dates are displayed in the animation control panel. The syntax of the format string is similar to the scanf function in C. Various units of time are represented by special characters preceded by the percent symbol (%). For example,
enum date cq “Calendar Q%Q, %Y” from “Calendar Q1, 1980” to “Calendar Q3, 1985” by “1 quarter”; |
The “Calendar Q” in the format string matches the “Calendar Q” in value1 and value2. The %Q in the format string indicates that the next number in value1 and value2 is the calendar quarter. The comma and space in the format string match the commas and spaces in the values. Finally, the %Y in the format string specifies that the year values are next.
Table C-2 lists the characters that can follow the percent symbol and the units of time they represent.
Table C-2. Characters That Can Follow the percent Symbol in the format String
Character | Time Unit | Precision |
|---|---|---|
Y | 4 | |
Q | 1 | |
M | 2 | |
N | month name | >= 3 |
D | 2 | |
h | 2 | |
m | 2 | |
s | 2 |
With the exception of N, each character matches an integer of the specified precision. N matches 3 or more characters giving the English name of the month.
The from-to-by form of the enum statement includes an increment value. For dates, the increment is a quoted string containing an integer, an optional space, and one of the special characters in Table C-2 or one of the symbols year, quarter, month, day, hour, minute, and second. The plural forms of these symbols are also accepted. Note that these symbols are not keywords, since they have special meaning only in the increment string. The following are examples of valid increments:
“1 year” “7 days” “4h” |
The data statements declare the fields in the data file. The fields must be declared in the order they appear in the data file. The format of most data statements is
type name; |
where type is int, float, double, string, or dataString; name is the variable name.
A data field can also be based on an enumeration. The syntax is
enum enumName name; |
The field must contain ints corresponding to the values of the enum. For example, if the enum ageGroup is declared as
enum string ageGroup {"below 30", "30-39", "40-49", "50-59", "60 or above"};
|
the field age can be declared as
enum ageGroup age; |
The field should contain ints between 0 and 4, where 0 is displayed as “below 30,” 1 as “30-39”, and so forth.
Only one variable can be declared per statement.
Arrays are also declared using data declarations. The declaration syntax for one-dimensional arrays is one of the following:
type name [ number ] ; type name [ enumName ] ; type name [ null enumName ] ; |
For example:
float revenue [50]; |
The declaration syntax for two-dimensional arrays is one of the following:
type name [ number1 ][ number2 ] ; type name [ enumName1 ][ enumName2 ] ; type name [ null enumName1 ][ null enumName2 ] ; |
For example:
float revenue [50][10]; |
When enums are used, the number of values in the array is taken from the declaration of the enum. For example, given the statements
enum int age from 20 to 70 by 10; float clothingPurchases[age]; |
the array clothingPurchases must have six values, corresponding to the enum values 20, 30, 40, 50, 60, and 70.
The keyword null indicates an extra value at the beginning of the array, corresponding to null. Thus, the statements
enum int age from 20 to 70 by 10; float clothingPurchases[null age]; |
declare clothingPurchases as an array with seven values: the first value corresponding to null or unknown age values, and the remaining six values corresponding to age values 20, 30, 40, 50, 60, and 70.
You can override the separator between values in an array by declaring it as:
type name [ number ] separator `char'; |
For example:
float revenue [50][10] separator `:'; |
If no separator is specified, the default separator (usually a tab) is used.
All options statements begin with the word “options” and have one or more comma-separated options.
The separator option defines the separator between fields in the data file. The default separator is a tab. The syntax is
options separator `char';
For example:
options separator `:';
Note: The separator is used also to separate values within arrays; however, arrays can override the separator. The backslash option controls whether backslashes in the input data are treated specially or like other characters. The syntax is:
options backslash off; options backslash on;
The default is off. If backslash processing is on, separators in the input data preceded by backslashes are treated as regular characters rather than separators. Within strings, this causes standard C-style backslash processing.
The expressions section of a configuration file lets you define additional fields that are expressions of existing fields. For example, one field can be defined as the sum of two other fields.
The format of the expressions section is
expressions
{
expressionDeclaration;
...
}
|
where expressionDeclaration has the following form:
type name = expression ; |
The following is a sample expression section. This section assumes two existing array fields of type double: “male” and “female”; these represent spending by males and females on various goods across time (one independent dimension). Two fields are added: “total” represents the total dollars spent, and “pctFemale” represents the percentage of dollars spent by females.
expressions
{
double total[36] = male+female;
double pctFemale[36] = divide (female*100, total, 50.0);
}
|
The expressions section has no options; thus, no defaults file is read in for it.
The view section of a configuration file describes how the data is displayed, including the mapping of sizes, colors, axes, and so on. The default values for these options are in /usr/lib/MineSet/scatterviz/view.scatterviz.options. Its form is
view
{
viewStatement;
...
}
|
A sample view section is
When entering the view section, the viewDefaults file is read in.
The slider statement identifies an enum to be used as a slider dimension. Its syntax is one of the following:
slider enumName; slider null enumName; |
The enum name is declared in the input section. If the keyword null is present, the slider includes a position at the beginning corresponding to null or unknown values of the enum. Arrays indexed by the slider must be declared to match the null in the slider statement.
There can be 0, 1, or 2 slider statements. The first slider statement applies to the horizontal slider, the second to the vertical slider. If there is no slider statement, the resulting display does not include animation.
The entity statement lets you specify a variable that uniquely identifies the entities in the display. The entity statement consists of a series of clauses, separated by commas:
entity clause1, clause2,... |
Alternatively, the clauses can be given in separate entity statements.
The first clause of the entity statement normally contains the name of the entity variable (brand in the example on page 401).
This clause defines how the entities are labeled. It has the following forms:
label off
label on
This turns on the labels. The default labels use the entity variable as the label for each entity.
label variable
This turns on the labels and uses the given variable to label the entities. When this form is used, it is not necessary to specify label on.
This clause turns on the labels and specifies their color. It has the form:
label color “colorname” |
where colorname is the name of a color in a special format. (Color naming is explained in “Color Statement”.) The default label color is gray.
The legend clause explains what the entities are. Any string can be placed in the entity legend. The legend clause has the following forms:
legend off
This turns off the entity legend.
legend on
This turns on the entity legend (this is the default). The default legend is
Entity: varname
where varname is the name of the entity variable.
legend label “string”
This turns the legend on and explicitly sets the legend string. If this form is used, legend on is unnecessary.
The size statement describes how a field of data is mapped to the sizes of entities. The size statement consists of a series of clauses, separated by commas:
size clause1, clause2,... |
Alternatively, the clauses can be given in separate size statements.
The first clause normally contains the name of a field to be mapped to size (total$, in the view example on page 401). The field must be of a number type (int, float, or double), of which float is the most efficient. The field can be an array that is indexed by slider dimensions. If no size field is specified, all entities are the same size.
Normally, the size variable is mapped to the size of the entities, so that the biggest entity has a size of 5. This size can be changed by specifying a different value. If there is no size variable, the default maximum size is 2.5. The max clause has the form
max float |
Instead of using the max clause to affect size values, the scale clause can be used to scale these values; all values are multiplied by the scale. The scale clause's syntax is
scale float |
The legend clause defines the meaning of the size mappings. Any string can be placed in the size legend. The legend clause has the following forms:
legend off
This turns off the size legend.
legend on
This turns on the size legend (this is the default). The default legend is:
size:varname
where varname is the name of the variable that is mapped to size.
legend label “string”
This turns the legend on and explicitly sets the legend string. If this form is used, legend on is unnecessary.
The color statement describes how values are mapped to colors. The format is similar to the size statement, consisting of several clauses that can be separated by commas, or entered as multiple statements. The syntax is:
color clause1, clause2,... |
Color names follow the conventions of the X window system, except that the names must be in quotes. Examples of valid colors are “green,” “Hot Pink,” and “#77ff42.” The latter is in the form “#rrggbb”, in which the red, green, and blue components of the color are specified in hexadecimal value. Pure saturation is represented by ff, a lack of color by 00. For example,”#000000” is black, “#ffffff” is white, “#ff0000” is red, and “#00ffff” is cyan.
As with size, you also can specify a single field to be mapped to an entity color. The field can be an array that is indexed by slider dimensions. If the field is an array, it must be a number type. If the field is a number type, the scale and buckets clauses described below can be used to map a range of colors to the values of the field. If the field is not a number type, it is sorted, and each unique value is assigned a color.
The colors clause specifies the colors to be used. The colors clause's syntax is:
colors "colorname" "colorname"... |
The format for colorname is described in “Color Naming”. Note that there are no commas between the colors, because commas are used to separate clauses in the color statement. A sample colors clause is:
colors "red" "gray" "blue" |
Colors in the list are subsequently referred to by their index, starting at zero. In the above example, red is color 0, gray is color 1, and blue is color 2.
If there is no colors statement, colors are chosen randomly. If there is a colors statement, at least as many colors must be specified as are to be mapped.
The scale clause allows assignment of values to a continuous range of colors. For example, when displaying a percentage, red can be assigned to 0%, gray to 50%, and blue to 100%. Intermediate values are interpolated; for example 25% is pinkish, and 55% is a slightly bluish gray.
The syntax for the scale clause is
scale float float ... |
The first value is mapped to color 0, the second to color 1, and so forth. The colors statement must contain at least as many colors as are to be mapped to the largest index.
Values in this statement must be in increasing order. Any value less than the first color is assigned the value of the first color. Any value greater than the last value is assigned the last color. Intermediate values are interpolated.
For example, assume the pctFemale field indicates what percentage of the group is female, and you want to map a group that is 100% female to red, 100% male to blue, and 50% each to gray. The colors statement for this is:
colors pctFemale, colors "blue" "gray" "red", scale 0 50 100; |
Use the scale clause only in conjunction with a numeric color variable.
The buckets clause is similar to the scale clause without interpolation. All values are rounded down to the highest value in the clause, and that exact color is used. Values less than the first value use the first color.
The syntax for the buckets clause is
buckets float float ... |
The syntax and assignment of colors is the same as for the scale clause.
If, in the above example, you used the buckets clause instead of the scale clause, the statement would be:
colors pctFemale, colors "blue" "gray" "red", buckets 0 50 100; |
All values greater than or equal to 100 are colored red. Values greater than, or equal to, 50 but less than 100, are gray. All other values are then blue.
Use the buckets clause only with a numeric color variable.
The legend clause creates a legend of the colors. The legend clause syntax can be any of the following:
legend off legend on legend "string" "string" ... legend label "string" |
The legend off clause turns the legend off. The legend on clause turns the legend on. It can be omitted if other legend statements are included. Specifying only legend on generates the default legend.
The default legend includes a single label to the left (with the name of the field that is mapped to color), and a list of colored labels on the right (with values obtained from the scale clause, the buckets clause, or from the field). To override the strings in the colored labels, specify the strings as:
legend "string" "string" |
To override the label on the left, specify it following the word label. To eliminate this label, specify an empty string; that is:
legend label "" |
The axis statement causes a variable to be used as an axis in the 3D landscape. The variable's values determine where the entities are positioned on the axis. There can be up to three axis statements. Like the size and color statements, the axis statement contains a series of comma-separated clauses, but all of them must be specified in a single statement.
axis clause1, clause2,... |
As with size and color, you can specify a field to be used as an axis. The field can be an array that is indexed by slider dimensions. If the field is an array, it must be of type number. If the field is not of type number, it is sorted, and each unique value is assigned a position along the axis.
The label clause has the form:
label "string" |
The string is used to label the axis. It appears in the landscape, at the end of the axis line. The default label is the name of the axis variable.
Normally, the axis variable is mapped directly to the position of the entities along the axis0. The max clause lets you normalize the values of the axis variable, so that the maximum value is mapped to the specified max. The max clause's syntax is:
max float |
Instead of using the max clause to affect position values, the scale clause can be used to scale the values. All values are multiplied by the scale. The scale clause syntax is
scale float |
The color clause specifies the color used for the axis line and label. It has the form:
color "colorname" |
The summary statement specifies a summation to be calculated over all the entities. The summary is used to color the drawing window in the animation control panel. Like the size and color statements, the summary statement has several clauses that can be specified in one statement, separated by commas, or in separate statements.
summary clause1, clause2,... |
You can specify the variable to be used in the summary. This variable must be of number type. Typically, the summary variable is an array indexed by slider dimensions, so that the summary value varies across the slider dimensions.
The color clause specifies the color used to display the summary values in the drawing window. It has the form
color “colorname” |
Various shades of the color, from white to the specified color, are used to represent summary values. The minimum summary value is mapped to white, while the maximum summary value is mapped to the specified color. The default summary color is red.
The legend clause creates a legend of the summary colors. The legend clause syntax can be any of the following:
legend off legend on legend label "string" |
The legend off clause turns the legend off. The legend on clause turns the legend on. It can be omitted if other legend statements are included. Specifying only legend on generates the default legend.
The legend includes a single label to the left (which defaults to the aggregation function and variable used in the summary), and two colored labels on the right (with the minimum and maximum summary values). To override the label on the left, specify it following the word label. To eliminate this label, specify an empty string; that is
legend label "" |
The message statement specifies the message displayed when an entity is selected. The syntax is similar to that of the C printf statement. A sample message statement is
message "%s: $%f, %.0f%% of target, %.0f%% of last year",
product, sales, pctTarget, pctLastYear;
|
This could produce the following message:
furniture: $2425.37, 23% of target, 87% of last year |
The formats must match the type of data being used:
Strings must use %.
Ints must use integer formats (such as %d.
Floats and doubles must use floating point formats (such as %f).
For details of the printf format, see the printf (1) reference (man) page (type man printf at the shell prompt).
A special format type has been added to printf. If the percent sign is followed by a comma (for example, “%,f”), commas are inserted in the number for clarity. Only the United States convention of d,ddd,ddd.dddd is supported, with the decimal point represented by a period, and commas separating every three places to the left of the decimal point. For example, if the above format were:
message "%s: $%,f, %,.0f%% of target, %,.0f%% of last year",
product, sales, pctTarget, pctLastYear;
|
it would produce the message:
furniture: $2,425.37, 23% of target, 87% of last year |
The $, *, h, l, ll, L, and n printf format options are not supported.
All values, including the format string, are expressions. Thus, if you had a pctFemale field, but wanted a more gender-neutral message, you could use:
message pctFemale>50?"%f%% females":"%f%% males",
pctFemale>50?pctFemale:100-pctFemale;
|
If pctFemale is 70, the message “70% females” is displayed; if pctFemale is 30, the message “70% males” is displayed. In this case, you can also achieve the same result with a single format string:
message "%f%% %s", pctFemale>50?pctFemale:100-pctFemale,
pctFemale>50?"females":"males";
|
If no message is specified, a default message containing the names and values of all the fields is used.
The filter statement specifies that only entities meeting certain filter criteria should be displayed initially (see “The Filter Menu” in Chapter 6). The filter criteria are in the form of expressions whose values must all be true or nonzero for an entity to be displayed (expressions are described in “Expressions”).
The syntax of the filter statement is
filter expression, expression,... |
For example, the statement
filter state == "CA" || state == "WA", sales > 9000, pctTarget >= 90; |
specifies that only records from California or Washington state, with sales greater than 9000 and a pctTarget value greater than or equal to 90 should be displayed initially.
After the Scatter Visualizer is invoked, the filter criteria can be changed or removed interactively using the filter panel.
The view section of the configuration file has several options for controlling parameters of the display. These options can appear in a single options statement, separated by commas, or in separate options statements. The syntax of the options statement is
options option, option,... |
The following options are available:
entity label size float
axis label size float
hide entity label distance float
controls the distance at which entity labels become invisible. Smaller distances might improve performance, but the labels disappear more quickly.
grid color “colorname”
grid size float float float
controls the spacing between grid lines. It applies the three values to grid lines along the x, y, and z axes, respectively.
entity shape shapeName
specifies the shape used to display entities. shapeName can be “cube,” “bar,” or “diamond.”