Index
Prev |  |

## Index

1-D lattice
  Setting Lattice Constraints

1-D lattice, example
  A Colormap Example

2-D image
  image, 2-D
    Lattice Examples
  manipulating
    2-D Lattice

2-D lattice, example
  A 2-D Image Example

92871
  HangingList
    nDim Gives the dimensionality of the pyramid dictionary,
      Structure of a Dictionary

accessor functions (API)
  Application Programming Interface

AddImg
  Types of Shared Executable

advanced topics
  Understanding the Module Builder

allocate function
  Allocate

allocating memory
  Allocating Memory Efficiently

allocating temporary storage
  How Explorer Implements Reference Counting

alternate executable
  The User Function File
  interpreter modules
    Installing Interpreter Modules
  setting
    Selecting Build Options

API
  Using the Explorer API

API routines
  automatically generated
    Application Programming Interface
  cxParameter
    Using the Parameter API
  cxPick
    The Pick API Routines
  for geometry modules
    Writing a Geometry Module
  for loop controllers
    Using the Loop Controller API
  for X Window System widgets
    Using the X-MCW Option
  geometry
    The Geometry API Routines
  lattice
    The Lattice API Routines
  required labels
    Assigning Labels

application programming interface
  definition
    Using the Explorer API

Apply button
  Moving Around the Windows

apply function
  Map and Apply

arena size
  shared memory
    Shared Memory Arena

argument
  data type
    Type

argument names
  Arg Name

argument references
  References

array
  definition
    Understanding Lattices

array bounds
  Array Dimensioning
  scoping rules
    Ordering Array Members

array data, converting
  Curvilinear Lattices

array declaration in ETL
  Array Dimensioning

array indexing
  Storing Data Values
  in pyramid
    Setting up the Lattice Structure

array of integers
  construction
    Composition Rules

array structure
  Storing Data Values

array values
  sharing
    Understanding Lattices

arrays
  Lattice Manipulations
  computing size
    Allocating Storage Space
  copying
    Copying Arrays
  dimensionality
    The Resulting C Structure
  in Shape
    Interfacing to Explorer Data Types

ASCII files
  Updating the Module Resources

aspect ratio
  bounding box
    Uniform Lattices
  changing
    Changing the Aspect Ratio

assigning labels
  Constructing Labels

asterisk (*) in data type menu
  Type

automatic type coercion
  Automatic Type Coercion of Arrays

base lattice
  on pyramid ports
    Defining Pyramid Constraint Fields
  structure
    Contents of Layers

baseLattice
  definition
    The Structure of a Pyramid

binary file
  What the Files Do
  geometry
    The Geometry Data Type

binary files
  Types of Shared Executable

BitProduct
  BitProduct (|.&)

bitproduct operator
  BitProduct (|.&)

blocked selection
  Inside

blocking a multiprocessing module
  Controlling a Multiprocessing Module

bounding box
  Uniform Lattices

“Build and Install” command
  Building and Installing Modules

build environment
  Configuring the Build Environment

Build menu
  Using the Build Menu

Build Options menu
  Selecting Build Options
  alternate executable
    Types of Shared Executable

Build Options window
  Installing Interpreter Modules
  purpose
    Working with Module Wrappers

build system
  Setting Up a Personal Module Tree

“Build” command
  Building and Installing Modules

building a shared executable
  Types of Shared Executable

building module without MDW
  Modules Without MDW

building modules
  Using Makefiles

button
  Apply
    Moving Around the Windows
  OK
    Moving Around the Windows

buttons
  Cancel
    Moving Around the Windows

byte
  primType
    Defining Primitive Values

C lattice
  data storage
    Manipulating Lattices

C structures
  from ETL
    The Resulting C Structure

calling sequence
  hook functions
    Hook Function Calling Sequence

Cancel button
  Moving Around the Windows

Cartesian coordinates
  The cxCoord Structure

case keyword
  Syntax

CDEFINES
  Building a Multiprocessing Module

channel selector module
  Building a Module

character
  primtype
    Defining Primitive Values

character string
  Input Ports

closed keyword
  Syntax
  in C
    The Resulting C Structure

code for sample module
  Example Code and Modules

color
  of a picked object
    Getting Data on the Hit Object

color coding
  connections
    Highlighted Connections

color nodes
  modifying
    An Example Geometry Module

colormap
  Limiting Lattice Values
  Lattice Examples

colormap module
  creating
    1-D Lattice

comma in ETL
  No Separating Comma

comment syntax
  Inserting Comments

compiler directives
  Building a Multiprocessing Module

compiling with debug option
  Setting Environment Variables

compressed pyramid
  definition
    The Structure of a Pyramid

compression dimension
  Using a Pyramid Dictionary

compression modes
  on pyramid ports
    Defining Pyramid Constraint Fields

compressType
  Disadvantages

computational function
  The User Function File

Conditional Evaluation
  Conditional Evaluation (?:)

conditional evaluation operator
  Conditional Evaluation (?:)

connecting ports
  rules
    Mapping Rules

connection
  wiring
    Creating a Link

connection list
  vertex sequence
    Using the Dictionary Elements

connections
  between ports and arguments
    Connecting Arguments to Ports
  in pyramids
    The Structure of a Pyramid
  multiple
    Mapping Rules
  required
    Creating a Link
    Mapping Rules

connections menu
  Understanding the Connections Menu

Connections window
  Connecting Arguments to Ports

connectivity list
  example
    A Pyramid Reader Module

console window
  setting to stdout
    Selecting Build Options

constant values
  for function arguments
    Using Pseudo Input Ports

constants
  Enumerated Constant Types

constraint options
  Input Port Characteristics

constraints
  on lattices
    Limiting Lattice Values
  on pyramid ports
    Setting Pyramid Constraints

constructing arrays in ETL
  Composition Rules

control arc, in loops
  Using the Loop Controller API

Control Panel Editor
  Defining the User Interface

controller modules, generic
  Using Generic Controller Modules

coordinate mapping
  Storing Coordinate Values

coordinate storage
  perimeter lattices
    Perimeter Lattices
  uniform lattice
    Uniform Lattices

coordinate types
  Defining Lattice Constraint Fields

Copy button
  Copying Arrays

copying
  arrays and pointers
    Copying Arrays

count
  in pyramid layers
    The Structure of a Pyramid

creating document prototypes
  Default Makefile Actions

curvilinear coordinates
  Interfacing to Explorer Data Types

curvilinear lattice
  in pyramid
    Setting up the Lattice Structure
  use
    Curvilinear Lattices

curvilinear lattices
  Curvilinear Lattices
  nDim
    The Dimension Variables

CXBUILDSHARED
  Setting Environment Variables

CXBUILDSHARED variable
  Build and Installation Options

cxConnection structure
  compressed
    Using a Pyramid Dictionary

cxCoord
  The Lattice Data Type
  The cxCoord Structure

cxCoordDefaultNew
  Output Ports

CXCREDITS variable
  Installing Credit Files

cxData
  The Lattice Data Type
  The cxData Structure

cxDataAllocErrorGet
  Allocating Memory Efficiently

cxDimsProd
  Curvilinear Lattices

cxFilenameExpand
  use
    Expanding Filenames

cxGeneric
  use
    The cxGeneric Data Type

cxGeoABGRAdd
  Getting Data on the Hit Object

cxGeoColorAdd
  Getting Data on the Hit Object

cxGeoLabelAdd
  Getting Data on the Hit Object

cxGeoNormalAdd
  Getting Data on the Hit Object

cxGeoReceive
  An Example Geometry Module

cxGeoRotate
  Getting Data on the Hit Object

cxGeoScale
  Getting Data on the Hit Object

cxGeoSender
  Decoding and Recoding Scene Graphs

cxGeoTranslate
  Getting Data on the Hit Object

cxInputAdd
  use
    Communicating with UNIX Processes

cxInputConnectsGet
  Modules Without MDW

cxInputDataChanged
  Modules Without MDW

cxInputDataGet
  Handling Fan-in Connections
  Modules Without MDW

cxInputDataGetV
  Handling Fan-in Connections

cxInputPortOpen
  Modules Without MDW

CXINSTALLSTRIPPED
  Setting Environment Variables

CXINSTALLSYMBOLIC
  Setting Environment Variables

CXINSTALLSYMBOLIC variable
  Build and Installation Options

cxLatPtrSet
  Reference Counts for Contained Data Types

cxLattice
  definition
    Understanding Lattices

cxLoopBreak
  Using the Loop Controller API

cxLoopControlArc
  Using the Loop Controller API

cxLoopCtlr
  Using the Loop Controller API

cxLoopIteration
  Using the Loop Controller API

cxmkmf
  Setting Up a Personal Module Tree
  definition
    Generating Makefiles

cxmkmf command
  Creating a Makefile

cxModuleNameGet
  Types of Shared Executable

cxObjectDefine
  Terminology

cxOutputDataFlushAll
  Sending Data Downstream

cxOutputDataSendNow
  Sending Data Downstream

cxOutputDataSet
  Modules Without MDW
  Sending Data Downstream

cxParameter
  Understanding Parameters
  The Data Type Declaration
  example of use
    Code Example

cxPick
  definition
    Understanding the Picking Function
  in modules
    Using the Pick Data Type
  variables
    The cxPick Structure

cxPickHit
  Terminology
  structure
    Getting Data on the Hit Object

cxPyramidLayer
  The Structure of a Pyramid

cxPyramidReference
  The Structure of a Pyramid

cxPyrLayerSet
  Reference Counts for Contained Data Types

cxPyrSet
  Reference Counts for Contained Data Types

cxScriptCommand
  The Scripting API

cxTimerAdd
  use
    Timer Events

Data Changed
  function
    Checking the State of Input Ports

data fan-in
  Handling Fan-in Connections

data frame
  definition
    Module Firing

data objects
  Reference-Counting Data Types

data preparation
  Preparing Your Data for Lattices

data storage
  column-major
    Storing Data Values
  coordinate values
    Storing Coordinate Values
  curvilinear lattices
    Curvilinear Lattices

data storage format
  Manipulating Lattices

data structure
  geometry
    The Geometry Data Type

data structures
  composition
    Composition Rules
  cxLattice
    The Lattice Data Type
  labels
    Assigning Labels

data type
  building
    Building the Type and Related Files
  components
    Overview
  cxParameter
    Understanding Parameters
  for function argument
    Type

data type declaration
  cxLattice
    The Data Type Declaration

data type definitions
  rules
    Rules for Type Definitions

data type names, conventions
  Naming Conventions

data type structure
  cxPick
    Terminology

data types
  naming
    Defining a New Type
    Naming Files and Data Types

data typing language
  Overview
  relation to C
    Using the ETL

data variables
  computing
    Storing Data Values

data variables, setting
  Defining Lattice Constraint Fields

data, lattice
  Storing Data Values

DataScribe
  alternate executable
    Types of Shared Executable

DEBUG
  Setting Environment Variables

debug option
  Setting Environment Variables

debugger tools
  Debugging a Module

debugging modules
  Debugging a Module

declaring an object
  No Pointer Variables

decrementing the count
  How Reference Counting Works

default
  pseudo ports
    Using Pseudo Input Ports

default libraries
  Associated Libraries

default values
  passing
    Passing Default Values

defaults
  executable
    Selecting Build Options
  MCW
    Selecting Build Options
  MDW
    Selecting Build Options
  stdout
    Selecting Build Options

defaults, module
  setting
    Using the Build Menu

define operator
  in Shape
    Differences from C
  use
    The define Operator (:=)

defining lattice constraints
  Limiting Lattice Values

defining variables
  No Separating Comma

delta protocol
  geometry
    The Geometry Data Type

describing volumes
  Curvilinear Lattices

dimension variables, lattice
  The Dimension Variables

dimensions, lattice
  The Lattice Data Type

dimensions, setting
  Defining Lattice Constraint Fields

dims
  The Lattice Data Type
  definition
    The Dimension Variables

dims value
  Mapping Rules

directories
  including in module code
    Writing Fortran User Functions

directory
  setting up for test
    Setting up your Build Environment

discriminated union
  Syntax

disk space, saving
  Sharing Module Executables

DisplayImg
  pick mode
    Using the Pick Data Type

distorted shapes
  Curvilinear Lattices

DotProduct
  DotProduct (+.*)

dotproduct operator
  DotProduct (+.*)

double
  primType
    Defining Primitive Values

drawing area
  in X Windows
    Using the X-MCW Option

dump
  Data Output from Shape

duplicating parameters
  Using the Parameter API

edges, pyramid
  Understanding Pyramids

eference count
  definition
    Understanding Reference Counting

elements, dictionary
  Using the Dictionary Elements

elements, pyramid
  Understanding Pyramids

embedded struct
  No Anonymous Structure Arrays

empty dictionary
  Disadvantages

enum keyword
  Syntax

enumeration type name, conventions
  Naming Conventions

enumerations
  Type Declaration File

environment variable
  EXPLORERUSERHOME
    Defining EXPLORERUSERHOME
  setting
    Setting Environment Variables

environment, build
  configuring
    Configuring the Build Environment

error recovery
  cxGeometry
    Example 5
  cxLattice
    Example 3
  cxPyramid
    Example 4

ETL (Explorer Typing Language)
  Overview

ETL syntax, summary
  Summary of ETL Syntax

event type
  Terminology

eventData
  Terminology

events
  for hook functions
    Hook Functions

explicit parallelism
  Building a Multiprocessing Module

Explorer languages
  Shape
    Overview

EXPLORERUSERHOME
  directory structure
    Defining EXPLORERUSERHOME
  setting
    Building and Installing Modules
    Building Sample Explorer Modules
    Creating the Directory

EXPLORERUSERHOME variable
  Build and Installation Options

extern
  for C++ functions
    Creating a User Function
  use
    Using Pseudo Input Ports

Extern port
  purpose
    Using Pseudo Input Ports

external function
  referencing
    Using Pseudo Input Ports

extracting parameter values
  Using the Parameter API

faces, pyramid
  Understanding Pyramids

FDEFINES
  Building a Multiprocessing Module

file
  .doc
    The Help File
  type declaration
    Type Declaration File
  .user
    The User Function Prototype

files
  credit files
    Installing Credit Files
  including in Module Builder
    Writing Fortran User Functions
  modulename.interp
    Installing Interpreter Modules
  MODULES
    Creating a Makefile
    The MODULES File
  mon.out
    Coping with Shared Libraries
  .mres
    Opening Modules
  program
    The Basic LatFunction Module
  TYPES
    Building the Type and Related Files
    Creating a Makefile
  user function
    The User Function File

fill mode indicators
  allocation
    Prelude Set-up Functions

fill_type
  Allocate

finite element mesh
  design
    Designing a Finite Element Mesh

finite element pyramid
  structure
    Finite Element Pyramids

firing algorithm
  in MCW
    Module Control Wrapper

float
  primType
    Defining Primitive Values

flush_output_port
  Data Output from Shape

For loop controller
  The For Module

Fortran
  with geometry modules
    Geometry Modules in Fortran

Fortran access routines
  The Data Type Declaration

Fortran lattice
  data storage
    Manipulating Lattices

Fortran libraries
  adding
    Associated Libraries

Fortran wrappers
  suppressing
    Suppressing char** Routines

Fortran wrappers for UDTs
  Fortran Wrappers

Func Args window
  Creating an Argument List

function argument
  Defining Function Arguments
  connections
    Creating a Link
  defining
    Defining the Function Arguments

function argument connections
  Connecting Arguments to Ports

function name
  Defining Function Arguments

functions
  API
    API Member Types and Functions

gather function
  Scatter and Gather

GenerateColormap
  Using the X-MCW Option

generic loop controllers
  using
    Using Generic Controller Modules

Generic Wrapper
  The Module Wrappers
  The Generic Wrapper
  hook functions
    Hook Functions

GenLat
  Resemblances to C
  Resemblances to C

geometry
  data structure
    The Geometry Data Type
  transcription
    Decoding and Recoding Scene Graphs

geometry libraries
  adding
    Associated Libraries

Geometry library
  access from Fortran
    Geometry Modules in Fortran

geometry module
  example
    An Example Geometry Module

geometry modules
  examples
    Code Examples

GLXWidget
  example
    Graphics Library (GL) Example

Graphics Library
  adding
    Associated Libraries

grid data
  Understanding Pyramids

group node
  Understanding Scene Graphs

help file
  The Help File
  updating
    The Help File

highlighting
  in Connections window
    Highlighted Connections

Histogram
  Using the X-MCW Option

hit
  Terminology

hit objects
  Gathering Shape Information.

hook function
  creating a prototype
    Hook Function Prototypes
  use
    Hook Functions

hook function table
  Hook Functions

hook functions
  calling sequence
    Hook Function Calling Sequence
  link tag
    Hook Function Calling Sequence
  prototypes
    Writing Hook Functions

illegal type declarations
  No Anonymous Structure Arrays

images
  obtaining information
    Understanding the Picking Function

ImageVision Library modules
  Types of Shared Executable

Imake
  definition
    Making Subdirectories for Module Development

imake command
  use
    Using Imake in Module Building

Imakefile
  Using Generated Makefiles

in-line structures
  Structures

include files
  installation
    Defining EXPLORERUSERHOME

Includes slot
  The Include Files

including files
  Including Other Type and Header Files

incrementing the reference count
  How Reference Counting Works

input port
  geometry
    Creating Geometry Modules
  pseudo
    Using Pseudo Input Ports

Input Ports window
  Defining Input Ports

Inside
  Inside

inside argument
  Inside

insideout
  InsideOut

insideout argument
  InsideOut

installing a type declaration file
  Building the Type and Related Files

installing interpreter modules
  Installing Interpreter Modules

installing script files
  Selecting Build Options

INSTALLSTRIPPED variable
  Build and Installation Options

integer
  primType
    Defining Primitive Values

integer sign
  Signing Integer Types

interface, module
  Defining the User Interface

interfaces, MCW
  Module Control Wrapper

interleaved selection
  Inside

interleaving
  curvilinear coordinates
    Curvilinear Lattices
  lattice coordinate values
    Storing Coordinate Values
  lattice data values
    Storing Data Values

interpreter module
  Types of Shared Executable
  installing
    Installing Interpreter Modules

interpreter module files
  Installing Interpreter Modules

interpreter modules
  Overview

Inventor
  definition
    Understanding Geometry
  use with languages
    Geometry Modules in Fortran
  with languages
    Understanding Geometry

Inventor code
  in geometry modules
    An Example Geometry Module

irregularly spaced structures
  Perimeter Lattices

IsosurfaceLat
  Resemblances to C
  To Create a Test Volume

keywords
  for ETL
    Syntax

label
  definition
    Assigning Labels
  example of use
    Labeling Items in Scene Graphs
  use in picking
    Getting Data on the Hit Object

label, for pick data
  Modules that Read Pick Data

labels
  for type members
    Assigning Labels
  generating API routines
    Assigning Labels
  in Module Builder
    Assigning Labels

language interpreter
  Overview

languages
  in user functions
    Using Several Function Files

LatFunction
  Overview
  Types of Shared Executable
  basic form
    The Basic LatFunction Module
  generic form
    The LatFunction Module
    The LatFunction-based Module
  prelude and postlude
    The Module Prelude and Postlude

lattice
  for a colormap
    Setting Lattice Constraints
  perimeter coordinates
    Perimeter Lattices
  rank
    Lattice Manipulations
  shape
    Lattice Manipulations
  uniform coordinates
    Uniform Lattices

lattice API routines
  The Lattice API Routines

Lattice Constraints window
  Setting Lattice Constraints
  Limiting Lattice Values
  Defining the Data Type

lattice dimensions
  The Lattice Data Type

lattice manipulations
  Lattice Manipulations

lattice modules
  examples
    Code Examples

lattice variables
  How Variables Interact

lattices
  curvilinear coordinates
    Curvilinear Lattices
  in Shape
    Lattice Manipulations
  limiting range
    Limiting Lattice Values

layer, pyramid
  The Structure of a Pyramid

libmalloc.a
  Building a Multiprocessing Module

libmpc.a
  Building a Multiprocessing Module

libraries
  adding specific
    Associated Libraries
  default
    Associated Libraries
  for user-defined types
    Associated Libraries

Libraries slot
  Associated Libraries

library files
  What the Files Do

line segments, creating
  Creating Line Segments

linkage
  hook functions
    Writing Hook Functions

linkID values
  hook functions
    Hook Function Calling Sequence

linking modules
  Selecting Build Options

list function
  List

list processing commands
  List Operators

list_first
  Handling Perimeter Lattice Coordinates

list_rest
  Handling Perimeter Lattice Coordinates

lists of arrays
  in Shape
    List Operators

locating a node
  Storing Data Values

long
  primType
    Defining Primitive Values

loop controller
  building
    Building Loop Controller Modules
  capabilities
    Building Loop Controller Modules
  setting status
    Selecting Build Options

loop iteration, halting
  Using the Loop Controller API

main window, Module Builder
  Opening Modules

make all
  Setting Up a Personal Module Tree

make clean
  Setting Up a Personal Module Tree

make clean command
  Make Clean

make command
  Creating a Module

make depend
  Setting Up a Personal Module Tree

make install
  with interpreter modules
    Installing Interpreter Modules

make install command
  Creating a Makefile
  Installing a Module

make variables
  fixed
    Using Generated Makefiles
  user-definable
    Using Generated Makefiles

make_lat
  Output Ports

Makefile
  Default Makefile Actions
  creating
    Building the Type and Related Files
  for debugging
    Setting Environment Variables
  recreating
    Creating a Makefile

Makefiles
  Using Makefiles
  making
    Setting Up a Personal Module Tree
  using
    User Makefiles
    Using Makefiles

Makefiles, making
  Building Sample Explorer Modules

managing shared memory
  Managing Data in Shared Memory

manpages
  installation
    Defining EXPLORERUSERHOME

MANPATH variable
  defining
    Location of API ManPages

map
  for channel selector moduile
    Running the Build Command

Map Editor
  data types in
    In the GUI

map function
  Map and Apply

mapping rules
  Mapping Rules

matrices
  Lattice Manipulations

max operator
  Min and Max

mbuilder command
  Opening Modules

MCW
  Module Control Wrapper
  loop control
    Building Loop Controller Modules
  module firing
    Module Firing

MDW
  Module Data Wrapper
  and function arguments
    Creating an Argument List

member names, conventions
  Naming Conventions

memCleanup
  Example 1

memory
  leaking
    Mapping Rules
  shared
    Copying Arrays

memory allocation, limitations
  Allocating Memory Efficiently

memory errors
  recovery
    Recovering from Memory Errors

memory leak
  MDW
    Managing Data in Shared Memory

menu bar options
  Creating a Menu Item

metatypes
  The Generic Wrapper

min operator
  Min and Max

modifiers
  Terminology

modifying
  Using Generated Makefiles

modifying existing modules
  Modifying Existing Modules

module
  color modification
    An Example Geometry Module

Module Builder
  data types in
    In the GUI
  main window
    Opening Modules
  purpose
    Introduction to Module building
  running
    Running the Module Builder
  starting up
    Invoking the Module Builder
  using windows
    Defining the Internal Structure

module building
  environment variable
    Setting Environment Variables
  process
    Introduction to Module building
  tutorial
    Building a Module

Module Control Wrapper
  function
    Module Control Wrapper
  selecting type
    Selecting Build Options

module data types
  cxGeneric
    The cxGeneric Data Type

Module Data Wrapper
  function
    Module Data Wrapper

module defaults
  setting
    Using the Build Menu

module executable
  sharing
    Sharing Module Executables

module firing
  Module Firing

module firing sequence
  firing sequence
    Firing Sequences

module interface
  controlling
    Defining Function Arguments

module ports
  Creating Ports

module resource (.mres) file
  Saving the Module Resources

module resources file
  Opening Modules
  for shared executable
    Using an Alternate Executable

modulename
  definition
    The Module Name

modules
  auto-generated
    Auto-generated Modules
  building and installing
    Building and Installing Modules
  creating prototypes
    Prototyping on the Fly
  credit files
    Installing Credit Files
  customized interfaces
    Module Data Wrapper
  debugging
    Debugging a Module
  generic loop controllers
    Using Generic Controller Modules
  geometry
    The Geometry Data Type
    Creating Geometry Modules
  geometry examples
    Code Examples
  inter-communication
    Between Modules
  lattice examples
    Code Examples
  loop controllers
    Building Loop Controller Modules
  modifying
    Modifying Existing Modules
  multiprocessing
    Support for Multiprocessing Modules
  pick examples
    Code Examples
  profiling
    Profiling a Module
  purpose
    Introduction to Module building
  saving
    Saving Modules
  write pick data
    Modules that Write Pick Data
  writing geometry
    Writing a Geometry Module

MODULES file
  The MODULES File
  Creating a Makefile

modules with X-MCW
  Using the X-MCW Option

molecular modelling data
  Understanding Pyramids

.mres file
  Opening Modules
  saving
    Moving Around the Windows
  updating
    Updating the Module Resources

multiple data flushes
  Sending Data Downstream

multiple data references
  How Explorer Implements Reference Counting

multiprocessing modules
  Support for Multiprocessing Modules

naming a module
  Naming Modules

naming convention
  for UDTs
    Naming Files and Data Types
  standard
    Naming Conventions

nDim
  The Lattice Data Type
  definition
    The Dimension Variables

nDim value
  Mapping Rules

node
  definition
    Understanding Lattices
  geometry
    Understanding Scene Graphs
  root
    Decoding and Recoding Scene Graphs

node coordinates
  The cxCoord Structure

node values
  cxData
    The cxData Structure

nodes
  computing
    Storing Data Values
  locating
    Storing Data Values

non-uniform B-spline
  Curvilinear Lattices

null_p
  Pair_p and Null_p

object
  pick information
    Terminology

object hit by pick
  Terminology

object, pyramid
  Understanding Pyramids

OK button
  Moving Around the Windows

optional port
  Input Port Characteristics

origin of pick
  Terminology

output port
  Defining Output Ports
  hook function
    Checking the Port Status
  mapping rules
    Mapping Rules
  menu highlighting
    Highlighted Connections
  status
    Checking the Port Status

output ports
  pick
    Understanding the Picking Function

Output Ports window
  Defining Output Ports

output_data_flush
  Output Ports

Outside
  Outside

outside argument
  Outside

pair_p
  Pair_p and Null_p

parallel compilation
  Building a Multiprocessing Module

parallel threads
  Controlling a Multiprocessing Module

parameter
  widget value
    Control Panel Widgets

perimeter coordinates
  Interfacing to Explorer Data Types

perimeter coordinates in Shape
  Handling Perimeter Lattice Coordinates

perimeter lattices
  Perimeter Lattices

pick data
  in modules
    Using the Pick Data Type

pick ID
  Getting Data on the Hit Object

pick map
  Labeling Items in Scene Graphs

pick mode
  Using the Pick Data Type

pick module
  user interface
    Understanding the Picking Function

pick modules
  examples
    Code Examples

picking terms
  Terminology

pixie command
  Using pixie

point
  defined for pick
    Getting Data on the Hit Object

pointer
  Understanding the Connections Menu

pointer variables in ETL
  No Pointer Variables

pointers
  to data types
    Type

pointers to arrays
  copying
    Copying Arrays

port
  connections menu
    Understanding the Connections Menu

port connections
  Connecting Ports and Function Arguments
  Connecting Arguments to Ports

port data type
  Input Port Characteristics

port identifiers
  LatFunction
    Data Output from Shape

port name
  Input Port Characteristics

port status
  flag
    Input Port Characteristics
  options
    Defining Lattice Constraint Fields

portID
  Data Output from Shape

ports
  Creating Ports
  data types on
    In the GUI

position of pick
  Terminology

postlude functions
  Postlude Functions

prelude functions
  Prelude Set-up Functions

primitive data type
  Defining Primitive Values

primitive data types
  Defining Lattice Constraint Fields

primitive type
  cxParameter
    Understanding Parameters

PrintLat
  Lattice Manipulations

PrintPick
  Modules that Read Pick Data

profiling modules
  Profiling a Module
  pixie
    Using pixie

program file
  The Basic LatFunction Module

program files
  installing
    Selecting Build Options

promoting arrays
  Promotion of Arrays

property node
  Understanding Scene Graphs

prototype
  help file
    Creating File Prototypes
  hook function
    Hook Function Prototypes
  user function
    The User Function Prototype

prototype documentation
  creating
    Default Makefile Actions

pseudo ports
  Using Pseudo Input Ports

pseudo-ports
  Using the Pseudoports

Pyramid Constraints window
  Setting Pyramid Constraints

pyramid data structure
  definition
    Understanding Pyramids

pyramid dictionary
  purpose
    Pyramid Dictionaries
  use
    Using a Pyramid Dictionary

pyramid output port
  constraints
    Defining Port Characteristics

pyramid reader
  example
    A Pyramid Reader Module

pyramid structure
  Creating a Tetrahedral Grid

pyramids
  purpose
    Understanding Pyramids

QueryLat
  read pick data
    Modules that Read Pick Data

QueryLat module
  Labeling Items in Scene Graphs

quit
  Quitting the Module Builder

rank
  of a lattice
    Lattice Manipulations

reading geometry
  Writing a Geometry Module

reading pick data
  Using the Pick Data Type
  example
    Modules that Read Pick Data

real
  primType
    Defining Primitive Values

receiver object
  in Inventor code
    Decoding and Recoding Scene Graphs

recovering from allocation errors
  examples
    Examples of Memory Recovery

recovering from memory errors
  Recovering from Memory Errors

recovery labels
  use
    Example 2

recursive data types
  Syntax

reduction of arrays
  Reduction of Arrays

reference
  external function
    Using Pseudo Input Ports
  to pyramid dictionaries
    The Structure of a Pyramid

reference counting
  Explorer version
    How Explorer Implements Reference Counting

reference counts
  Reference-Counting Data Types
  removal hook
    Writing Hook Functions

reference elements, pyramid dictionary
  Using the Dictionary Elements

reference-counted data types
  Reference-Counting Data Types

reference-counted structure
  Structures
  handling memory
    Memory Handling

reference-counted structures
  Reference-counted Structures
  Syntax

references
  for variables
    References

Render
  pick mode
    Using the Pick Data Type

Render module
  action
    Understanding Scene Graphs

renderer module
  A Simple Renderer

Repeat loop controller
  Using Generic Controller Modules

required port
  Input Port Characteristics

residues
  Chemistry Pyramids

restrictions
  on lattice ports
    Setting Lattice Constraints

return value
  Return Val?

RGB
  A 2-D Image Example

rocessing geometry
  The Geometry Data Type

root data type
  The Lattice Data Type
  creating
    Overview
  cxPyramid
    The Structure of a Pyramid

root directory
  for user
    Defining EXPLORERUSERHOME

root keyword
  Syntax

routines
  conversion to modules
    Module Data Wrapper

running the Module Builder
  Running the Module Builder

saving data
  incrementing the reference count
    Manipulating Reference Counts

saving disk space
  Sharing Module Executables

saving modules
  Saving Modules

scalar
  Lattice Manipulations
  Input Ports

scalar sign
  Signing Other Scalar Types

scalar types
  in Explorer
    Scalar Types

scalar value
  datatype
    Understanding Parameters

scalar_lattice_in
  Scalar_lattice_in and Scalar_lattice_out

scalar_lattice_out
  Scalar_lattice_in and Scalar_lattice_out

scatter function
  Scatter and Gather

scene graph
  The Geometry Data Type
  definition
    Understanding Scene Graphs

scoping in Shape
  Issues of Scope

scoping structures
  Scoping

script files
  installing
    Selecting Build Options

scripting
  from within modules
    The Scripting API

selecting a text type-in slot
  Moving Around the Windows

send_indices function
  SendIndices

SendIndices
  SendIndices

setting scalar parameters
  Using the Parameter API

setting up
  Setting Up a Personal Module Tree

setting up a build system
  Setting Up a Personal Module Tree

setting up a user directory
  Making Subdirectories for Module Development

Shape
  and C
    Resemblances to C
  copy function
    Copy
  data output
    Data Output from Shape
  data types
    Data Types
  function declaration
    Function Declaration Syntax
  garbage collection
    Additional Features
  loop syntax
    Loop Syntax
  of a lattice
    Lattice Manipulations
  subarry selection
    Additional Features

shape function
  Shape

Shape language
  Overview

shape nodes
  Understanding Scene Graphs

shared executable
  types
    Types of Shared Executable

shared keyword
  Syntax

shared libraries
  Setting Environment Variables
  with profiling
    Coping with Shared Libraries

shared member
  Differences Between Structures

shared memory
  reference counting
    Managing Data in Shared Memory
  UDTs
    Memory Handling
  used by Explorer
    Understanding Reference Counting

shared memory arena
  Shared Memory Arena

sharing a structure
  Differences Between Structures

sharing an executable
  Sharing Module Executables

sharing data
  Examples of Reference-counted Structures

short
  primType
    Defining Primitive Values

simple tetrahedral grid
  Creating a Tetrahedral Grid

simple-typed member
  Structure Member Declaration

sin function
  Map and Apply

slice function
  Slice

source directory
  making
    Building Sample Explorer Modules

spheres
  creating
    Creating More Geometry
  texturing
    Texturing a Sphere

stack
  Stack

stacking operator
  Stack

standard output
  setting
    Selecting Build Options

storage
  allocate for user function
    Allocating Storage Space
    Using Pseudo Input Ports
  array values
    Manipulating Lattices

storage size
  setting
    Using the Pseudoports

Streakline
  Building Loop Controller Modules

struct
  Type Declaration File

struct keyword
  Syntax

struct structures
  Struct Structures

structure
  of data type
    Understanding the Connections Menu
  unique name
    No Anonymous Structure Arrays

subarray selection
  in Shape
    Additional Features

subroutine
  creating
    Creating a User Function
  definition
    Creating a User Function

subshape
  Scatter and Gather

subshape function
  Subshape

subsidiary data type
  definition
    Creating a Data Type

sumCoord
  Perimeter Lattices

suppressing API routines
  Suppressing char** Routines

surface normal
  for picking
    Getting Data on the Hit Object

switch discriminators
  scoping rules
    Using Switch Discriminators

switch keyword
  Syntax

switch structure
  Switch Structures
  ETL to C
    The Resulting C Structure
  labels
    Functions for Members in a Switch

symbol table
  Setting Environment Variables

symbolic links
  Setting Environment Variables

system-defined variable
  The Include Files

temporary storage
  Allocating Storage Space

threads
  controlling in multiprocessors
    Controlling a Multiprocessing Module

transform
  global
    Getting Data on the Hit Object
  local
    Getting Data on the Hit Object

transform matrix
  Getting Data on the Hit Object

Trigger
  The cxGeneric Data Type

type coercion
  Defining Lattice Constraint Fields
  Understanding Parameters
  Automatic Type Coercion of Arrays

type declaration
  cxParameter
    The Data Type Declaration
  cxPick
    The Data Type Declaration
  geometry
    Data Type Declaration

type declaration file
  across machine boundaries
    Crossing Machine Boundaries
  machine-specific
    Crossing Machine Boundaries

type declaration files
  Type Declaration File

type definition
  cxCoord
    The cxCoord Structure
  cxData
    The cxData Structure
  cxPick
    Terminology
  cxPyramid
    The Structure of a Pyramid

type files
  installation
    Defining EXPLORERUSERHOME

typedef keyword
  Syntax

TYPES file
  Building the Type and Related Files
  Creating a Makefile

UDT
  Overview
  build process
    What the Files Do
  building
    Building the Type and Related Files
  generated files
    What the Files Do

UDT files
  Building the Type and Related Files

uniform coordinates
  Interfacing to Explorer Data Types

uniform lattices
  Uniform Lattices

union
  ETL toC
    The Resulting C Structure
  in data type
    Type Declaration File

“Update document” command
  Updating the Module Resources

update operators
  Other Operators

user directory
  setting up
    Making Subdirectories for Module Development

User Func File slot
  Using Several Function Files

user function
  alternate executable
    The User Function File
  creating
    Creating a User Function
  definition
    Creating a User Function
    Creating the User Function
  in Fortran
    Writing Fortran User Functions
  language
    Creating a User Function

user function file
  The User Function File

user interface
  for Pick modules
    Understanding the Picking Function

User Makefile slot
  Using Makefiles

user-defined data type
  definition
    Overview

user-defined type
  example
    Example of a User-defined Type

using a shared executable
  Using an Alternate Executable

using generic loop controllers
  Using Generic Controller Modules

using Pick
  Understanding the Picking Function

validating pick data
  Getting Data on the Hit Object

variable declaration in ETL
  Structure Member Declaration

variables
  in cxPick
    The cxPick Structure

variables, passing
  References

varname
  Lattice Manipulations

vector
  Storing Data Values

vectors
  Lattice Manipulations

vertex labelling
  Using the Dictionary Elements

vertices, pyramid
  Understanding Pyramids

vertices, pyramid element
  Using the Dictionary Elements

VolumeToGeom
  To Create a Test Volume

While loop controller
  Using Generic Controller Modules

widget
  passing parameters
    Control Panel Widgets
  Program FIle
    Building a LatFunction-based Module

Widget Attributes
  Defining the User Interface

widgets
  setting several
    Setting Widgets

windows
  Module Builder
    Moving Around the Windows

wiring
  port and functions
    Creating a Link

wiring rules
  Mapping Rules

wrapper code
  default
    Selecting Build Options
    Selecting Build Options

wrappers, module
  The Module Wrappers

write_char
  Data Output from Shape

writing pick data
  Using the Pick Data Type
  Modules that Write Pick Data

X drawing area
  example
    Examples Using X Widgets

X Window System widgets
  API
    Using the X-MCW Option

X WIndow widgets
  Using the X-MCW Option

X-MCW
  use
    Using the X-MCW Option
  wrappers
    Selecting Build Options

XGLArea
  sample output
    Fortran Version:

XorImg
  Types of Shared Executable
  Types of Shared Executable
  Using an Alternate Executable

XtGLArea
  example programs
    XtGLArea Examples

XtGLArea routines
  examples
    XtGLArea Examples

zero-based indexing
  The Data Type Declaration

Prev | Table of Contents |
Appendix B. The Firing Algorithm |  |