Users' Manual

Users' Manual - IRIT

A Solid Modeling Program

(C) Copyright 1989-2009 Gershon Elber

EMail:
Join IRIT mailing list:
Mailing list:
Bug reports:
WWW Page:	http://www.cs.technion.ac.il/~irit

This manual is for IRIT Ver. 10

Copyright (C) 1989-2009 Gershon Elber

EMail: gershon@cs.technion.ac.il

Join IRIT mailing list: gershon@cs.technion.ac.il

Mailing list: irit-mail@cs.technion.ac.il

Bug reports: irit-bugs@cs.technion.ac.il

WWW Page: http://www.cs.technion.ac.il/~irit

Introduction

IRIT is a solid modeler developed for educational purposes. Although small, it is now powerful enough to create quite complex scenes.

IRIT started as a polygonal solid modeler and was originally developed on an IBM PC under MSDOS. Version 2.0 was also ported to X11 and version 3.0 to SGI 4D systems. Version 3.0 also includes quite a few free form curves and surfaces tools. See the UPDATE.NEW file for more detailed update information. In Version 4.0, the display devices were enhanced, freeform curves and surfaces are more extensively supported, functions can be defined, and numerous improvement and optimizations are added.

Copyrights

BECAUSE IRIT AND ITS SUPPORTING TOOLS AS DOCUMENTED IN THIS DOCUMENT ARE LICENSED FREE OF CHARGE, I PROVIDE ABSOLUTELY NO WARRANTY, TO THE EXTENT PERMITTED BY APPLICABLE STATE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING, I GERSHON ELBER PROVIDE THE IRIT PROGRAM AND ITS SUPPORTING TOOLS "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THESE PROGRAMS IS WITH YOU. SHOULD THE IRIT PROGRAMS PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.

IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW WILL GERSHON ELBER, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY LOST PROFITS, LOST MONIES, OR OTHER SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR A FAILURE OF THE PROGRAMS TO OPERATE WITH PROGRAMS NOT DISTRIBUTED BY GERSHON ELBER) THE PROGRAMS, EVEN IF YOU HAVE BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES, OR FOR ANY CLAIM BY ANY OTHER PARTY.

IRIT is a freeware solid modeler. It is not public domain since we hold copyrights on it. However, unless you are to sell or attempt to make money from any part of this code and/or any model you made with this solid modeler, you are free to make anything you want with it. In order to use IRIT commercially, you must license it first - contact us is such a case.

IRIT can be compiled and executed on numerous Unix/Linux systems as well as Windows 98/NT/2000/XP/Vista, Mac, OS2, and AmigaDOS. Also, under Windows, IRIT must be installed at a directory/path with no spaces.

You are not obligated to me or to anyone else in any way by using IRIT. You are encouraged to share any model you made with it, but the models you made with it are yours, and you have no obligation to share them. You can use this program and/or any model created with it for non commercial and non profit purposes only. An acknowledgement on the way the models were created would be nice but is not required.

Command Line Options and Set Up

The IRIT program reads a file called irit.cfg each time it is executed. This file configures the system. It is a regular text file with comments, so you can edit it and properly modify it for your environment. This file is being searched for in the directory specified by the IRIT_PATH environment variable. For example 'setenv IRIT_PATH /u/gershon/irit/bin/'. Note IRIT_PATH must terminate with '/'. If the variable is not set only the current directory is being searched for irit.cfg.

In addition, if it exists, a file by the name of iritinit.irt will be automatically executed before any other '.irt' file. This file may contain any IRIT command. It is the proper place to put your predefined functions and procedures, if you have any. This file will be searched much the same way irit.cfg is. The name of this initialization file may be changed by setting the StartFile entry in the configuration file. This file is far more important starting at version 4.0, because of the new function and procedure definition that has been added, and which is used to emulate BEEP, VIEW, and INTERACT, for example.

The solid modeler can be executed in text mode (see the .cfg and the -t flag below) on virtually any system with a C compiler.

Under all systems the following environment variables must be set and updated:

path	Add to path the directory where IRIT's binaries are.
IRIT_PATH	Directory with config., help and IRIT's binary files.
IRIT_DISPLAY	The graphics driver program/options. Must be in path.
IRIT_BIN_IPC	If set, uses binary Inter Process Communication.

For example,

set path = (path /u/gershon/irit/bin) setenv IRIT_PATH /u/gershon/irit/bin/ setenv IRIT_DISPLAY "xgldrvs -s-" setenv IRIT_BIN_IPC 1

to set /u/gershon/irit/bin as the binary directory and to use the sgi's gl driver. If IRIT_DISPLAY is not set, the server (i.e., the IRIT program) will prompt and wait for you to run a client (i.e., a display driver). if IRIT_PATH is not set, none of the configuration files, nor the help file will be found.

If IRIT_BIN_IPC is not set, text based IPC is used, which is far slower. There is no real reason not to use IRIT_BIN_IPC, unless it does not work for you, for some reason.

In addition, the following optional environment variables may be set.

IRIT_MALLOC	If set, apply dynamic memory consistency testing.
	Programs will execute much slower in this mode.
IRIT_MALLOC_PTR	Set to a pointer address and the program will scream
	once this pointer is allocated, if IRIT_MALLOC is set.
IRIT_MALLOC_STACK	Under Windows only, keeps stack info on all mallocs.
IRIT_NO_SIGNALS	If set, no signals are caught by IRIT.
IRIT_SERVER_HOST	Internet Name of IRIT server (used by graphics driver).
IRIT_SERVER_PORT	Used internally to the TCP socket number. Should not
	be set by users.
IRIT_TIME_OUT	Integer (seconds) for timing out when trying
	to execute a display device from IRIT. Default is 10
	seconds.
IRIT_INCLUDE	A semicolon separated list of directories, in which to
	look for the irt files to include. See INCLUDE command.
LD_LIBRARY_PATH	If shared libraries are created, this variable must be
	updated to point to the shared libraries' directory.

For example,

setenv IRIT_MALLOC 1 setenv IRIT_MALLOC_PTR 1234567890 setenv IRIT_NO_SIGNALS 1 setenv IRIT_SERVER_HOST irit.cs.technion.ac.il setenv IRIT_INCLUDE "/d2/gershon/irit/irit/scripts;/tmp"

IRIT_MALLOC is useful for programmers, or when reporting a memory fatal error occurrence. This variable, when set as a non zero value, will activate the following (hexadecimal bit settings with any combination of the following):

0x01	A test for overwriting before the dynamic memory
	is allocated or immediately after it. Cheap in time.
0x02	Savings of all allocated objects in a table for the
	detection of freeing unallocated objects and consistency
	of the entire dynamic memory. Time expensive.
0x04	Zeros every freed object, once it is freed.
0x08	On Windows environments - enables _CrtCheckMemory checks
	every malloc/free, in debug compilation modes.
0x10	On Windows environments - enables _CrtCheckMemory checks
	every 16 mallocs/frees, in debug compilation modes.

IRIT_NO_SIGNALS is also useful for debugging when contorl-C is used within a debugger. The IRIT_SERVER_HOST/PORT controls the server/client (IRIT/Display device) communication.

IRIT_SERVER_HOST and IRIT_SERVER_PORT are used in the unix and Window NT ports of IRIT.

See the section on graphics drivers for more details.

A session can be logged into a file as set via LogFile in the configuration file. See also the LOGFILE command.

The following command line options are available:

IRIT [-t] [-g] [-q] [-i] [-z] {[-m ...]} [file.irt]

-t	Puts IRIT into text mode. No graphics will be displayed and
	the display commands will be ignored. This is useful when
	one needs to execute an IRIT file to create data on a tty
	device...
-g	IRIT under GUI mode. Should not be used by end users.
-q	Quiet mode with no regular output to stdout.
-i	IRIT under Interactive mode. Should not be used by end users.
-z	Prints usage message and current configuration/version
	information.
-m	Optional option... If IRIT is compiled for debugging, allows
	setting three addition parameters of trap pointer, search
	pointer, and abort counter.
file.irt	A file to invoke directly instead of waiting to input from
	stdin.

IBM PC OS2 Specific Set Up

Under OS2 the IRIT_DISPLAY environment variable must be set (if set) to os2drvs.exe without any option (-s- will be passed automatically). os2drvs.exe must be in a directory that is in the PATH environment variable. IRIT_BIN_IPC can be used to signal binary IPC which is faster. Here is a complete example:

set IRIT_PATH=c:\irit\bin\ set IRIT_DISPLAY=os2drvs -s- set IRIT_BIN_IPC=1

assuming the directory specified by IRIT_PATH holds the executables of IRIT and is in PATH.

If IRIT_BIN_IPC is not set, text based IPC is used which is far slower. There is no real reason not to use IRIT_BIN_IPC unless it does not work for you, for some reason.

The OS2 executables are typically built using the EMX port of gnu C compiler. The distribution of the executables does not include the EMX run time library and any attempt to run IRIT will fail. You will get an error message such as "File EMX does not exist". You can get the run time from

ftp to ftp-os2.nmsu.edu (aliased also as hobbes.NMSU.Edu) cd to os2/unix/emx09c (or a newer version number/level) get emxrt.zip and place its dlls in a place they would be found.

IBM PC Window 95/98/NT/2000/XP Specific Set Up

The NT port uses sockets and is, in this respect, similar to the Unix port. The envirnoment variables IRIT_DISPLAY, IRIT_SERVER_HOST, and IRIT_BIN_IPC should all be set in a similar way to the Unix specific setup. As a direct result, the server (IRIT) and the display device can run on different hosts. For example, the server might be running on an NT system while the display device will be running on an SGI4D, exploiting the graphic's hardware capabilities. Here is a complete example:

set IRIT_PATH=c:\irit\bin\ set IRIT_DISPLAY=wntgdrvs -s- set IRIT_BIN_IPC=1

Also, under Windows, IRIT must be installed in a directory/path with no spaces.

Unix Specific Set Up

Under UNIX using X11 (x11drvs driver), add the following options to your .Xdefaults. Most are self explanatory. The Trans attributes control the transformation window, while the View attributes control the view window. SubWin attributes control the subwindows within the transformation window.

#if COLOR
iritTransBackGround:	NavyBlue
iritTransBorderColor:	Red
iritTransBorderWidth:	3
iritTransTextColor:	Yellow
iritTransSubWin*BackGround:	DarkGreen
iritTransSubWin*BorderColor:	Magenta
iritTransGeometry:	=150x500+500+0
iritTransCursorColor:	Green
iritViewBackGround:	NavyBlue
iritViewBorderColor:	Red
iritViewBorderWidth:	3
iritViewGeometry:	=500x500+0+0
iritViewCursorColor:	Red
irit*MaxColors:	15
#else
iritTransGeometry:	=150x500+500+0
iritTransBackGround:	Black
iritViewGeometry:	=500x500+0+0
iritViewBackGround:	Black
irit*MaxColors:	1
#endif

First Usage

Commands to IRIT are entered using a textual interface, usually from the same window from which the program was executed.

Some important commands to begin with are:

1. include("file.irt"); - will execute the commands in file.irt. Note include can be recursive up to 10 levels. To execute the demo (demo.irt) simply type 'include("demo.irt");'. Another way to run the demo is by typing demo(); which is a predefined procedure defined in iritinit.irt.

2. help(""); - will print all available commands and how to get help on them. A file called irit.hlp will be searched as irit.cfg is being searched (see above), to provide the help.

3. exit(); - close everything and exit IRIT.

Most operators are overloaded. This means that you can multiply two scalars (numbers), or two vectors, or even two matrices, with the same multiplication operator (*). To get the on-line help on the operator '*', type 'help("*");'

The best way to learn this program (as any other program...) is by trying it. Print the manual and study each of the commands available. Study the demo programs (*.irt) provided, as well.

The "best" mode in which to use IRIT is via the emacs editor. With this distribution an emacs mode for IRIT files (irt postfix) is provided (irit.el). Make your .emacs load this file automatically. Loading file.irt will switch emacs into an IRIT mode that supports the following keystrokes:

Meta-E	Executes the current line
Meta-R	Executes the current Region (Between Cursor and Mark)
Meta-S	Executes a single line from input buffer
Meta-H	Prints IRIT help on the current WORD the point is on using 'help("WORD");'

The first time one of the above keystrokes is hit, emacs will fork an IRIT process so that IRIT'S stdin is controlled via the above commands. This emacs mode was tested under various Unix environments, under OS2 2.x/3.x, and under Windows 95/98/NT/2000/XP.

Line Editing

The IRIT interpreter provides full line editing capabilities. The following are the available control options:

^a	Beginning of line
^e	End of line
^f	Forward one character
^b	Backward one character
^d	Delete current character
^h (Backspace)	Delete backward one character
^i (Tab)	Toggles overwrite/insert mode
^k	Kill to end of line
^p	Get previous history line
^n	Get next history line
^j (LineFeed)	Done with this line

Only lines entered from stdin will enter the history queue. The above control capabilities are fully configurable via the irit.cfg configuration file.

Data Types

These are the Data Types recognized by the solid modeler. They are also used to define the calling sequences of the different functions below:

ConstantType	Scalar real type that cannot be modified.
NumericType	Scalar real type.
VectorType	3D real type vector.
PointType	3D real type point.
CtlPtType	Control point of a freeform curve or surface.
PlaneType	3D real type plane.
MatrixType	4 by 4 matrix (homogeneous transformation matrix).
PolygonType	Object consists of polygons.
PolylineType	Object consists of polylines.
CurveType	Object consists of curves.
SurfaceType	Object consists of surfaces.
TrimSrfType	Object consists of trimmed surfaces.
TriSrfType	Object consists of triangular surfaces
TrivarType	Object consists of trivariate functions.
MultivarType	Object consists of multivariate functions.
FreeformType	One of CurveType, SurfaceType, TrimSrfType,
	TrivarType, MultivarType, TriSrfType.
GeometricType	One of Polygon/lineType, FreeformType.
InstanceType	Object with a GeometryType and a Transformation.
GeometricTreeType	A list of GeometricTypes or GeometricTreeTypes.
StringType	Sequence of chars within double quotes - "A string".
	Current implementation is limited to 80 chars.
AnyType	Any of the above.
ListType	List of (any of the above type) objects. List
	size is dynamically increased, as needed.

Although points and vectors are not the same, IRIT does not distinguish between them, most of the time. In this future this might change.

Commands summary

These are all the commands and operators supported by the IRIT Solid Modeler:

+	BSCTSPRSPR	COORD	FFPTDIST	MEVAL
-	BSCTTRSPT	COS	FFPTTYPE	MFROMMESH
*	BSCTTRSSPR	COVERISO	FFSPLIT	MFROMMV
/	BSP2BZR	COVERPT	FITPMODEL	MMERGE
^	BZR2BSP	CPATTR	FIXPLGEOM	MOFFSET
=	CALPHASECTOR	CPINCLUDE	FIXPLNRML	MOMENT
==	CANGLEMAP	CPOLY	FLOOR	MPOWER
!=	CARCLEN	CPOWER	FMOD	MPROMOTE
<	CAREA	CRAISE	FNFREE	MRAISE
>	CARRANGMNT	CRC2CRVTAN	FOR	MRCHCUBE
<=	CBEZIER	CREDUCE	FREE	MREFINE
>=	CBIARCS	CREFINE	FUNCTION	MREGION
ABS	CBISECTOR2D	CREGION	GBOX	MREPARAM
ACOS	CBISECTOR3D	CREPARAM	GETATTR	MREVERSE
ADAPISO	CBSPLINE	CROSSEC	GETLINE	MSCIRC
ADWIDTH	CCINTER	CRV2TANS	GETNAME	MSLEEP
ALGSUM	CCRVTR	CRVKERNEL	GGINTER	MSCONE
ANALYFIT	CCRVTR1PT	CRVLNDST	GPOLYGON	MSSPHERE
ANIMEVAL	CCRVTREVAL	CRVPTDST	GPOLYLINE	MVCONTACT
ANTIPODAL	CDERIVE	CRVPTTAN	HAUSDORFF	MVEXPLICIT
AOFFSET	CDIVIDE	CSPIRAL	HELP	MVINTER
ARC	CEDITPT	CSURFACE	HERMITE	MZERO
ARC360	CENVOFF	CTANGENT	HOMOMAT	NCCNTRPATH
AREA	CEVAL	CTLPT	IF	NCPCKTPATH
ASIN	CEXTREMES	CTRIMSRF	IMPLCTRANS	NIL
ATAN	CFNCRVTR	CUBICCRVS	INCLUDE	NREF
ATAN2	CHDIR	CVIEWMAP	INSERTPOLY	NRMLCONE
ATTRIB	CIEXTREME	CVISIBLE	INSTANCE	NTH
ATTRPROP	CINFLECT	CYLIN	INTERACT	OFFSET
AWIDTH	CINTERP	CZEROS	IQUERY	ORTHOTOMC
BBOX	CINTEG	DIST2FF	IRITSTATE	PATTRIB
BLHERMITE	CIRCLE	DSTPTLN	ISGEOM	PAUSE
BLSHERMITE	CIRCPOLY	DSTPTPLN	ISOCLINE	PCIRCLE
BLOSSOM	CLNTCLOSE	DSTLNLN	KNOTCLEAN	PCRVTR
BOOLONE	CLNTCRSR	DUALITY	KNOTREMOVE	PDECIMATE
BOOLSUM	CLNTEXEC	ELLIPSE3PT	LINTERP	PDOMAIN
BOUNDARY	CLNTREAD	ERROR	LIST	PIMPRTNC
BOX	CLNTWRITE	EVOLUTE	LN	PLANE
BSCTCONCN2	CMESH	EXEC	LOAD	PLANECLIP
BSCTCONCON	CMOEBIUS	EXIT	LOFFSET	PLN3PTS
BSCTCONCYL	CMORPH	EXP	LOG	PMORPH
BSCTCONLN	CMULTIRES	EXTRUDE	LOGFILE	PNORMAL
BSCTCONPL	CNORMAL	FFCMPCRV	MAP3PT2EQL	POINT
BSCTCONPT	CNRMLCRV	FFCOMPAT	MATDECOMP	POLARSIL
BSCTCONSPR	CNVXHULL	FFCTLPTS	MATPOSDIR	POLY
BSCTCYLCYL	COERCE	FFEXTREME	MAXEDGELEN	POLYHOLES
BSCTCYLPL	COLOR	FFGTYPE	MBEZIER	POWER
BSCTCYLPT	COMMENT	FFKNTVEC	MBISECTOR	PPINCLUDE
BSCTCYLSPR	COMPOSE	FFMATCH	MBSPLINE	PPINTER
BSCTPLNLN	CON2	FFMERGE	MDERIVE	PPROPFTCH
BSCTPLNPT	CONE	FFMESH	MDIVIDE	PRINTER
BSCTSPRLN	CONICSEC	FFMSIZE	MERGEPLLN	PRINTF
BSCTSPRPL	CONTOUR	FFORDER	MERGEPOLY	PRINTFILE
BSCTSPRPT	CONVEX	FFPOLES	MESHSIZE

PRISA	SASPCTGRPH	SMOMENTS	SURFREV	TMORPH
PROCEDURE	SASYMPEVAL	SMOOTHNRML	SURFREVAXS	TNSCRCR
PROJMAT	SAVE	SMORPH	SURFREV2	TOFFSET
PT3BARY	SBEZIER	SNOC	SURFREVAX2	TORUS
PTHMSPR	SBISECTOR	SNORMAL	SVISIBLE	TRAISE
PTLNPLN	SBSPLINE	SNRMLSRF	SVOLUME	TRANS
PTPTLN	SCALE	SPARABOLC	SWEEPSRF	TREFINE
PTREGISTER	SCRVTR	SPHERE	SWPSCLSRF	TREGION
PTS2PLLN	SCRVTREVAL	SPLITLST	SWUNGASUM	TREPARAM
PTS2PLYS	SDDMMAP	SQRT	SYMBCPROD	TRIANGL
PTSLNLN	SDERIVE	SRADCRVTR	SYMBDIFF	TRIMSRF
QUADCRVS	SDIVIDE	SRAISE	SYMBDPROD	TRMSRFS
QUADRIC	SEDITPT	SRAYCLIP	SYMBIPROD	TSBEZIER
RANDOM	SELFINTER	SREFINE	SYMBPROD	TSBSPLINE
RAYTRAPS	SETCOVER	SREGION	SYMBSUM	TSDERIVE
RFLCTLN	SETNAME	SREPARAM	SYSTEM	TSEVAL
RFLCTMAT	SEVAL	SREVERSE	TAN	TSGREGORY
RESET	SFLECNODAL	SRF2TANS	TBEZIER	TSNORMAL
RMATTR	SFOCAL	SRF3TANS	TBSPLINE	TVLOAD
ROTVEC	SFROMCRVS	SRFFFORM	TCRVTR	TVZRJACOB
ROTV2V	SGAUSS	SRFLNDST	TDERIVE	UVPOLY
ROTX	SILHOUETTE	SRFKERNEL	TDIVIDE	VARLIST
ROTY	SIN	SRFPTDST	TEDITPT	VECTOR
ROTZ	SINTERP	SRINTER	TEVAL	VIEW
ROTZ2V	SIZEOF	SSINTER	TEXTGEOM	VIEWOBJ
ROTZ2V2	SKEL2DINT	SSINTR2	TEXTWARP	VIEWSET
RRINTER	SMEAN	STANGENT	TFROMSRFS	VOLUME
RULEDSRF	SMERGE	STRIMSRF	TIME	WHILE
RULEDTV	SMESH	STRIVAR	TINTERP	ZCOLLIDE
SACCESS	SMOEBIUS	SURFPREV	THISOBJ

Functions and Variables

Functions that return a NumericType:

ABS	COS	EXP	POWER	THISOBJ
ACOS	CLNTEXEC	FLOOR	RANDOM	VOLUME
AREA	CPOLY	FMOD	SIN
ASIN	DSTPTLN	LN	SIZEOF
ATAN	DSTPTPLN	LOG	SQRT
ATAN2	DSTLNLN	MESHSIZE	TAN

Functions that return a GeometricType:

ADAPISO	CDERIVE	CVIEWMAP	MDIVIDE	PTHMSPR
ALGSUM	CDIVIDE	CVISIBLE	MERGEPLLN	PTLNPLN
ANALYFIT	CEDITPT	CYLIN	MERGEPOLY	PTPTLN
ANIMEVAL	CENVOFF	CZEROS	MEVAL	PTREGISTER
ANTIPODAL	CEVAL	DIST2FF	MFROMMESH	PTS2PLLN
AOFFSET	CEXTREMES	DUALITY	MFROMMV	PTS2PLYS
ARC	CFNCRVTR	ELLIPSE3PT	MMERGE	PTSLNLN
ARC360	CIEXTREME	EVOLUTE	MOFFSET	QUADCRVS
BBOX	CINFLECT	EXTRUDE	MOMENT	QUADRIC
BLHERMITE	CINTERP	FFCMPCRV	MPOWER	RAYTRAPS
BLSHERMITE	CIRCLE	FFCOMPAT	MPROMOTE	RFLCTLN
BLOSSOM	CIRCPOLY	FFCTLPTS	MRAISE	RRINTER
BOOLONE	CLNTCRSR	FFEXTREME	MRCHCUBE	RULEDSRF
BOOLSUM	CLNTREAD	FFGTYPE	MREFINE	RULEDTV
BOUNDARY	CMESH	FFKNTVEC	MREGION	SACCESS
BOX	CMOEBIUS	FFMATCH	MREPARAM	SASPCTGRPH
BSCTCONCN2	CMORPH	FFMERGE	MREVERSE	SASYMPEVAL
BSCTCONCON	CMULTIRES	FFMESH	MSCIRC	SBEZIER
BSCTCONCYL	CNORMAL	FFMSIZE	MSCONE	SBISECTOR
BSCTCONLN	CNRMLCRV	FFORDER	MSSPHERE	SBSPLINE
BSCTCONPL	CNVXHULL	FFPOLES	MVCONTACT	SCRVTR
BSCTCONPT	COERCE	FFPTDIST	MVEXPLICIT	SCRVTREVAL
BSCTCONSPR	COMPOSE	FFPTTYPE	MVINTER	SDDMMAP
BSCTCYLCYL	CON2	FFSPLIT	MZERO	SDERIVE
BSCTCYLPL	CONE	FITPMODEL	NCCNTRPATH	SDIVIDE
BSCTCYLPT	CONICSEC	FIXPLGEOM	NCPCKTPATH	SEDITPT
BSCTCYLSPR	CONTOUR	FIXPLNRML	NIL	SELFINTER
BSCTPLNLN	CONVEX	GBOX	OFFSET	SETCOVER
BSCTPLNPT	COORD	GETATTR	ORTHOTOMC	SEVAL
BSCTSPRLN	COVERISO	GETLINE	PATTRIB	SFLECNODAL
BSCTSPRPL	COVERPT	GETNAME	PCIRCLE	SFOCAL
BSCTSPRPT	CPINCLUDE	GGINTER	PCRVTR	SFROMCRVS
BSCTSPRSPR	CPOWER	GPOLYGON	PDECIMATE	SGAUSS
BSCTTRSPT	CRAISE	GPOLYLINE	PDOMAIN	SILHOUETTE
BSCTTRSSPR	CRC2CRVTAN	HAUSDORFF	PIMPRTNC	SINTERP
BSP2BZR	CREDUCE	HERMITE	PLANE	SKEL2DINT
BZR2BSP	CREFINE	IMPLCTRANS	PLANECLIP	SMEAN
CALPHASECTOR	CREGION	INSTANCE	PLN3PTS	SMERGE
CANGLEMAP	CREPARAM	IRITSTATE	PMORPH	SMESH
CARCLEN	CROSSEC	ISGEOM	PNORMAL	SMOEBIUS
CAREA	CRV2TANS	ISOCLINE	POINT	SMOMENTS
CARRANGMNT	CRVKERNEL	KNOTCLEAN	POLARSIL	SMOOTHNRML
CBEZIER	CRVLNDST	KNOTREMOVE	POLY	SMORPH
CBIARCS	CRVPTDST	LINTERP	POLYHOLES	SNORMAL
CBISECTOR2D	CRVPTTAN	LOFFSET	PPINCLUDE	SNRMLSRF
CBISECTOR3D	CSPIRAL	MATDECOMP	PPINTER	SPARABOLC
CBSPLINE	CSURFACE	MAXEDGELEN	PPROPFTCH	SPHERE
CCINTER	CTANGENT	MBEZIER	PRINTER	SPLITLST
CCRVTR	CTRIMSRF	MBISECTOR	PRISA
CCRVTR1PT	CTLPT	MBSPLINE	PROCEDURE
CCRVTREVAL	CUBICCRVS	MDERIVE	PT3BARY

SRADCRVTR	SSINTER	SWUNGASUM	TEXTGEOM	TRMSRFS
SRAISE	SSINTR2	SYMBCPROD	TEXTWARP	TSBEZIER
SRAYCLIP	STANGENT	SYMBDIFF	TFROMSRFS	TSBSPLINE
SREFINE	STRIMSRF	SYMBDPROD	TINTERP	TSDERIVE
SREGION	STRIVAR	SYMBIPROD	TMORPH	TSEVAL
SREPARAM	SURFPREV	SYMBPROD	TNSCRCR	TSGREGORY
SREVERSE	SURFREV	SYMBSUM	TOFFSET	TSNORMAL
SRF2TANS	SURFREVAXS	TBEZIER	TORUS	TVLOAD
SRF3TANS	SURFREV2	TBSPLINE	TRAISE	TVZRJACOB
SRFFFORM	SURFREVAX2	TCRVTR	TREFINE	UVPOLY
SRFLNDST	SVISIBLE	TDERIVE	TREGION	ZCOLLIDE
SRFKERNEL	SVOLUME	TDIVIDE	TREPARAM
SRFPTDST	SWEEPSRF	TEDITPT	TRIANGL
SRINTER	SWPSCLSRF	TEVAL	TRIMSRF

Functions that create linear transformation matrices:

HOMOMAT	PROJMAT	ROTV2V	ROTZ	SCALE
MAP3PT2EQL	RFLCTMAT	ROTX	ROTZ2V	TRANS
MATPOSDIR	ROTVEC	ROTY	ROTZ2V2

Miscellaneous functions:

ADWIDTH	ERROR	INSERTPOLY	PAUSE	TIME
ATTRIB	EXEC	INTERACT	PRINTF	VARLIST
ATTRPROP	EXIT	IQUERY	PRINTFILE	VECTOR
AWIDTH	FNFREE	LIST	PROCEDURE	VIEW
CHDIR	FOR	LOAD	RESET	VIEWOBJ
CLNTCLOSE	FREE	LOGFILE	RMATTR	VIEWSET
CLNTWRITE	FUNCTION	MSLEEP	SAVE	WHILE
COLOR	HELP	NREF	SETNAME
COMMENT	IF	NRMLCONE	SNOC
CPATTR	INCLUDE	NTH	SYSTEM

Variables that are predefined in the system:

AXES	POLY_APPROX_OPT	POLY_MERGE_COPLANAR
DRAWCTLPT	POLY_APPROX_UV	PRSP_MAT
FLAT4PLY	POLY_APPROX_TOL	RESOLUTION
MACHINE	POLY_APPROX_TRI	VIEW_MAT

Constants that are predefined in the system:

AMIGA	E3	MACOSX	P8	SURFACE_TYPE
APOLLO	E4	MAGENTA	P9	SUN
BEZIER_TYPE	E5	MATRIX_TYPE	PARAM_CENTRIP	TRIMSRF_TYPE
BLACK	E6	MSDOS	PARAM_CHORD	TRISRF_TYPE
BLUE	E7	MULTIVAR_TYPE	PARAM_NIELFOL	TRIVAR_TYPE
BSPLINE_TYPE	E8	NUMERIC_TYPE	PARAM_UNIFORM	TRUE
CLIENTS_ALL	E9	OFF	PI	UNDEF_TYPE
COL	FALSE	ON	PLANE_TYPE	UNIX
CTLPT_TYPE	GREEN	P1	POINT_TYPE	VECTOR_TYPE
CURVE_TYPE	HP	P2	POLY_TYPE	WINDOWS
CYAN	IBMOS2	P3	POWER_TYPE	WHITE
CYGWIN	KV_FLOAT	P4	RED	YELLOW
DEPTH	KV_OPEN	P5	ROW
E1	LINUX	P6	SGI
E2	LIST_TYPE	P7	STRING_TYPE

Language description

The front end of the IRIT Solid Modeler is an infix parser that mimics some C language behavior. The infix operators that are supported are plus (+), minus (-), multiply (*), divide (/), and power (^), for numeric operators, with the same precedence as in C.

However, unlike the C language, these operators are overloaded, or different action is taken, based upon the different operands. This means that one can write '1 + 2', in which the plus sign denotes a numeric addition, or one can write 'PolyObj1 + PolyObj2', in which case the plus sign denotes the Boolean operation of a union between two geometric objects. The exact way each operator is overloaded is defined below.

In this environment, reals, integers, and even Booleans, are all represented as real types. Data are automatically promoted as necessary. For example, the constants TRUE and FALSE are defined as 1.0 and 0.0, respectively.

Each expression is terminated by a semicolon. An expression can be as simple as 'a;' which prints the value of variable a, or as complex as:

for ( t = 1.1, 0.1, 1.9, cb1 = csurface( sb, COL, t ): color( cb1, green ): snoc( cb1, cb_all ) );

While an expression is terminated with a semicolon, a colon is used to terminate mini-expressions within an expression.

Once a complete expression is read in (i.e., a semicolon is detected) and parsed correctly (i.e. no syntax errors are found), it is executed. Before each operator or a function is executed, parameter type matching tests are made to make sure the operator can be applied to these operand(s), or that the function gets the correct set of arguments.

The parser is totally case insensitive, so Obj, obj, and OBJ will refer to the same object, while MergePoly, MERGEPOLY, and mergePoly will refer to the same function.

Objects (Variables, if you prefer) need not be declared. Simply use them when you need them. Object names may be any alpha-numeric (and underscore) string of at most 30 characters. When assigned to an old object, the old object will be automatically deleted and if necessary, its type will be modified on the fly.

Example:

V = sin( 45 * pi / 180.0 ); V = V * vector( 1, 2, 3 ); V = V * rotx( 90 ); V = V * V;

will assign to V a NumericType equal to the sine of 45 degrees, the VectorType ( 1, 2, 3 ) scaled by the sine of 45, rotate that vector around the X axis by 90 degrees, and finally a NumericType which is the dot (inner) product of V with itself.

The parser will read from stdin, unless a file is specified on the command line or an INCLUDE command is executed. In both cases, when the end of file is encountered, the parser will again wait for input from stdin. In order to execute a file and quit at the end of the file, put an EXIT command as the last command in the file.

Operator overloading

Overloading +

The + operator is overloaded above the following domains:

NumericType + NumericType -> NumericType PointType + PolygonType -> PolygonType (Point polyline profiling) VectorType + VectorType -> VectorType (Vector addition) MatrixType + MatrixType -> MatrixType (Matrix addition) PolygonType + PolygonType -> PolygonType (Boolean UNION operation) CurveType + CurveType -> CurveType (Curve curve profiling) CurveType + CtlPtType -> CurveType (Curve control point profiling) CtlPtType + CtlPtType -> CurveType (Control points profiling) ListType + ListType -> ListType (Append lists operator) StringType + StringType -> StringType (String concat) StringType + RealType -> StringType (String concat, real as int string)

Note: Boolean UNION of two disjoint objects (no common volume) will result in the two objects being combined. It is the USER's responsibility to make sure that the non intersecting objects are also disjoint - this system only tests for no intersection. Boolean UNION of two polyline objects will merge the list of polylines.

Overloading -

The - operator is overloaded above the following domains:

As a binary operator:

NumericType - NumericType -> NumericType VectorType - VectorType -> VectorType (Vectoric difference) MatrixType - MatrixType -> MatrixType (Matrix difference) PolygonType - PolygonType -> PolygonType (Boolean SUBTRACT operation)

As a unary operator:

- NumericType -> NumericType - PointType -> PointType (Scale vector by -1) - VectorType -> VectorType (Scale vector by -1) - CtlPtType -> CtlPtType (Scale vector by -1) - PlaneType -> PlaneType (Scale vector by -1) - StringType -> StringType (Reverse the order of string's characters) - MatrixType -> MatrixType (Scale matrix by -1) - PolygonType -> PolygonType (Boolean NEGATION operation) - CurveType -> CurveType (Curve parameterization is reversed) - SurfaceType -> SurfaceType (Surface parameterization is reversed) - TrimSrfType -> TrimSrfType (Trim surface parameterization is reversed)

Note: Boolean SUBTRACT of two disjoint objects (no common volume) will result in an empty object. For both a curve and a surface parameterization, reverse operation (binary minus) causes the object normal to be flipped as a side effect.

Overloading *

The * operator is overloaded above the following domains:

NumericType * NumericType -> NumericType VectorType * NumericType -> VectorType (Vector scaling) VectorType * CurveType -> CurveType (Inner product projection) VectorType * SurfaceType -> SurfaceType (Inner product projection) VectorType * VectorType -> NumericType (Inner product) PlaneType * MatrixType -> PlaneType (Plane transformation) MatrixType * NumericType -> MatrixType (Matrix Scaling) MatrixType * PointType -> PointType (Point transformation) MatrixType * CtlPtType -> CtlPtType (Ctl Point transformation) MatrixType * VectorType -> VectorType (Vector transformation) MatrixType * MatrixType -> MatrixType (Matrix multiplication) MatrixType * GeometricType -> GeometricType (Object transformation) MatrixType * ListType -> ListType (Object hierarchy transform.) PolygonType * PolygonType -> PolygonType (Boolean INTERSECTION operation) InstanceType * MatrixType -> InstanceType (Transform of Instance's matrix)

Note: Boolean INTERSECTION of two disjoint objects (no common volume) will result in an empty object. Object hierarchy transform transforms any transformable object (GeometricType) found in the list recursively. Boolean INTERSECTION of two planar (XY plane) polyline objects will compute the intersection points of the two lists of polylines. Be aware that a plane multiplied by a matrix does not always do what you might expected.

Overloading /

The / operator is overloaded above the following domains:

NumericType / NumericType -> NumericType PointType / PointType -> PolyType (Polyline between two pts) PointType / PolygonType -> PolygonType (Point polyline profiling) PolygonType / PolygonType -> PolygonType (Boolean CUT operation)

Note: Boolean CUT of two disjoint objects (no common volume) will result with an empty object.

Overloading ^{ }

The ^ operator is overloaded above the following domains:

NumericType ^ NumericType -> NumericType VectorType ^ VectorType -> VectorType (Cross product) MatrixType ^ NumericType -> MatrixType (Matrix to the (int) power) PolygonType ^ PolygonType -> PolygonType (Boolean MERGE operation) StringType ^ StringType -> StringType (String concat) StringType ^ RealType -> StringType (String concat, real as real string)

Note: Boolean MERGE simply merges the two sets of polygons without any intersection tests. Matrix powers must be positive integers or -1 or -2, in which case the matrix inverse (if it exists) or transpose is computed.

Overloading Equal (Assignments)

Assignments are allowed as side effects, in any place in an expression. If "Expr" is an expression, then "var = Expr" is the exact same expression with the side effect of setting Var to that value. There is no guarantee of the order of evaluation, so using Vars that are set within the same expression is a bad practice. Use parentheses to force the order of evaluation, i.e., "( var = Expr )".

Comparison operators ==, !=, <, >, <=, >=

The conditional comparison operators can be applied to the following domains (o for a comparison operator):

NumericType o NumericType -> NumericType StringType o StringType -> NumericType PointType o PointType -> NumericType VectorType o VectorType -> NumericType PlaneType o PlaneType -> NumericType CtlPtType o CtlPtType -> NumericType MatrixType o MatrixType -> NumericType CurveType o CurveType -> NumericType SurfaceType o SurfaceType -> NumericType TrivarType o TrivarType -> NumericType TriSrfType o TriSrfType -> NumericType MultivarType o MultivarType -> NumericType

The returned NumericType is non-zero if the condition holds, or zero if not. The comparison operators other than == and != can be used on NumericTypes and StringType only.

Logical operators &&, ||, !

Complex logical expressions can be defined using the logical and (&&), logical or (||) and logical not (!). These operators can be applied to NumericTypes that are considered Boolean results. That is, true for a non-zero value, and false otherwise. The returned NumericType is true if both operands are true for the and operator, at least one is true for the or operator, and the operand is false for the not operator. In all other cases, a false is returned. To make sure logical expressions are readable, the and and or operators are defined to have the same priority. Use parentheses to disambiguate a logical expression and to make it more readable.

Geometric Boolean Operations

The IRIT Solid Modeling System supports Boolean operations between polyhedra objects. Freeform objects will be automaticaly converted to a polygonal representation when used in Boolean operations. The +, *, and - are overloaded to denote Boolean union, intersection and subtraction when operating on geometric entities. - can also be used as an unary operator to reverse the object orientation inside out.

IRIT supports Boolean operations on polyhedra models. A polyhedra based model is simply a collection of polygons. While a polyhedra is simply a set of polygons, this set must conform to certain conditions:

Every polygon has known adjacent polygons, for all its edges.

The model must be a 2-manifold. That is every edge is shared by exactly two polygons.

intersection curves must be closed and the objects participating in the Boleans might be open in unintersecting regions.

Every polygon has a normal that points into the model. That normal is inside/outside consistent with its adjacent polygons. In other words, for every polygon, one can locally determine the inside or the outside of the model. Moreover, every polygon has neighbors for all its edges, forming a closed object that consistently delineates inside from outside, globally.

If your input geometry does not adhere to the above constrains, the Boolean operation is likely to fail. You can enable a special intersection-curves mode that only compute the intersection curves between the two input objects and does not form the output object. This special model is insensitive to many of the above constraints so you could use this model to examine the intersection curves and make sure there are indeed forming closed loops. You can enable this intersection-curves mode via 'iritstate("intercrv", true);'. See also IRITSTATE command.

The Boolean operations are set operations conducted between two such models, M_1 and M_2, that delineate inside from outside. Boolean Union, Boolean Intersection and Boolean Subtraction are the three common operations that resemble the exact semantic that is expected, when treating M_1 and M_2 as three-dimensional point sets.

Certain attributes are propegated between input and output geometry, when processed through the Boolean operations module. If the vertices of the input geometry have normals, uv parametric coordinates ("uvvals" attribute), or rgb colors ("rgb" attribute), they will be propertly propagated and interpolated through the Booleans. Similarly, an integer "ID" attribute that is placed on an input object will propagate into its polygons and all polygons in the output that are part of the input objects will be carrying this "ID" attribute.

The Boolean operations can be formulated into a binary tree structure also known as a Constructive Solid Geometry (CSG) tree.

FIGURE: A simple example of a polyhedra model, computed as a sequence of several Boolean operation, presented as a CSG tree.
Example:

resolution = 20; B = box(vector(-1, -1, -0.25), 2, 1.2, 0.5); C = con2(vector(0, 0, -1.5), vector(0, 0, 3), 0.7, 0.3); D = convex(B - C); E = convex(C - B); F = convex(B + C); G = convex(B * C); tr = rotx( -90 ) * roty( 40 ) * rotx( -30 ); All = list( D * tr * trans( vector( 0.6, 0.5, 0.0 ) ), E * tr * trans( vector( 3.0, 0.0, 0.0 ) ), F * tr * trans( vector( -2.0, 0.0, 0.0 ) ), G * tr * trans( vector( 0.7, -1.0, 0.0 ) ) ) * scale( vector( 0.25, 0.25, 0.25 ) ) * trans( vector( -0.1, -0.3, 0.0 ) ); view_mat = rotx( 0 ); view( list( view_mat, All ), on ); save( "booleans", list( view_mat, All ) );

This is a complete example of how to compute the union, intersection and both differences of a box and a truncated cone.

FIGURE: Geometric Boolean operations between a box and a truncated cone. Shown are union (left), intersection (bottom center), box minus the cone (top center), and cone minus the box (right).

Special cases can be very difficult to handle when considering Boolean operations. Consider an axes parallel bounding cube. Consider a second cube rotated alpha degrees from the first cube. At large angles, the Boolean operations are fairly simple to compute. Nevertheless, as alpha approaches zero, the almost coplanar planes of the two intersecting cubes make it very difficult to robustly and consistently compute their intersection.

FIGURE: Examples of robustness of Boolean Intersection operation. As the rotation anlge approaches zero, the coplanarity of the intersecting models puts very difficult constraints on the robustness of the result. In this specific example, using IRIT, the operation fails at angles of 10e-6 and below.

There are several flags to control the Boolean operations. See IRITSTATE command for the "InterCrv", "InterUV", "Coplanar", and "PolySort" states.

Priority of operators

The following table lists the priority of the different operators.

Lowest	Operator	Name of operator
priority	,	comma
	:	colon
	&&, \|\|	logical and, logical or
	=,==,!=,<=,>=,<,>	assignment, equal, not equal, less
		equal, greater equal, less, greater
	+, -	plus, minus
	*, /	multiply, divide
Highest	^	power
priority	-, !	unary minus, logical not

Grammar

The grammar of the IRIT parser follows guidelines similar to those of the C language for simple expressions. However, complex statements differ. See the IF, FOR, FUNCTION, and PROCEDURE below for the usage of these clauses.

Function Description

NumericType returning functions

ABS

NumericType ABS( NumericType Operand )

returns the absolute value of the given Operand.

ACOS

NumericType ACOS( NumericType Operand )

returns the arc cosine value (in radians) of the given Operand.

AREA

NumericType AREA( PolygonType Object )

returns the area of the given Object (in object units). The area of the polygonal object, not the area of the primitive it might approximate,is returned.

This means that the area of a polygonal approximation of a sphere will be returned, not the exact area of the sphere.

ASIN

NumericType ASIN( NumericType Operand )

returns the arc sine value (in radians) of the given Operand.

ATAN

NumericType ATAN( NumericType Operand )

returns the arc tangent value (in radians) of the given Operand.

ATAN2

NumericType ATAN2( NumericType Operand1, NumericType Operand2 )

returns the arc tangent value (in radians) of the given ratio: Operand1 / Operand2, over the whole circle.

COS

NumericType COS( NumericType Operand )

returns the cosine value of the given Operand (in radians).

CLNTEXEC

NumericType CLNTEXEC( StringType ClientName )

Initiate communication channels to a client named ClientName. ClientName is executed by this function as a sub process. Two communication channels are opened between the IRIT server and the new client, for read and write. See also CLNTCRSR, CLNTREAD, CLNTWRITE, and CLNTCLOSE. If ClientName is an empty string, the user is provided with the new communication port to be used and the server blocks for the user to manually execute the client after setting the proper IRIT_SERVER_HOST/PORT environment variables.

Example:

h1 = CLNTEXEC( "" ); h2 = CLNTEXEC( "nuldrvs -s-" );

executes two clients, one named nuldrvs while the other one is prompted for by the user. As a result of the second invokation of CLNTEXEC, the user will be prompted with a message similar to:

Irit: Startup your program - I am waiting... setenv IRIT_SERVER_PORT 2182

and he/she will need to set the proper environment variable and execute their client manually.

CPOLY

NumericType CPOLY( PolygonType Object )

returns the number of polygons in the given polygonal Object.

DSTPTLN

NumericType DSTPTLN( PointType Pt, PointType LineOrig, VectorType LineRay )

returns the distance between a given point Pt and line LineOrig, LineRay. See also PTPTLN.

DSTPTPLN

NumericType DSTPTPLN( PointType Pt, PlaneType Plane )

returns the distance between a given point Pt and plane Plane.

DSTLNLN

NumericType DSTLNLN( PointType Line1Orig, VectorType Line1Ray, PointType Line2Orig, VectorType Line2Ray )

returns the distance between two lines defined by point LineiOrig and ray LineiRay. See also PTSLNLN.

EXP

NumericType EXP( NumericType Operand )

returns the natural exponential value of the given Operand.

FLOOR

NumericType FLOOR( NumericType Operand )

returns the largest integer not greater than the Operand.

FMOD

NumericType FMOD( NumericType Operand, NumericType Mod )

returns the floating point remainder of the division of the Operand by Mod.

LN

NumericType LN( NumericType Operand )

returns the natural logarithm value of the given Operand.

LOG

NumericType LOG( NumericType Operand )

returns the base 10 logarithm value of the given Operand.

MESHSIZE

NumericType MESHSIZE( FreeformType Freeform, ConstantType Direction )

returns the size of the Freeform's mesh in a Direction, which will be COL, ROW or DEPTH. For the case of a multivariate Freeform, the Direction is an integer value starting from 0. See also FFMSIZE. Examples:

Len = MESHSIZE( Crv, COL ); RSize = MESHSIZE( Sphere, ROW ); CSize = MESHSIZE( Sphere, COL ); TVSize = MESHSIZE( TV, COL ) * MESHSIZE( TV, ROW ) * MESHSIZE( TV, DEPTH ); MVSize1 = MESHSIZE( MV, 1 );

POWER

NumericType POWER( NumericType Operand, NumericType Exp )

returns the Operand to the power of Exp.

RANDOM

NumericType RANDOM( NumericType Min, NumericType Max )

returns a randomized value between Min and Max. See also "RandomInit", in the IRITSTATE function.

SIN

NumericType SIN( NumericType Operand )

returns the sine value of the given Operand (in radians).

SIZEOF

NumericType SIZEOF( PointTypr Pt | VectorType Vec | PlaneType Pln | CtlPtType CtlPt | ListType List | PolygonType Poly | CurveType Crv | StringType Str )

returns the size of a point, vector, plane, or control point (negative size if rational) or the length of a list if List, the number of polygons if Poly, the length of the control polygon if Crv, or the number of characters in string if Str. If, however, only one polygon is in Poly, it returns the number of vertices in that polygon.

Example:

len = SIZEOF( list( 1, 2, 3 ) ); numPolys = SIZEOF( axes ); numCtlpt = SIZEOF( circle( vector( 0, 0, 0 ), 1 ) );

will assign the value of 3 to the variable len, set numPolys to the number of polylines in the axes object, and set numCtlPt to 9, the number of control points in a circle.

SQRT

NumericType SQRT( NumericType Operand )

returns the square root value of the given Operand.

TAN

NumericType TAN( NumericType Operand )

returns the tangent value of the given Operand (in radians).

THISOBJ

NumericType THISOBJ( StringType Object )

returns the object type of the given name of an Object. This can be one of the constants,

UNDEF_TYPE	PLANE_TYPE	CTLPT_TYPE	MODEL_TYPE
POLY_TYPE	MATRIX_TYPE	LIST_TYPE	MULTIVAR_TYPE
NUMERIC_TYPE	CURVE_TYPE	TRIVAR_TYPE
POINT_TYPE	SURFACE_TYPE	TRISRF_TYPE
VECTOR_TYPE	STRING_TYPE	TRIMSRF_TYPE

This is also a way to ask if an object by a given name exists (if the returned type is UNDEF_TYPE or not).

VOLUME

NumericType VOLUME( PolygonType Object )

returns the volume of the given Object (in object units). It returns the volume of the polygonal object, not the volume of the object it might approximate.

This routine decomposes all non-convex polygons to convex ones, as a side effect (see CONVEX).

GeometricType returning functions

ADAPISO

CurveType ADAPISO( SurfaceType Srf, NumericType Dir, NumericType Eps, NumericType FullIso, NumericType SinglePath )

constructs a coverage to Srf using isocurve in the Dir direction, so that for any point p on surface Srf, there exists a point on one of the isocurves that is close to p within Eps. If FullIso, the extracted isocurves span the entire surface domain; otherwise they may span only a subset of the domain. If SinglePath, an approximation to a single path (Hamiltonian path) that visits all isocurves is constructed (not supported). See also COVERPT, COVERISO.

srf = sbezier( list( list( ctlpt( E3, -0.5, -1.0, 0.0 ), ctlpt( E3, 0.4, 0.0, 0.1 ), ctlpt( E3, -0.5, 1.0, 0.0 ) ), list( ctlpt( E3, 0.0, -0.7, 0.1 ), ctlpt( E3, 0.0, 0.0, 0.0 ), ctlpt( E3, 0.0, 0.7, -0.2 ) ), list( ctlpt( E3, 0.5, -1.0, 0.1 ), ctlpt( E3, -0.4, 0.0, 0.0 ), ctlpt( E3, 0.5, 1.0, -0.2 ) ) ) ); aiso = ADAPISO( srf, COL, 0.1, FALSE, FALSE );

constructs an adaptive isocurve approximation with tolerance of 0.1 to surface srf in direction COL. Isocurves are allowed to span a subset of the surface domain. No single path is needed.

The SinglePath option is currently not supported.

ALGSUM

SurfaceType ALGSUM( CurveType Crv1, CurveType Crv2 )

Given two curves, compute a surface that is their algebraic sum:

                       S(u, v) = C1(u) + C2(v)

Example:

c1 = circle( vector( 0.0, 0.0, 0.0 ), 0.7 ); c2 = ctlpt( E3, -0.2, -0.5, -1.5 ) + ctlpt( E3, 0.2, 0.5, 1.5 ); s1 = algsum( c1, c2 ); c2 = cbspline( 3, list( ctlpt( E3, 0.0, 0.0, 0.0 ), ctlpt( E3, 0.0, 0.0, 0.7 ), ctlpt( E3, 0.0, 1.5, 1.0 ), ctlpt( E3, 0.0, 0.0, 1.3 ), ctlpt( E3, 0.0, 0.0, 2.0 ) ), list( KV_OPEN ) ); s2 = algsum( c1, c2 );

creates two algebraic sum surfaces, one in the shape of a cylinder as a sum of a line and a circle, and one circular sweep like.

FIGURE: An algebraic sum of a circle and a line creating a cylinder (left) and a general sweep like surface (right), both using ALGSUM.

ANALYFIT

ListType ANALYFIT( ListType UVPts, ListType EucPts, NumericType FirstAtOrigin, NumericType Degree )

computes a surface fit to the given paraametrized points data. The fitted surface will be of bi-degree Degree, fitting points EucPts at parameters UVPts. Needless to say EucPts and UVPts should be lists of points of similar length. If FirstAtOrigin is TRUE, all points are translated so the first point in EucPts is at the origin. Only the first coordinates of UVPts are used.

Example:

Fitting = nil(); Eps = 1e-2; PtPln = nil(): for (i = 1, 1, 100, snoc( point( random( -1, 1 ), random( -1, 1 ), random( -Eps, Eps ) ), PtPln ) ); BilinCoefs = ANALYFIT( PtPln, PtPln, 0, 1 ) );

fits a bilinear to the given planar data with noise. See also the COERCE function from POWER_TYPE to BEZIER_TYPE, and FITPMODEL.

ANIMEVAL

AnyType ANIMEVAL( NumericType Time, AnyType Object, NumericType EvalMats )

evaluates the animation curves in Object at time Time. The transformations for time Time are saved at the respective sub objects of Object as "animation_mat" matrices, if EvalMats is TRUE. If, however, EvalMats is FALSE, the evaluated/mapped geometry is returned directly.

For example,

mov_x = cbezier( list( ctlpt( E1, 0.0 ), ctlpt( E1, 1.0 ) ) ); attrib( axes, "animation", list( mov_x ) ); axes2 = ANIMEVAL( 0.5, axes, true );

and axes2 will have a matrix in attribute "animation_mat" of translation in x of 1/2.

ANTIPODAL

ListType ANTIPODAL( CurveType Crv, NumericType SubdivTol, NumericType NumerTol ) or ListType ANTIPODAL( SurfaceType Srf, NumericType SubdivTol, NumericType NumerTol )

computes distinct antipodal pairs on curve Crv or on surface Srf. An antipodal pair defines two distinct locations on Crv or on Srf that a line through the two locations is orthogonal to the tangent space of the shape, at thouse locations. In other words, the normals to the freeform shape at those two locations are along the line connecting the locations. SubdivTol and NumerTol control the tolerance of the computation as in MZERO.

Examples:

A = ANTIPODAL( Srf, 1e-3, -1e-12 );

AOFFSET

CurveType AOFFSET( CurveType Crv, NumericType OffsetDistance, NumericType Epsilon, NumericType TrimLoops, NumericType BezInterp ) or CurveType AOFFSET( CurveType Crv, CurveType OffsetDistance, NumericType Epsilon, NumericType TrimLoops, NumericType BezInterp )

computes an offset of OffsetDistance with a globally bounded error (controlled by Epsilon). The smaller Epsilon is, the better the approximation to the offset. The bounded error is achieved by adaptive refinement of the Crv. If OffsetDistance is a (scalar) curve, the curve's first coordinate is used to prescribe a variable offset amount along the curve. Both Crv and OffsetDistance must share the same parametric domain. If TrimLoops is TRUE or on, the regions of the object that self-intersect as a result of the offset operation are trimmed away. If BezInterp is TRUE, each curve's segment is interpolated instead of approximated.

Example:

OffCrv1 = AOFFSET( Crv, 0.5, 0.01, FALSE, FALSE ); OffCrv2 = AOFFSET( Crv, 0.5, 0.01, TRUE, FALSE );

computes an adaptive offset to Crv with OffsetDistance of 0.5 and Epsilon of 0.01 and trims the self intersection loops in the second instance. See also OFFSET, TOFFSET, LOFFSET, and MOFFSET.

FIGURE: Adaptive offset approximation (thick) of a B-spline curve (thin). On the left, the self intersections in the offset computed in the right are eliminated. Both offsets were computed using AOFFSET.

ARC

CurveType ARC( VectorType StartPos, VectorType Center, VectorType EndPos )

constructs an arc between the two end points StartPos and EndPos, centered at Center. THe arc will always be less than 180 degrees, so the shortest circular path from StartPos to EndPos is selected. The case where StartPos, Center, and EndPos are collinear is illegal, since it attempts to define a 180 degrees arc. The arc is constructed as a single rational quadratic Bezier curve.

Example:

Arc1 = ARC( vector( 1.0, 0.0, 0.0 ), vector( 1.0, 1.0, 0.0 ), vector( 0.0, 1.0, 0.0 ) );

constructs a 90 degrees arc, tangent to both the X and Y axes at coordinate 1.

FIGURE: A 90 degree arc constructed using the ARC constructor (left) and a 280 degrees arc (right) constructed using the ARC360 constructor.
See also ARC360

ARC360

CurveType ARC360( VectorType Center, NumericType Radius, NumericType StartAngle, NumericType EndAngle )

constructs an arc between the two angles (degrees) StartAngle and EndAngle, centered at Center. The arc will always be less than 360 degrees. The arc is constructed as a rational quadratic B-spline curve.

Example:

Arc2 = ARC360( vector( 0.0, 0.0, 0.0 ), 1.0, 75, 355 );

constructs a 280 degrees arc. See also ARC.

BBOX

ListType BBOX( GeometricTreeType Geom )

Given a (tree of) geometry, Geom computes its bounding box and return it as a list of six numbers: XMin/Max, YMin/Max, ZMin/Max, in this order.

Example:

B1 = BBOX( axes );

BLHERMITE

SurfaceType BLHERMITE( CurveType Bndry1, CurveType Bndry2, CurveType Tan1, CurveType Tan2, CurveType Sctn, CurveType Nrml )

computes a Hermite blend surface that supports an arbitrary cross section. This constructs a surface between Bndry1 and Bndry2 so that the first derivative continuity constraints, as prescribed by Tan1 at Bndry1 and Tan2 at Bndry2, are preserved. In addition, the interior between Bndry1 and Bndry2 will follow the shape of planar cross section curve Sctn and will be oriented along the vector field prescribed by Nrml. Cross section Sctn is a planar curve that must start at (-1, 0) and end at (1, 0), and have zero speed at the ends (first control point equals the second and is the same at the end).

Example:

c1 = ctlpt( e3, 0, 0, 0 ) + ctlpt( e3, 0, 1, 0 ); c2 = ctlpt( e3, 1, 0, 0 ) + ctlpt( e3, 1, 1, 0 ); d1 = ctlpt( e3, 1, 0, 1 ) + ctlpt( e3, 1, 0, 0.1 ); d2 = ctlpt( e3, 1, 0, -0.1 ) + ctlpt( e3, 1, 0, -1 ); s1 = hermite( c1, c2, d1, d2 ); color( s1, red ); cSec = cbspline( 3, list( ctlpt( e2, -1, 0 ), ctlpt( e2, -1, 0 ), ctlpt( e2, -0.14, 0.26 ), ctlpt( e2, -0.65, 0.51 ), ctlpt( e2, 0, 0.76 ), ctlpt( e2, 0.65, 0.51 ), ctlpt( e2, 0.14, 0.26 ), ctlpt( e2, 1, 0 ), ctlpt( e2, 1, 0 ) ), list( kv_open ) ); n = ctlpt( e3, 0, 0, 1 ) + ctlpt( e3, 0, 0, 1 ); s2 = BLHERMITE( c1, c2, d1, d2, cSec2, n ); color( s2, yellow );

constructs a regular Hermite surfaces s1 and a blending Hermite that follows the cross section cSec. See also HERMITE and BLSHERMITE.

BLSHERMITE

SurfaceType BLSHERMITE( SurfaceType Srf, CurveType PCrv, CurveType Sctn, NumericType TanScale, AnyType Width, AnyType Height )

computes a Hermite blend surface on Srf along parametric curve of Srf, PCrv, the cross section Sctn, a tangent field scale control TanScale, and the width and height control of Width and Height. Width and Height can be either a numeric value of expected width and height or a scalar field curve prescribing the expected width and height along the constructed blend.

The constructed surface, which is C1 continuous to Srf, is positioned along PCrv, a curve in the parametric domain of Srf. The cross section Sctn is a planar curve that must start at (-1, 0) and end at (1, 0), and have zero speed at the ends (first control point equals the second and is the same at the end). TanScale controls how rapid the change in the tangent is, as we move away from the surface.

Example:

cSec = cbspline( 3, list( ctlpt( e2, -1, 0 ), ctlpt( e2, -1, 0 ), ctlpt( e2, -0.5, 0.2 ), ctlpt( e2, -0.7, 0.3 ), ctlpt( e2, 0, 0.5 ), ctlpt( e2, 0.7, 0.3 ), ctlpt( e2, 0.5, 0.2 ), ctlpt( e2, 1, 0 ), ctlpt( e2, 1, 0 ) ), list( kv_open ) ); s = -surfPRev( cregion( pcircle( vector( 0, 0, 0 ), 1 ), 0, 2 ) * rx( 90 ) ); s1 = BLSHERMITE( s, ctlpt( E2, 0, 1 ) + ctlpt( E2, 4, 1 ), cSec, 1, 0.2, 0.5 ); s2 = BLSHERMITE( s, ctlpt( E2, 0, 1.5 ) + ctlpt( E2, 4, 1.5 ), cSec, 0.1, 0.2, 0.5 ); s3 = BLSHERMITE( s, ctlpt( E2, 0, 0.3 ) + ctlpt( E2, 4, 0.3 ), cSec, 1.5, 0.2, 0.5 );

places three Hermite blend surfaces s1, s2, s3 using the cross section cSec on a unit sphere s. See also HERMITE and BLHERMITE.

FIGURE: Blending Hermite with a prescribed cross section (left) using BLHERMITE and blending Hermite with a prescribed cross section on a surface (right) using BLSHERMITE.

BLOSSOM

CtlPtType BLOSSOM( CurveType Crv, ListType BlossomVals ) or CtlPtType BLOSSOM( SurfaceType Srf, ListType BlossomVals )

computes the blossom of the given Crv or Srf and the given blossom values BlossomVals. For a Crv, BlossomVals is expected to hold a linear list of blossom values. For a Srf, BlossomVals is expected to hold two linear lists (for u and v) of blossom values.

Example:

c1 = cbezier( list( ctlpt( E2, 1.7, 0.0 ), ctlpt( E2, 0.7, 0.7 ), ctlpt( E2, 1.7, 0.3 ), ctlpt( E2, 1.5, 0.8 ), ctlpt( E2, 1.6, 1.0 ) ) ); BLOSSOM( c1, list( 0, 0, 0, 0 ) ) == coord( c1, 0 ) && BLOSSOM( c1, list( 0, 0, 0, 1 ) ) == coord( c1, 1 ) && BLOSSOM( c1, list( 0, 0, 1, 1 ) ) == coord( c1, 2 ) && BLOSSOM( c1, list( 0, 1, 1, 1 ) ) == coord( c1, 3 ) && BLOSSOM( c1, list( 1, 1, 1, 1 ) ) == coord( c1, 4 );

extracts the control points of an quadric Bezier curve via blossoming and compares this to the results obtained via a traditional extraction approach (via the COORD function).

BOOLONE

SurfaceType BOOLONE( CurveType Crv )

Given a closed curve, the curve is subdivided into four segments equally spaced in the parametric space that are fed into BOOLSUM. This is useful if a surface should "fill" the area enclosed by a closed curve.

Example:

Srf = BOOLONE( circle( vector( 0.0, 0.0, 0.0 ), 1.0 ) );

creates a disk surface containing the area enclosed by the unit circle.

FIGURE: A boolean sum of a circle creates a disk (left) using BOOLONE and a general Boolean sum of four curves (right) using BOOLSUM.

BOOLSUM

SurfaceType BOOLSUM( CurveType Crv1, CurveType Crv2, CurveType Crv3, CurveType Crv4 )

constructs a surface using the provided four curves as its four boundary curves. Curves do not have to have the same order or type, and will be promoted to their least common denominator. The end points of the four curves should match as follows:

Crv1 start point,	to Crv3 start point.
Crv1 end point,	to Crv4 start point.
Crv2 start point,	to Crv3 end point.
Crv2 end point,	to Crv4 end point.

where Crv1 and Crv2 are the two boundaries in one parametric direction, and Crv3 and Crv4 are the two boundaries in the other parametric direction.

Example:

Cbzr1 = cbezier( list( ctlpt( E3, 0.1, 0.1, 0.1 ), ctlpt( E3, 0.0, 0.5, 1.0 ), ctlpt( E3, 0.4, 1.0, 0.4 ) ) ); Cbzr2 = cbezier( list( ctlpt( E3, 1.0, 0.2, 0.2 ), ctlpt( E3, 1.0, 0.5, -1.0 ), ctlpt( E3, 1.0, 1.0, 0.3 ) ) ); Cbsp3 = cbspline( 4, list( ctlpt( E3, 0.1, 0.1, 0.1 ), ctlpt( E3, 0.25, 0.0, -1.0 ), ctlpt( E3, 0.5, 0.0, 2.0 ), ctlpt( E3, 0.75, 0.0, -1.0 ), ctlpt( E3, 1.0, 0.2, 0.2 ) ), list( KV_OPEN ) ); Cbsp4 = cbspline( 4, list( ctlpt( E3, 0.4, 1.0, 0.4 ), ctlpt( E3, 0.25, 1.0, 1.0 ), ctlpt( E3, 0.5, 1.0, -2.0 ), ctlpt( E3, 0.75, 1.0, 1.0 ), ctlpt( E3, 1.0, 1.0, 0.3 ) ), list( KV_OPEN ) ); Srf = BOOLSUM( Cbzr1, Cbzr2, Cbsp3, Cbsp4 );

BOUNDARY

AnyType BOUNDARY( AnyType Obj )

Given a geometric object Obj, let it be a surface, a trimed surface, or a polygonal model, returns the boundary of the shape. If Obj is a polygonal object originated with a surface and all vertices has "uvvals" attributes, by placing "SrfBoundary" attribute on Obj with the "UMin VMin UMax VMax" surface domain, the surface boundary is will be properly detected, even if the surface is closed.

Example:

CBndry1 = BOUNDARY( Srf ); poly_approx_uv = 1; Pl = gpolygon( Srf, 1 ); attrib( Pl, "SrfBoundary", "0 0 1 2" ); # Domain of Srf [0, 1] x [0, 2] CBndry2 = BOUNDARY( Pl );

returns in CBndry1, the four boundary curves of tensor product surface Srf and in CBndry2, the edges on the tesselation of Srf, Pl, on the boundary of Srf, even if Srf is closed.

BOX

PolygonType BOX( VectorType Point, NumericType Dx, NumericType Dy, NumericType Dz )

creates a BOX polygonal object, whose boundary is coplanar with the XY, XZ, and YZ planes. The BOX is defined by Point as base position, and Dx, Dy, Dz as BOX dimensions. Negative dimensions are allowed.

Example:

B = BOX( vector( 0, 0, 0 ), 1, 1, 1);

creates a unit cube from 0 to 1 in all axes.

BSCTCONCN2

SurfaceType BSCTCONCN2( PointType ConeApx1, VectorType ConeDir1, NumericType ConeAngle1, PointType ConeApx2, VectorType ConeDir2, NumericType ConeAngle2 )

computes the bisector surface of two cones in general position. The cones' apexes can be found in ConeApx1 and ConeApx2 with axes directions ConeDir1 and ConeDir2 and spanning angles of ConeAngle1 and ConeAngle2.

Example:

BisectSrf = BSCTCONCN2( Apx1, Dir1, Ang1, Apx2, Dir2, Ang2 );

See also BSCPCONCON, BSCTCONCYL, BSCTCYLCYL, BSCTCONLN, BSCTCONPL, BSCTCONPT, BSCTCONSPR, BSCTCYLPL, BSCTCYLPT, BSCTCYLSPR, BSCTPLNLN, BSCTPLNPT, BSCTSPRLN, BSCTSPRPL, BSCTSPRPT, BSCTSPRSPR, BSCTTRSPT, BSCTTRSSPR, CALPHASECTOR, CBISECTOR2D, CBISECTOR3D, SBISECTOR,

BSCTCONCON

SurfaceType | ListType BSCTCONCON( VectorType ConeDir1, NumericType ConeAngle1, VectorType ConeDir2, NumericType ConeAngle2, NumericType Size )

computes the bisector surface of two cones that share the same apex. The cones' directions are ConeDir1 and ConeDir2 and the spanning angles of ConeAngle1 and ConeAngle2. ConeDir1 and ConeDir2 must be in the northern hemisphere; i.e. their Z coefficient must be positive. Size controls the portion of the (infinite) bisector actually represented.

Example:

BisectSrf = BSCTCONCON( vector( 0, 0, 1 ), 50, vector( 0, 0, 1 ), 20, 1.0 );

computes the bisector of two concentric cones, which is also a cone. See also BSCTCONLN, BSCTCONPL, BSCTCONPT, BSCTCONSPR, BSCTCYLPL, BSCPCONCON, BSCTCONCN2, BSCTCONCYL, BSCTCYLPT, BSCTCYLSPR, BSCTPLNLN, BSCTPLNPT, BSCTSPRLN, BSCTSPRPL, BSCTSPRPT, BSCTSPRSPR, BSCTTRSPT, BSCTTRSSPR, CALPHASECTOR, CBISECTOR2D, CBISECTOR3D, SBISECTOR

BSCTCONCYL

SurfaceType BSCTCONCYL( PointType ConeApx1, VectorType ConeDir1, NumericType ConeAngle1, PointType CylPt2, VectorType CylDir2, NumericType CylRad2 )

computes the bisector surface of a cone and a cylinder in general position. The cones apex is in ConeApx1 with axes direction of ConeDir1 and spanning angles of ConeAngle1. The second cylinder starts at CylPt2, in direction CylDir2 and radius CylRad2.

Example:

BisectSrf = BSCTCONCYL( Apx1, Dir1, Ang1, Pt2, Dir2, Rad2 );

See also BSCPCONCON, BSCTCONCN2, BSCTCYLCYL, BSCTCONLN, BSCTCONPL, BSCTCONPT, BSCTCONSPR, BSCTCYLPL, BSCTCYLPT, BSCTCYLSPR, BSCTPLNLN, BSCTPLNPT, BSCTSPRLN, BSCTSPRPL, BSCTSPRPT, BSCTSPRSPR, BSCTTRSPT, BSCTTRSSPR, CALPHASECTOR, CBISECTOR2D, CBISECTOR3D, SBISECTOR

BSCTCONLN

SurfaceType | ListType BSCTCONLN( VectorType ConeDir, NumericType ConeAngle, VectorType LineDir, NumericType Size )

computes the bisector surface of a cone and a line through its apex. The cone's direction is ConeDir and its spanning angle is ConeAngle. ConeDir and LineDir must be in the northern hemisphere; i.e. their Z coefficient must be positive. Size controls the portion of the (infinite) bisector actually represented.

Example:

BisectSrf = ( vector( 0, 0, 1 ), 45, vector( 0, 0.1, 1 ), 1 );

computes the bisector surface of a cone along the Z axis with spanning angle of 45 degrees, and a line through its apex in direction ( 0, 0.1, 1 ).

See also BSCPCONCON, BSCTCONCN2, BSCTCONCYL, BSCTCONCON, BSCTCONPL, BSCTCONPT, BSCTCONSPR, BSCTCYLPL, BSCTCYLPT, BSCTCYLSPR, BSCTPLNLN, BSCTPLNPT, BSCTSPRLN, BSCTSPRPL, BSCTSPRPT, BSCTSPRSPR, BSCTTRSPT, BSCTTRSSPR, CALPHASECTOR, CBISECTOR2D, CBISECTOR3D, SBISECTOR,

BSCTCONPL

SurfaceType | ListType BSCTCONPL( PointType ConeApex, VectorType ConeDir, NumericType ConeAngle, NumericType Size )

computes the bisector surface of a general cone and the XY plane (Z = 0 plane). The cone's apex is at ConeApex, the cone's direction is ConeDir and its spanning angle is ConeAngle. Dir must be in the northern hemisphere; i.e. their Z coefficient must be positive. Size controls the portion of the (infinite) bisector actually represented.

Example:

BisectSrf = BSCTCONPL( point( 0, 0, -0.3 ), vector( 1, 1, 1 ), 20, 1 );

computes the bisector surface of a cone with its apex at (0, 0, -0.3) along the axis (1, 1, 1) with spanning angle of 20 degrees, and the plane Z = 0.

See also BSCPCONCON, BSCTCONCN2, BSCTCONCYL, BSCTCONCON, BSCTCONLN, BSCTCONPT, BSCTCONSPR, BSCTCYLPL, BSCTCYLPT, BSCTCYLSPR, BSCTPLNLN, BSCTPLNPT, BSCTSPRLN, BSCTSPRPL, BSCTSPRPT, BSCTSPRSPR, BSCTTRSPT, BSCTTRSSPR, CALPHASECTOR, CBISECTOR2D, CBISECTOR3D, SBISECTOR.

BSCTCONPT

SurfaceType | ListType BSCTCONPT( PointType ConeApex, VectorType ConeDir, NumericType ConeAngle, PointType Pt, NumericType Size )

computes the bisector surface of a cone in a general position and a point, Pt. The cone's apex is at ConeApex, the cone's direction is ConeDir and its spanning angle is ConeAngle. Size controls the portion of the (infinite) bisector actually represented.

Example:

Bisect = BSCTCONPT( point( 0, 0, 0 ), vector( 0, 0, 1 ), 22, point( 0, 0.2, 0.7 ), 1 );

See also BSCPCONCON, BSCTCONCN2, BSCTCONCYL, BSCTCONCON, BSCTCONLN, BSCTCONPL, BSCTCONSPR, BSCTCYLPL, BSCTCYLPT, BSCTCYLSPR, BSCTPLNLN, BSCTPLNPT, BSCTSPRLN, BSCTSPRPL, BSCTSPRPT, BSCTSPRSPR, BSCTTRSPT, BSCTTRSSPR, CALPHASECTOR, CBISECTOR2D, CBISECTOR3D, SBISECTOR.

BSCTCONSPR

SurfaceType | ListType BSCTCONSPR( PointType ConeApex, VectorType ConeDir, NumericType ConeAngle, PointType SptCntr, NumericType SprRadius, NumericType Size )

computes the bisector surface of a cone and a sphere. The cone's apex is at ConeApex, the cone's direction is ConeDir and its spanning angle is ConeAngle. The sphere is centered at SptCntr and has a radius of SprRadius. Size controls the portion of the (infinite) bisector actually represented.

Example:

BisectSrf = BSCTCONSPR( point( 0, 0, 0 ), vector( 0, 0, 1 ), 45, point( 0, 0, 1 ), 0.5, 2.0 );

computes the bisector between a cone along the Z axis with a 45 degree spanning angle and a sphere at (0, 0, 1) of radius 0.5.

See also BSCPCONCON, BSCTCONCN2, BSCTCONCYL, BSCTCONCON, BSCTCONLN, BSCTCONPL, BSCTCONPT, BSCTCYLPL, BSCTCYLPT, BSCTCYLSPR, BSCTPLNLN, BSCTPLNPT, BSCTSPRLN, BSCTSPRPL, BSCTSPRPT, BSCTSPRSPR, BSCTTRSPT, BSCTTRSSPR, CALPHASECTOR, CBISECTOR2D, CBISECTOR3D, SBISECTOR.

BSCTCYLCYL

SurfaceType BSCTCYLCYL( PointType CylPt1, VectorType CylDir1, NumericType CylRad1, PointType CylPt2, VectorType CylDir2, NumericType CylRad2 )

computes the bisector surface of two cylinders in a general position. The cylinders start at CylPt1 and CylPt2 and follow the directions CylDir1 and CylDir2. They have radii of CylRad1 and CylRad2.

Example:

BisectSrf = BSCTCYLCYL( Pt1, Dir1, Rad1, Pt2, Dir2, Rad2 );

See also BSCPCONCON, BSCTCONCN2, BSCTCONCYL, BSCTCONLN, BSCTCONPL, BSCTCONPT, BSCTCONSPR, BSCTCYLPL, BSCTCYLPT, BSCTCYLSPR, BSCTPLNLN, BSCTPLNPT, BSCTSPRLN, BSCTSPRPL, BSCTSPRPT, BSCTSPRSPR, BSCTTRSPT, BSCTTRSSPR, CALPHASECTOR, CBISECTOR2D, CBISECTOR3D, SBISECTOR.

BSCTCYLPL

SurfaceType | ListType BSCTCYLPL( PointType CylPos, VectorType CylDir, NumericType CylRadius, Size )

computes the bisector surface of a a cylinder and the XY plane (plane Z = 0). The cylinder is located at CylPos, in the direction of CylDir which also sets the length of the cylinder. The radius of the cylinder is CylRadius. Size controls the portion of the (infinite) bisector actually represented.

Example:

Pt = point( 0.1, 0, 0.2 ); BisectSrf = BSCTCYLPL( point( 0, 0, 0.5 ), vector( 0, 0, 1 ), 0.2, 1 );

computed the bisector surface between a cylinder of radius 0.2 along the Z axis and the XY plane.

See also BSCPCONCON, BSCTCONCN2, BSCTCONCYL, BSCTCONCON, BSCTCONLN, BSCTCONPL, BSCTCONPT, BSCTCONSPR, BSCTCYLPT, BSCTCYLSPR, BSCTPLNLN, BSCTPLNPT, BSCTSPRLN, BSCTSPRPL, BSCTSPRPT, BSCTSPRSPR, BSCTTRSPT, BSCTTRSSPR, CALPHASECTOR, CBISECTOR2D, CBISECTOR3D, SBISECTOR.

BSCTCYLPT

SurfaceType | ListType BSCTCYLPT( PointType CylPos, VectorType CylDir, NumericType CylRadius, PointType Pt, NumericType Size )

computes the bisector surface of a a cylinder and a point, Pt. The cylinder is located at CylPos, in the direction of CylDir which also sets the length of the cylinder. The radius of the cylinder is CylRadius. Size controls the portion of the (infinite) bisector actually represented.

Example:

Pt = point( 0.1, 0, 0.2 ); BisectSrf = BSCTCYLPT( point( 0, 0, 0.5 ), vector( 0, 0, 1 ), 0.2, Pt, 1 );

computes the bisector surface between a cylinder of radius 0.2 along the Z axis and a point at (0.1, 0, 0.2).

See also BSCPCONCON, BSCTCONCN2, BSCTCONCYL, BSCTCONCON, BSCTCONLN, BSCTCONPL, BSCTCONPT, BSCTCONSPR, BSCTCYLPL, BSCTCYLSPR, BSCTPLNLN, BSCTPLNPT, BSCTSPRLN, BSCTSPRPL, BSCTSPRPT, BSCTSPRSPR, BSCTTRSPT, BSCTTRSSPR, CALPHASECTOR, CBISECTOR2D, CBISECTOR3D, SBISECTOR

BSCTCYLSPR

SurfaceType | ListType BSCTCYLSPR( PointType CylPos, VectorType CylDir, NumericType CylRadius, PointType SprCntr, NumericType SprRadius, NumericType Size )

computes the bisector surface of a cylinder and a sphere. The cylinder is located at CylPos, in the direction of CylDir which also sets the length of the cylinder. The radius of the cylinder is CylRadius. The sphere is centered at SptCntr and has a radius of SprRadius. Size controls the portion of the (infinite) bisector actually represented.

Example:

BisectSrf = BSCTCYLSPR( point( 0, 0, 1.5 ), vector( 0, 0, 3 ), 0.2, point( 0, 0, 0 ), 0.7, 3 );

computed the bisector surface between a cylinder of radius 0.2 along the Z axis and a sphere at the origin with radius 0.7.

See also BSCPCONCON, BSCTCONCN2, BSCTCONCYL, BSCTCONCON, BSCTCONLN, BSCTCONPL, BSCTCONPT, BSCTCONSPR, BSCTCYLPL, BSCTCYLPT, BSCTPLNLN, BSCTPLNPT, BSCTSPRLN, BSCTSPRPL, BSCTSPRPT, BSCTSPRSPR, BSCTTRSPT, BSCTTRSSPR, CALPHASECTOR, CBISECTOR2D, CBISECTOR3D, SBISECTOR.

BSCTPLNLN

SurfaceType | ListType BSCTPLNLN( VectorType LineDir, NumericType Size )

computes the bisector surface of the XY plane (plane Z = 0) and a line in direction LineDir. The plane and the line are assumed to intersect at the origin. Size controls the portion of the (infinite) bisector actually represented.

Example:

BisectSrf = BSCTPLNLN( vector( 0, 0, 1 ), 1 );

computes the bisector of the XY plane and the Z axis (a cone).

See also BSCPCONCON, BSCTCONCN2, BSCTCONCYL, BSCTCONCON, BSCTCONLN, BSCTCONPL, BSCTCONPT, BSCTCONSPR, BSCTCYLPL, BSCTCYLPT, BSCTCYLSPR, BSCTPLNPT, BSCTSPRLN, BSCTSPRPL, BSCTSPRPT, BSCTSPRSPR, BSCTTRSPT, BSCTTRSSPR, CALPHASECTOR, CBISECTOR2D, CBISECTOR3D, SBISECTOR.

BSCTPLNPT

SurfaceType | ListType BSCTPLNPT( PointType Pt, NumericType Size )

computes the bisector surface of the XY plane (plane Z = 0) and a point Pt. This surface is a paraboloid of revolution. Size controls the portion of the (infinite) bisector actually represented.

Example:

BisectSrf = BSCTPLNPT( point( 0, 0, 1 ), 1 );

computes the bisector surface of the XY plane and the point (0, 0, 1).

See also BSCPCONCON, BSCTCONCN2, BSCTCONCYL, BSCTCONCON, BSCTCONLN, BSCTCONPL, BSCTCONPT, BSCTCONSPR, BSCTCYLPL, BSCTCYLPT, BSCTCYLSPR, BSCTPLNLN, BSCTSPRLN, BSCTSPRPL, BSCTSPRPT, BSCTSPRSPR, BSCTTRSPT, BSCTTRSSPR, CALPHASECTOR, CBISECTOR2D, CBISECTOR3D, SBISECTOR.

BSCTSPRLN

SurfaceType | ListType BSCTSPRLN( PointType SprCntr, NumericType SprRadius, NumericType Size )

computes the bisector surface of a sphere and the Z axis line. The sphere is centered at SptCntr and has a radius of SprRadius. Size controls the portion of the (infinite) bisector actually represented.

Example:

BisectSrf = BSCTSPRLN( vector( 2, 0, 0 ), 0.7, 1 );

See also BSCPCONCON, BSCTCONCN2, BSCTCONCYL, BSCTCONCON, BSCTCONLN, BSCTCONPL, BSCTCONPT, BSCTCONSPR, BSCTCYLPL, BSCTCYLPT, BSCTCYLSPR, BSCTPLNPT, BSCTSPRLN, BSCTSPRPL, BSCTSPRPT, BSCTSPRSPR, BSCTTRSPT, BSCTTRSSPR, CALPHASECTOR, CBISECTOR2D, CBISECTOR3D, SBISECTOR.

BSCTSPRPL

SurfaceType | ListType BSCTSPRPL( PointType SprCntr, NumericType SprRadius, NumericType Size )

computes the bisector surface of the XP plane (the plane Z = 0) and a sphere. This bisector surface is a paraboloid of revolution. The sphere is centered at SptCntr and has a radius of SprRadius. Size controls the portion of the (infinite) bisector actually represented.

Example:

BisectSrf = BSCTSPRPL( point( 0, 0, 1.5 ), 0.7, 0.5 );

See also BSCPCONCON, BSCTCONCN2, BSCTCONCYL, BSCTCONCON, BSCTCONLN, BSCTCONPL, BSCTCONPT, BSCTCONSPR, BSCTCYLPL, BSCTCYLPT, BSCTCYLSPR, BSCTPLNLN, BSCTPLNPT, BSCTSPRLN, BSCTSPRPT, BSCTSPRSPR, BSCTTRSPT, BSCTTRSSPR, CALPHASECTOR, CBISECTOR2D, CBISECTOR3D, SBISECTOR.

BSCTSPRPT

SurfaceType | ListType BSCTSPRPT( PointType SprCntr, NumericType SprRadius PointType Pt )

computes the bisector surface of a sphere and a point, Pt. The sphere is centered at SptCntr and has a radius of SprRadius.

Example:

Pt = point( 0, 0, 1 ); BisectSrf = BSCTSPRPT( point( 0, 0, 0 ), 0.7, Pt );

computes the bisector of a sphere of radius 0.7 centered at the origin, and the point (0, 0, 1).

See also BSCPCONCON, BSCTCONCN2, BSCTCONCYL, BSCTCONCON, BSCTCONLN, BSCTCONPL, BSCTCONPT, BSCTCONSPR, BSCTCYLPL, BSCTCYLPT, BSCTCYLSPR, BSCTPLNLN, BSCTPLNPT, BSCTSPRLN, BSCTSPRPL, BSCTSPRSPR, BSCTTRSPT, BSCTTRSSPR, CALPHASECTOR, CBISECTOR2D, CBISECTOR3D, SBISECTOR.

BSCTSPRSPR

SurfaceType | ListType BSCTSPRSPR( PointType Spr1Cntr, NumericType Spr1Radius PointType Spr2Cntr, NumericType Spr2Radius )

computes the bisector surface of two spheres. The spheres are centered at Spt1Cntr and Spt2Cntr and have a radii of Spr1Radius and Spr2Radius, respectively.

Example:

BisectSrf = ( point( 0, 0, 0 ), 0.7, point( 1, 0, 0 ), 0.2 );

compute the bisectors of a sphere at the origin with radius 0.7, and a sphere at (1, 0, 0) with a radius of 0.2.

See also BSCPCONCON, BSCTCONCN2, BSCTCONCYL, BSCTCONCON, BSCTCONLN, BSCTCONPL, BSCTCONPT, BSCTCONSPR, BSCTCYLPL, BSCTCYLPT, BSCTCYLSPR, BSCTPLNLN, BSCTPLNPT, BSCTSPRLN, BSCTSPRPL, BSCTSPRPT, BSCTTRSPT, BSCTTRSSPR, CALPHASECTOR, CBISECTOR2D, CBISECTOR3D, SBISECTOR.

BSCTTRSPT

SurfaceType | ListType BSCTTRSPT( PointType TrsPos, VectorType TrsDir, NumericType TrsMjrRad, NumericType TrsMnrRad, PointType Pt )

computes the bisector surface of a torus and a point, Pt. The torus is located at TrsPos, with its axis of symmetry TrsDir, a major radius of TrsMajorRad and a minor radius pf TrsMinorRad.

Example:

BisectSrf = BSCTTRSPT( point( 0.0, 0.0, 0.0 ), vector( 0.0, 0.0, 1.0 ), 0.7, 0.7, Pt );

See also BSCPCONCON, BSCTCONCN2, BSCTCONCYL, BSCTCONCON, BSCTCONLN, BSCTCONPL, BSCTCONPT, BSCTCONSPR, BSCTCYLPL, BSCTCYLPT, BSCTCYLSPR, BSCTPLNLN, BSCTPLNPT, BSCTSPRLN, BSCTSPRPL, BSCTSPRPT, BSCTSPRSPR, BSCTTRSSPR, CALPHASECTOR, CBISECTOR2D, CBISECTOR3D, SBISECTOR.

BSCTTRSSPR

SurfaceType | ListType BSCTTRSSPR( PointType TrsPos, VectorType TrsDir, NumericType TrsMjrRad, NumericType TrsMnrRad, PointType SprCntr, NumericType SprRadius )

computes the bisector surface of a torus and a sphere. The torus is located at TrsPos, with its axis of symmetry TrsDir, a major radius of TrsMajorRad and a minor radius pf TrsMinorRad. The sphere is centered at SptCntr and has a radius of SprRadius.

Example:

BisectSrf = BSCTTRSSPR( point( 0.0, 0.0, 0.0 ), vector( 0.0, 0.0, 1.0 ), 0.7, 0.7, point( 0.7, 0.0, 0.0 ), 0.7);

See also BSCPCONCON, BSCTCONCN2, BSCTCONCYL, BSCTCONCON, BSCTCONLN, BSCTCONPL, BSCTCONPT, BSCTCONSPR, BSCTCYLPL, BSCTCYLPT, BSCTCYLSPR, BSCTPLNLN, BSCTPLNPT, BSCTSPRLN, BSCTSPRPL, BSCTSPRPT, BSCTSPRSPR, BSCTTRSPT, CALPHASECTOR, CBISECTOR2D, CBISECTOR3D, SBISECTOR.

FIGURE: Bisectors of many CSG primitives such as points, lines, planes, spheres, cones, cylinders, and torii are rational. In (left), the rational bisector of a line and a sphere is shown while (right) shows the bisector of a sphere and a torus tangent to each other. See BSCTCONCON, BSCTCONLN, BSCTCONPL, BSCTCONPT, BSCTCONSPR, BSCTCYLPL, BSCTCYLPT, BSCTCYLSPR, BSCTPLNLN, BSCTPLNPT, BSCTSPRLN, BSCTSPRPL, BSCTSPRPT, BSCTSPRSPR, BSCTTRSPT, BSCTTRSSPR.

BZR2BSP

CurveType BZR2BSP( CurveType Crv ) or SurfaceType BZR2BSP( SurfaceType Srf )

creates a B-spline curve or a B-spline surface from the given Bezier curve or Bezier surface. The B-spline curve or surface is assigned an open end knot vector(s) with no interior knots, in the parametric domain of zero to one.

Example:

BspSrf = BZR2BSP( BzrSrf );

BSP2BZR

CurveType | ListType BSP2BZR( CurveType Crv ) or SurfaceType | ListType BSP2BZR( SurfaceType Srf )

creates Bezier curve(s) or surface(s) from a given B-spline curve or a B-spline surface. The B-spline input is subdivided at all internal knots to create Bezier curves or surfaces. Therefore, if the input B-spline does have internal knots, a list of Bezier curves or surfaces is returned. Otherwise, a single Bezier curve or surface is returned. The returned Beziers will have BspDomainMin/Max attributes with the original Bspline domain of the Bezier.

Example:

BzrCirc = BSP2BZR( circle( vector( 0.0, 0.0, 0.0 ), 1.0 ) );

would subdivide the unit circle into four 90 degrees Bezier arcs returned in a list.

CALPHASECTOR

SurfaceType CALPHASECTOR( ListType TwoCrvs, NumericType Alpha) or {CurveType | SurfaceType} CALPHASECTOR( ListType CrvPt, NumericType Alpha)

computes the alpha sector for TwoCrvs of E3 type or between a curve and a point, CrvPt. Alpha varies between zero and one. An alpha-sector is created where for Alpha equals zero, the created surface will contain the first curve, and whereas for Tolerance equals one, the created surface will contain the second curve. For CrvPt case, if the Crv is E2, the alpha sector is a curve and if it is E3, the alpha sector is a surface. See also CBISECTOR2D, CBISECTOR3D.

Example:

c1 = creparam( pcircle( vector( 0.0, 0.0, 0.0 ), 1 ), 0, 1 ); c2 = cbezier( list( ctlpt( E3, -1.0, 0.0, 1.0 ), ctlpt( E3, 1.0, 0.0, -1.0 ) ) ); c1 = coerce( c1, E3); AlphaSect = CALPHASECTOR( list( c1, c2 ), 0.2 ); interact( list( c1, c2, AlphaSect ) );

computes the alpha sector surface between the two curves c1 and c2 for alpha equals 0.2.

CANGLEMAP

CurveType CANGLEMAP( CurveType Crv, NumericType Tolerance, NumericType Angle, NumericType DiagSpan ) or SurfaceType CANGLEMAP( CurveType Crv, NumericType Tolerance, NumericType Angle, NumericType DiagSpan )

computes the angular map of planar curve Crv. This bivariate map corresponds pairs of locations in Crv with tangents that are Angle degrees apart. If, for example, Angle is 90 degrees, locations with orthogonal tangents are identified. The zero set of this bivariate map provides the actual correcpondence and this zero set is computed with Tolerance accuracy, that approximately sets the number of desired surface samples. If Tolerance is negative the function whose zero set is the angular map is returned instead. If DiagSpan is non zero, the angular diagonal span is sampled DiagSpan samples and is computed instead. The DiagSpan will provide for each parameter t the forward and backward step that could be taken before hitting an angular span of Angle degrees for the first time.

Example:

AM = cAngleMap( Crv, 30, Angle, false ); ADS = cAngleMap( Crv, 30, Angle, 300 );

computes the Angular map of curve Crv ay angle Angle with tolerance 30 and then extract the angular diagonal span with the same parameters and 300 samples.

See provided figure for more insight. Shown is a given planar curve, with three angular maps of 30, 60 and 90 degrees. The angular diagonal span is also drawn in dark thin lines.

FIGURE: Angular maps computed for the given planar curve on the left, at 30, 60, and 90 degrees, using CANGLEMAP. Also show is the angular diagonal span in thin dark color.
See also CVIEWMAP, CVISIBLE, CARRANGMNT.

CARCLEN

CurveType CARCLEN( CurveType Crv, NumericType Fineness, NumericType Order )

approximates an arc length curve out of the given curve Crv. The new approximated curve is sampled with tolerance that is governed by Fineness and will be of order Order. The returned curve is not guaranteed to share the exact same trace as the original curve Crv.

Example:

c2 = carclen( c, 1e-4, 3 );

approximates c as a quadratic arc length curve c2 by sampling the original curve with tolerance 1e-4.

CAREA

CurveType CAREA( CurveType Crv )

computes the integral area curve, ACrv, of the given curve Crv, up to a sign. If Crv is a closed curve with domain t0 to t1, then the difference of ACrv(t1) - ACrv(t0) is the requested area. Example:

Crv = pcircle( vector( 0, 0, 0 ), 1 ); ACrv = CAREA( Crv ); Pi = abs( coord( ceval( ACrv, 4 ), 1 ) - coord( ceval( ACrv, 0 ), 1 ) );

is yet another way of approximating the value of Pi. See also SMOMENTS and SVOLUME.

CARRANGMNT

CurveType CARRANGMNT( CurveType Crvs, NumericType Eps, NumericType Operation, PointType CenterPt )

computations over the given arrangment of planar curves Crvs upto accuracy that is governed by Eps. Operation can be one of:

1 - computes all the curve curve intersection locations in the arrangment and keep the results in "InterPts" attributes on the returned curves.

2 - computes all the curve curve intersection locations in the arrangment and split all curves at all those intersections.

3 - computes Y-minimum lower envelop for this curves' arrangement.

4 - computes radial lower envelop around point Center Pt.

CenterPt is ignored if Operation is not equal to 4.

Example:

LinearLowEnv = carrangmnt( Crvs, 1e-12, 3, 0 );

computes the Y-minimum envelop of curve Crvs.

See provided figure for one example of Y-minimum envelop of curves.

FIGURE: Y-minimum envelop for a set of curves, computed using CARRANGMNT. The lower envelop is shown in thick lines.
See also CVIEWMAP, CVISIBLE, CANGLEMAP.

CBEZIER

CurveType CBEZIER( ListType CtlPtList )

creates a Bezier curve out of the provided control point list. CtlPtList is a list of control points, all of which must be of type (E1-E9 P1-P9), or regular PointType defining the curve's control polygon. The curve's point type will be of a space which is the union of the spaces of all points.

Example:

s45 = sin(pi / 4); Arc90 = CBEZIER( list( ctlpt( P2, 1.0, 0.0, 1.0 ), ctlpt( P2, s45, s45, s45 ), ctlpt( P1, 1.0, 1.0 ) ) );

constructs an arc of 90 degrees as a rational quadratic Bezier curve.

See also CBSPLINE, CPOWER and SBEZIER.

CBIARCS

ListType CBIARCS( CurveType Crv, NumericType Tol, NumericType MaxAngle )

computes bi-arc fitting to a given curve Crv, with a tolarence Tol in L-infinity sense, and a maximum angular span of each arc of at most MaxAngle degrees. Returned is a list of arcs as rational Bezier curves with an arc "center" point attribute to ease the reconstruction of the analytic representation of the geometry.

Example:

C1 = cbspline( 4, list( ctlpt( E3, -0.287, -0.286, 0 ), ctlpt( E2, 0.0272, -0.425 ), ctlpt( E2, 0.265, -0.0839 ), ctlpt( E2, 0.607, -0.165 ), ctlpt( E2, 0.832, -0.205 ), ctlpt( E2, 0.737, 0.042 ), ctlpt( E2, 0.357, 0.103 ), ctlpt( E2, 0.508, 0.298 ), ctlpt( E2, 0.814, 0.649 ), ctlpt( E2, 0.692, 0.775 ), ctlpt( E2, 0.411, 0.391 ), ctlpt( E2, 0.301, 0.315 ), ctlpt( E2, 0.625, 0.945 ), ctlpt( E2, 0.49, 1.03 ), ctlpt( E2, 0.369, 0.829 ), ctlpt( E2, 0.185, 0.384 ), ctlpt( E2, 0.194, 0.518 ), ctlpt( E2, 0.243, 1.09 ), ctlpt( E2, 0.0653, 1.13 ), ctlpt( E2, 0.0644, 0.381 ), ctlpt( E2, 0.00925, 0.496 ), ctlpt( E2, -0.0113, 0.943 ), ctlpt( E2, -0.202, 0.954 ), ctlpt( E2, -0.147, 0.644 ), ctlpt( E2, -0.162, 0.208 ), ctlpt( E2, -0.337, -0.156 ) ), list( kv_periodic ) ); C1 = coerce( C1, kv_open ); Arcs = CBIARCS( Crv, 0.01, 90 );

computes bi-arcs fitting to a given curve in the shape of a human hand, with arcs with at most 90 degrees and tolerance of 0.01.

FIGURE: Bi-arcs are fitted to the given curve in the shape of a human hand, at two different tolerances, using CBIARCS.
See also QUADCRVS, CUBICCRVS.

CBISECTOR2D

CurveType CBISECTOR2D( CurveType Crv, NumericType ZeroSet, NumericType BisectFunc, NumericType Tolerance, NumericType NumerImprove, NumericType SameNormal ) or CurveType CBISECTOR2D( ListType TwoCrvs, NumericType ZeroSet, NumericType BisectFunc, NumericType Tolerance, NumericType NumerImprove, NumericType SameNormal ) or SurfaceType CBISECTOR2D( ListType CrvPt, NumericType ZeroSet, NumericType UseNrmlTan, NumericType Tolerance, NumericType NumerImprove, NumericType SameNormal )

computes the self bisector curve(s) for Crv or the bisector(s) of TwoCrvs or the bisector of a curve and a point, CrvPt. If (bf ZeroSet) is TRUE, the zero-set surface is computed and is used mainly for displaying the zero-set. If it is FALSE, the bisector is returned. The zero-set is computing using the functions F1, F2 and F3 in the paper Gershon Elber and Myung Soo Kim. ``Bisector Curves of Planar Rational Curves.'' CAD, Vol 30, No 14, pp 1089-1096, December 1998} which is determined by the BisectFunc parameter. If BisectFunc = 1, then F1 is used and so on. Tolerance controls the accuracy of the computation, with 10 as a good starting value. If Tolerance is negative, NumerImprove can be either TRUE or FALSE, allowing or disabling a final numerical improvement stage. SameNormal can also assume a TRUE or FALSE value, selecting only opposite facing normals, if TRUE. The bisector curve of a curve (E2) and a point CrvPt is computed analytically. Other parameters are ignored. See also CBISECTOR3D, CALPHASECTOR, SBISECTOR.

Example:

c1 = cbezier( list( ctlpt( E2, -0.5, -0.2 ), ctlpt( E2, 0.0, -0.2 ), ctlpt( E2, 0.6, 0.6 ) ) ); c2 = cbezier( list( ctlpt( E2, 0.3, -0.7 ), ctlpt( E2, -0.2, -0.7 ), ctlpt( E2, 0.7, 0.6 ) ) ); BisectCrvs = CBISECTOR2D( list( c1, c2 ), FALSE, 1, 12, true, false ); All = list( c1, c2, BisectCrvs ); interact( list( All, view_mat2d ) );

computes the bisector for planar curves as a set of bisector curves.

CBISECTOR3D

SurfaceType CBISECTOR3D( ListType TwoCrvs, NumericType BisectFunc) or SurfaceType CBISECTOR3D( ListType CrvPt, NumericType BisectFunc)

computes the bisector surface TwoCrvs or the bisector surface of a curve and a point, CrvPt, in R3. The BisectFunc determines the function to be used for generating the bisector surface between the two E3 curves. If 1, a 3-space bisector surface is generated to the given curves or a curve and a point. If 4, a surface whose zero set prescribes the bisectors of the given curves is returned. For a bisector between a curve and a point, the BisectFunc parameter is ignored and a 3 space surface is always computed. See also CBISECTOR2D, CALPHASECTOR, SBISECTOR.

Example:

c1 = creparam( pcircle( vector( 0.0, 0.0, 0.0 ), 1 ), 0, 1 ); c2 = cbezier( list( ctlpt( E3, -1.0, 0.0, 1.0 ), ctlpt( E3, 1.0, 0.0, -1.0 ) ) ); c1 = coerce( c1, E3); BisectSrf = CBISECTOR3D( list( c1, c2 ), 1 ); interact( list( c1, c2, BisectSrf ) );

computes a bisector surface of a Z parallel line and a circle in the XY plane.

FIGURE: (left) Bisectors of two quadratic Bezier curves in the plane. (right) A bisector surface of a line and a circle in three space. See the CBISECTOR2D and CBISECTOR3D functions respectively.

CBSPLINE

CurveType CBSPLINE( NumericType Order, ListType CtlPtList, ListType KnotVector )

creates a B-spline curve out of the provided control point list, the knot vector, and the specified order. CtlPtList is a list of control points, all of which must be of type (E1-E9 P1-P9, or regular PointType defining the curve's control polygon. The curve's point type will be of a space which is the union of the spaces of all points. The length of the KnotVector must be equal to the number of control points in CtlPtList plus the Order. If, however, the length of the knot vector is equal to #CtlPtList + Order + Order - 1, the curve is assumed to be periodic. The knot vector list may be specified as either list( KV_OPEN ), list( KV_FLOAT ) or list( KV_PERIODIC ) in which a uniform open, uniform floating or uniform periodic knot vector with the appropriate length is automatically constructed.

Example:

s45 = sin(pi / 4); HalfCirc = CBSPLINE( 3, list( ctlpt( P3, 1.0, 1.0, 0.0, 0.0 ), ctlpt( P3, s45, s45, s45, 0.0 ), ctlpt( P3, 1.0, 0.0, 1.0, 0.0 ), ctlpt( P3, s45, -s45, s45, 0.0 ), ctlpt( P3, 1.0, -1.0, 0.0, 0.0 ) ), list( 0, 0, 0, 1, 1, 2, 2, 2 ) );

constructs an arc of 180 degrees in the XZ plane as a rational quadratic B-spline curve.

Example:

c = CBSPLINE( 4, list( ctlpt( E2, 0.5, 0.5 ), ctlpt( E2, -0.5, 0.5 ), ctlpt( E2, -0.5, -0.5 ), ctlpt( E2, 0.5, -0.5 ) ), list( KV_PERIODIC ) ); color( c, red ); viewobj( c ); c1 = cregion( c, 3, 4 ); color( c1, green ); c2 = cregion( c, 4, 5 ); color( c2, yellow ); c3 = cregion( c, 5, 6 ); color( c3, cyan ); c4 = cregion( c, 6, 7 ); color( c3, magenta ); viewobj( list( c1, c2, c3, c4 ) );

creates a periodic curve and extracts its four polynomial domains as four open end B-spline curves.

FIGURE: A cubic periodic curve created using KV_PERIODIC end conditions.

See also CBEZIER, CPOWER and SBSPLINE.

CCINTER

ListType CCINTER( CurveType Crv1, CurveType Crv2, NumericType Epsilon, NumericType SelfInter ) or SurfaceType CCINTER( CurveType Crv1, CurveType Crv2, NumericType Epsilon, NumericType SelfInter )

compute the intersection point(s) of Crv1 and Crv2 in the XY plane. Since this computation involves numeric operations, Epsilon controls the accuracy of the parametric values of the result. It returns a list of PointTypes, each containing the parameter of Crv1 in the X coordinate, and the parameter of Crv2 in the Y coordinate. If, however, Epsilon is negative, a scalar field surface representing the square of the distance function is returned instead. If SelfInter is TRUE, Crv1 and Crv2 can be the same curve, and self intersection points are searched for instead.

Example:

crv1 = cbspline( 3, list( ctlpt( E2, 0, 0 ), ctlpt( E2, 0, 0.5 ), ctlpt( E2, 0.5, 0.7 ), ctlpt( E2, 1, 1 ) ), list( KV_OPEN ) ); crv2 = cbspline( 3, list( ctlpt( E2, 1, 0 ), ctlpt( E2, 0.7, 0.25 ), ctlpt( E2, 0.3, 0.5 ), ctlpt( E2, 0, 1 ) ), list( KV_OPEN ) ); inter_pts = CCINTER( crv1, crv2, 0.0001, FALSE );

computes the parameter values of the intersection point of crv1 and crv2 to a tolerance of 0.0001.

FIGURE: A intersection point of two freeform curve computed using CCINTER.

CCRVTR

ListType CCRVTR( CurveType Crv, NumericType Epsilon, NumericType Operation ) or CurveType CCRVTR( CurveType Crv, NumericType Epsilon, NumericType Operation )

computes the curvature field's magnitude square of Crv in the XY plane if Operation is 1, or its extreme points if Operation equals 2. This set includes not only points of maximum (convexity) and mimumum (concavity) curvature, but also points of zero curvature locations, such as inflection points. A list of parameter value(s) of the location(s) with extreme curvature along the Crv is returned in the latter case. Since this operation is partially numeric, Epsilon is used to set the needed accuracy. If, however, Operation is 3, the input curve is being split at the extreme curvature location and a list of curve segments is returned instead.

  This function computes the (square of the)  curvature scalar field for

planar curves as,

         x' y'' - x'' y'

  k(t) = ----------------

              2     2  3/2

          ( x'  + y'  )

and computes (the square of) kN for three-dimensional curves as the

following vector field,

                                 C' x C''     C'    (C' x C'') x C'

  k(t) N(t) = K(t) B(t) x T(t) = -------- x ----- = ---------------

                                       3    | C' |            4

                                  | C'|                 | C' |

The extremum values are extracted from the computed curvature field. This (square of the) curvature field is a high order curve, even if the input geometry is of low order. This is especially true for rational curves, for which the quotient rule for differentiation is used and almost doubles the degree in every differentiation.

See also CCRVTREVAL, CINFLECT, CNRMLCRV, CZEROS, CEXTREMES, and SCRVTR.

Example:

crv = cbezier( list( ctlpt( E2, -1.0, 0.5 ), ctlpt( E2, -0.5, -2.0 ), ctlpt( E2, 0.0, 1.0 ), ctlpt( E2, 1.0, 0.0 ) ) ) * rotz( 30 ); crvtr = CCRVTR( crv, 0.001, 2 ); pt_crvtr = nil(); pt = nil(); for ( i = 1, 1, sizeof( crvtr ), ( pt = ceval( crv, nth( crvtr, i ) ) ): snoc( pt, pt_crvtr ) ); interact( list( crv, pt_crvtr ) );

finds the extreme curvature points in Crv and displays them all with the curve.

FIGURE: Extreme curvature locations on a freeform curve computed using CCRVTR.

CCRVTR

PolyType CCRVTR1PT( CurveType Crv, NumericType CtlPtIdx, NumericType Min, NumericType Max, NumericType SubdivTol, NumericType NumerTol, NumericType Operation ) or MultivarType CCRVTR1PT( CurveType Crv, NumericType CtlPtIdx, NumericType Min, NumericType Max, NumericType SubdivTol, NumericType NumerTol, NumericType Operation )

computes the topology changes in the curvature field of curve Crv as control point index CtlPtIdx in the curve is moving. The motion of the control points is limited to be between Min and Max in X and Y. See MZERO for the meaning of the SubdivTol and NumerTol. The returned value depends on Operation: If Operation is 0, a multivariate of dim(Crv) + 1 that is representing the curvature topology field is returned. If Operation is 1, the marching cubes of Operation == 0 is computed and returned as a polygonal surface. If Operation is 2 the silhouette of 1 is computed and returned and if Operation is 3 the result of 2 is evaluated back into Euclidean space.

Example:

MV = CCRVTR1PT( Crv, 4, Min, Max, 0.01, 1e-10, 1 );

CCRVTREVAL

NumericType CCRVTREVAL( CurveType Curve, NumericType t )

computes the curvature of curve Curve at parameter t.

Example:

k = CCRVTREVAL(Crv, 0.5 );

See also CCRVTR.

CDERIVE

CurveType CDERIVE( CurveType Curve )

returns a vector field curve representing the differentiated curve, also known as the Hodograph curve.

Example:

Circ = circle( vector( 0.0, 0.0, 0.0 ), 1.0 ); Hodograph = CDERIVE( Circ );

FIGURE: The Hodograph (thick) of a B-spline circle (thin) constructed as four 90 degrees rational Bezier arcs, computed using CDERIVE.
See also CINTEG, SDERIVE, TDERIVE, and MDERIVE

CDIVIDE

ListType CDIVIDE( CurveType Curve, NumericType Param )

subdivides a curve into two sub-curves at the specified parameter value. Curve can be either a B-spline curve in which Param must be within the Curve's parametric domain, or a Bezier curve in which Param can be arbitrary, extrapolating if not in the range of zero to one.

It returns a list of the two sub-curves. The individual curves may be extracted from the list using the NTH command.

Example:

CrvLst = CDIVIDE( Crv, 1.3 ); Crv1 = nth( CrvLst, 1 ); Crv2 = nth( CrvLst, 2 );

subdivides the curve Crv at the parameter value of 0.5.

FIGURE: A B-spline curve is subdivided into two distinct regions using CDIVIDE.
See also SDIVIDE, TDIVIDE, and MDIVIDE

CEDITPT

CurveType CEDITPT( CurveType Curve, CtlPtType CtlPt, NumericType Index )

provides a simple mechanism to manually modify a single control point number Index (base count is 0) in the Curve, by substituting CtlPt instead. CtlPt must have the same point type as the control points of the Curve. The original curve Curve is not modified.

Example:

CPt = ctlpt( E3, 1, 2, 3 ); NewCrv = CEDITPT( Curve, CPt, 1 );

constructs a NewCrv with the second control point of Curve being CPt.

CENVOFF

SurfaceType CENVOFF( CurveType Curve, NumericType Height, NumericType Tolerance ) or ListType CENVOFF( CurveType Curve, NumericType Height, NumericType Tolerance )

computes the offset envelope of a given planar curve Curve. The offset envelope is the envelope of cones with apex on point on Curve in the Z direction. Height is the height of the cone which also equals the offset distance or the width of the cones. Tolerance controls the accuracy of the offset approximation.

If the Curve is closed, two surfaces are created in the offset envelope, one for the inside and another for the outside. If Curve is open, a single envelope offset surface is computed, wrapping around both sides.

Example:

c1 = cbezier( list( ctlpt( E2, -0.8, 0.0 ), ctlpt( E2, -0.2, 1.0 ), ctlpt( E2, 0.2, 0.0 ), ctlpt( E2, 0.8, 0.6 ) ) ); s1 = CENVOFF( c1, 0.5, 0.01 );

computes an envelope offset surface for a cubic Bezier curve c1 of Height of 0.5 and Tolerance of 0.01.

FIGURE: The envelope offset of a freeform planar curve computed using CENVOFF.

CEVAL

CtlPtType CEVAL( CurveType Curve, NumericType Param )

evaluates the provided Curve at the given Param value. Param should be in the curve's parametric domain if the Curve is a B-spline curve, or between zero and one if the Curve is a Bezier curve. The returned control point has the same point type as the control points of the Curve.

Example:

CPt = CEVAL( Crv, 0.25 );

evaluates Crv at the parameter value of 0.25. See also SEVAL, MEVAL, TEVAL.

CEXTREMES

ListType CEXTREMES( CurveType Crv, NumericType Epsilon, NumericType Axis )

computes the extreme set of the given Crv in the given axis (1 for X, 2 for Y, 3 for Z). Since this computation is numeric, an Epsilon is also required to specify the desired tolerance. It returns a list of all the parameter values (NumericType) in which the curve takes an extreme value.

Example:

extremes = CEXTREMES( Crv, 0.0001, 1 );

computes the extreme set of curve crv, in the X axis, with error tolerance of 0.0001. See also CZERO.

FIGURE: The X local extremums of a freeform curve are isolated using CEXTREMES.

CFNCRVTR

CurveType CFNCRVTR( CurveType E2Crv, NumericType Samples, NumericType Order, NumericType ArcLen ) or CurveType CFNCRVTR( CurveType CrvtrE1Crv, NumericType Accuracy, NumericType Order, NumericType Periodic )

computes the curvature field of planar curve E2Crv in the first form, and reconstructs an E2 planar curve from the given curvature field CrvtrE1Crv in the second form. In the first form, Samples defines the numer of samples to use along the input curve while if ArcLen TRUE the samples are also made along the arc length of E2Crv. In the second form, a planar curve is reconstructed from the curvature field of CrvtrE1Crv, with Accuracy to control the accuracy. If the reconstructed curve is suppose to be closed, set Periodic to TRUE. In both forms, Order sets the order of the return curve.

Example:

CrvtrField = CFNCRVTR( Crv, 1000, 2, TRUE );

CIEXTREME

ListType CIEXTREME( SurfaceType Srf, NumericType Dir, NumericType SubdivTol, NumericType NumerTol )

computes the X- or Y-extreme values of the implicit univariate defined as the zero set of Srf. In addition, this function also detects hyperbolic tangent contact of Srf with the plane Z = 0. Dir specified the desired direction of the extremum to extract, one of COL or ROW. See MZERO for the meaning of the SubdivTol and NumerTol.

Example:

ViewMap = CIEXTREME( Srf, col, 0.01, 1e-9 );

See figure for an example.

FIGURE: An example of computing the X- and Y-extreme locations of this implicit curve defined as the zero set of the surface. Also detected surface tangency contacts with the plane Z = 0.

CINFLECT

ListType CINFLECT( CurveType Crv, NumericType Epsilon, NumericType Operation ) or CurveType CINFLECT( CurveType Crv, NumericType Epsilon, NumericType Operation )

computes and returns a scalar field (the numerator of the curvature field, the sign of the curvature field if you like) whose zeros are the inflection points of Crv in the XY plane, if Operation is 1. If Operation is 2, the inflection points are derived and returned as list of all the parameter values (NumericType) in which the curve has an inflection point. Since this computation is partially numeric, an Epsilon is also required to specify the desired tolerance. If, however, Operation is 3, the input curve Crv is being split at all the inflection points and the different, inflection free, curve segements are returned in a list.

The sign of curvature scalar field is equal to

      s(t) = x' y'' - x'' y'

Example:

inflect = CINFLECT( crv, 0.001, 2 ); pt_inflect = nil(); pt = nil(); for ( i = 1, 1, sizeof( inflect ), pt = ceval( crv, nth( inflect, i ) ): snoc( pt, pt_inflect ) ); interact( list( axes, crv, pt_inflect ) );

computes the set of inflection points of curve crv with error tolerance of 0.001. This set is then scanned in a loop and evaluated to the curve's locations which are then displayed with the crv. See also CZEROS, CEXTREMES, and CCRVTR.

FIGURE: The Inflection points of a freeform curve can be isolated using CINFLECT.

CINTEG

CurveType CINTEG( CurveType Crv );

returns a vector field curve representing the integral curve. See also CDERIVE.

CINTERP

CurveType CINTERP( ListType PtList, NumericType Order, NumericType Size, ConstantType Param, NumericType Periodic) or CurveType CINTERP( CurveType Crv, NumericType Order, NumericType Size, ConstantType Param, NumericType Periodic) or CurveType CINTERP( ListType PtList, NumericType Order, NumericType Size, ListType Params, NumericType Periodic) or CurveType CINTERP( CurveType Crv, NumericType Order, NumericType Size, ListType Params, NumericType Periodic)

compute a B-spline curve that interpolates or approximates the list of points in PtList or a given curve Crv. The B-spline curve will have order Order and Size control points, and will be periodic if periodic is non zero. The knots will be spaced according to Param which can be one of PARAM_UNIFORM, PARAM_CHORD, PARAM_CENTRIP or PARAM_NEILFOL or lists of parameter values and knots (see below). The PARAM_UNIFORM prescribes a uniform knot sequence, PARAM_CHORD specifies knot spacing according to the chord length and PARAM_CENTRIP according to the square root of the chord length. Finally, PARAM_NEILFOL takes into consideration the angles between three consecutive points. A periodic curve will be coerced to have a PARAM_UNIFORM knot sequence. If Params is a list object, it should contain two lists of numerical values. The first list contains the parameter values at which to approximate or interpolate the data points. Hence, the length of this list must equal the length of the PtList data. The second list specifies the knot vector of the construct B-spline curve. Use of Periodic end conditions can create cases with degenerated linear systems (determinant equal zero). Increase or decrease of the Order of the B-spline by one will resolve the problem. All points in PtList must be of type (E1-E9, P1-P9) control point, or regular PointType. If Size is equal to the number of points in PtList, the resulting curve will interpolate the data set. Otherwise, if Size is less than the number of points in PtList, the point data set will be least square approximated. At no time can Size be lower than Order. Size of zero forces interpolation by selecting Size to be the size of the data set. All interior knots will be distinct, preserving maximal continuity. The resulting B-spline curve will have open end conditions.

Example:

pl = nil(); for ( x = 0, 1, 100, snoc(point(cos(x / 5), sin(x / 5), x / 50 - 1), pl) ); c = CINTERP( pl, 3, 21, PARAM_UNIFORM, false );

samples a helical curve at 100 points and least square fit of a quadratic B-spline curve with 21 points to the data set. The curve will have a uniform knot spacing and is not periodic. See also SINTERP, TINTERP and LINTERP.

FIGURE: A Helix, sampled at 100 locations, is least square fitted using CINTERP by a quadratic B-spline curve and 21 control points.

CIRCLE

CurveType CIRCLE( VectorType Center, NumericType Radius )

constructs a circle at the specified Center with the specified Radius. The returned circle is a B-spline curve of four piecewise Bezier 90 degree arcs. The construced circle is always parallel to the XY plane. Use the linear transformation routines to place the circle in the appropriate orientation and location.

CIRCPOLY

PolygonType CIRCPOLY( VectorType Normal, VectorType Trans, NumericType Radius )

defines a circular polygon in a plane perpendicular to Normal that contains the Trans point. The constructed polygon is centered at Trans. RESOLUTION vertices will be defined with Radius from distance from Trans.

Alternative ways to construct a polygon are manual construction of the vertices using POLY, or the construction of a flat ruled surface using RULEDSRF.

CLNTCRSR

ListType CLNTCRSR( NumericType TimeOut )

reads the mouse coordinates as well as mouse events from displace devices, or times out after TimeOut miliseconds. A list object of two sub-objects, a points and a vector, named "_PickCrsr_" is returned. These point and vector define the three-dimensional line of the mouse in object space.

Mouse events are typically processed by the display device. However, by the command "CLNTPICKCRSR" (in iritinit.irt) which sends a "PICKCRSR" request to the display devices, mouse events will be sent to the server. The server can be requested to keep mouse events for "CLNTCRSR" to be read via the IritState command and the "CursorKeep" attribute.

Both the point and the vector will have a numeric attribute of "EventType" that will have the following meaning:

1	Mouse motion event
2	Mouse down event
5	Mouse up event

In case of a time out the returned list object will be empty and will have the name "_PickFail_".

Example:

ClntPickCrsr( clients_all ); IritState( "CursorKeep", 1 ); Quit = 0; for ( i = 0, 1, 10, CLNTCRSR( 10000 ) ); ClntPickDone( clients_all ); IritState( "CursorKeep", 0 );

asks all clients to send mouse events to the server, asks the server to keep mouse events, and then reads 10 mouse events.

CLNTREAD

AnyType CLNTREAD( NumericType Handler, NumericType Block )

reads one object from a client communication channel. Handler contains the index of the communication channel opened via CLNTEXEC. If no data is available in the communication channel, this function will block for at most Block milliseconds until data is found or timeout occurs. In the latter, a single StringType object is returned with the content of "no data (timeout)". If Handler equals -1, the regular display device (forked via, for example, VIEWOBJ command) is used. See also VIEWSET, CLNTWRITE, CLNTCLOSE, and CLNTEXEC.

Example:

h2 = clntexec( "xmtdrvs -s-" ); . . Model = CLNTREAD( h2 ); . . clntclose( h2,TRUE );

reads one object from client through communication channel h2 and saves it in variable model.

CMESH

CurveType CMESH( SurfaceType Srf, ConstantType Direction, NumericType Index )

returns a single ROW or COLumn as specified by the Direction and Index (base count is 0) of the control mesh of surface Srf.

The returned curve will have the same knot vector as Srf in the appropriate direction. See also CSURFACE.

This curve is not necessarily in the surface Srf.

Example:

Crv = CMESH( Srf, COL, 0 );

extracts the first column of surface Srf as a curve. See also CSURFACE. See also SMESH, MFROMMESH.

CMOEBIUS

CurveType CMOEBIUS( CurveType Crv, NumericType Ratio )

rebalances the weights of a rational curve using the Moebius transformation. The shape of the curve remains identical while the speed is modified. Ratio controls the ratio between the last and the first weights. If Ratio = 0, the first and last weights are made equal.

See also SMOEBIUS.

CMORPH

CurveType CMORPH( CurveType Crv1, CurveType Crv2, NumericType Method, NumericType Blend ) or ListType CMORPH( CurveType Crv1, CurveType Crv2, NumericType Method, NumericType Blend )

create a new curve which is a metamorph of the two given curves. The two given curves must be compatible (see FFCOMPAT) before this blend is invoked. This is very useful if a sequence that "morphs" one curve to another is to be created. Several metamorphosis methods are supported according to the value of Method,

0	Simple convex blend.
1	Corner/Edge cutting scheme, scaled to same curve length.
2	Corner/Edge cutting scheme, scaled to same bounding box.
3	Same as 1 but with filtering out of tangencies.
4	Same as 2 but with filtering out of tangencies.
5	Multiresolution decomposition based metamorphosis. See CMULTRES.

In Method 1, Blend is a number between zero (Crv1) and one (Crv2) defining the similarity to Crv1 and Crv2, respectively. A single curve is returned.

In Methods 2 to 5, Blend is a step size for the metamorphosis operation and a whole list describing the entire metamorphosis operation is returned.

Examples:

for ( i = 0, 1, 300, c = CMORPH( crv1a, crv1b, 0, i / 300.0 ): color( c, yellow ): viewobj( c ) ); crvs = CMORPH( crv1a, crv1b, 2, 0.003 ); snoc( crv1b, crvs ); for ( i = 1, 1, sizeof( crvs ), c = nth( crvs, i ): color( c, yellow ): viewobj( c ) ); Turtle2 = ffmatch( Wolf, Turtle, 20, 100, 2, false, 2 ); ffcompat( Wolf, Turtle2 ); for ( i = 0, 1, 25, c = CMORPH( Wolf, Turtle2, 0, i / 25 ): color( c, yellow ): viewobj( c ) );

creates three metamorphosis animation sequences, one that is based on a convex blend, and two that are based on corner/edge cutting schemes. See also PMORPH, SMORPH, TMORPH, and FFMATCH.

FIGURE: A morphing sequence using convex blend (top left), edge cutting (top right), and using FFMATCH and convex blend (bottom).

CMULTIRES

ListType CMULTIRES( CurveType Crv, NumericType Discont, NumericType LeastSquares )

computes a multiresolution decomposition of curve Crv using least squares approximation, if LeastSquares is TRUE, or using B-Wavelets if LeastSquares is FALSE. The latter is optimal but slower. The resulting list of curves describes an hierarchy of curves in linear subspaces of the space in which Crv lay. If LeastSquares is TRUE, the curves could be summed algebraically to form Crv. Each of the curves in the hierarchy is a least squares approximation of Crv in the subspace in which it is defined. If LeastSquares is FALSE, a list of orthogonal projections of the Crv onto the prescibed subspaces (by the knot sequences) is provided. Finally, Discont is a Boolean flag that controls the way tangent discontinuities are preserved throughout the decomposition. If, however, Discont is -1, LeastSquares will indicate the index of the knot in Crv to compute its BWavelet function.

Example:

MRCrv = CMULTIRES( Animal, false, true ); sum = nth( MRCrv, 1 ); MRCrvs = list( sum * tx( 3.0 ) ); for ( ( i = 2 ), 1, sizeof( MRCrv ), sum = symbsum( sum, nth( MRCrv, i ) ): snoc( sum * tx( ( 3 - i ) * 1.5 ), MRCrvs ) ); All = MRCrvs * sc ( 0.25 ); view( All, on );

computes a multiresolution decomposition to curve CrossSec as MRCrv and displays all the decomposition levels by summing them all up. The use of none as on object name allows one to display an object in the display device without replacing the previous object in the display device, carrying the same name.

This creates two metamorphosis animation sequences, one based on a convex blend and one based on a corner/edge cutting scheme.

FIGURE: A multiresolution decomposition of a curve of an animal using least squares. The original curve is shown on the left.

CNORMAL

VectorType CNORMAL( CurveType Crv, NumericType TParam )

computes the normal vector to curve Crv at the parameter values TParam. The returned vector has a unit length.

Example:

Normal = CNORMAL( Crv, 0.5 );

computes the normal to Crv at the parameter value 0.5. See also CNRMLCRV, CTANGENT.

CNRMLCRV

CurveType CNRMLCRV( CurveType Crv )

symbolically computes a vector field curve representing the non-normalized normals of the given curve. That is, a normal vector field, evaluated at t, provides a vector in the direction of the normal of the original curve at t. The normal curve once computed is in fact equal to kN where k is the curvature of Crv and N is its normal.

Example:

NrmlCrv = CNRMLCRV( Crv );

See also CCRVTR.

CNVXHULL

PolygonType CNVXHULL( PolygonType Poly | PolylineType Poly, NumericType FineNess ); or CurveType CNVXHULL( CurveType Crv, NumericType FineNess );

compute the convex hull of the given set of Poly or Curve with tolerance for curves only, which is governed by the polygon subdivision accuracy as set via FineNess. FineNess is ignored for polylines. For curves, the result might be partial if the curve is not closed or periodic. See also CRV2TANS and CRVPTTAN.

Example:

Pts1 = nil(); Pts2 = nil(); for ( i = 0, 1, 7, R = 0.2 + fmod( i, 2 ) / 2: Pt = ctlpt( E2, R * cos( i * 2 * pi / 8 ), R * sin( i * 2 * pi / 8 ) ): snoc( Pt, Pts1 ): snoc( coerce( Pt, point_type ), Pts2 ) ); Crv = coerce( cbspline( 4, Pts1, list( KV_PERIODIC ) ), KV_OPEN ); CHPts = CNVXHULL( poly( Pts2, 0 ), 0 ); CHCrv = CNVXHULL( Crv, 10 );

computes the convex hull of a given control polygon and freeform curve.

FIGURE: A convex hull of a set of points and of a freeform B-spline curve. The left show a convex hull of a set of points. The right shows the convex hull (thick line) of a freeform curve.

COERCE

AnyType COERCE( AnyType Object, ConstantType NewType )

provides a coercion mechanism between different objects or object types. PointType, VectorType, PlaneType, and CtlPtType can be all coerced to each other by using the NewType of POINT_TYPE, VECTOR_TYPE, PLANE_TYPE, or one of E1-E9, P1-P9 (CtlPtType). Similarly, CurveType, SurfaceType, TrimSrfType, TriSrfType, TrivarType, and MultivarType can all be coerced to hold different CtlPtType control points, or even different open end conditions from KV_PERIODIC to KV_FLOAT to KV_OPEN. Freefroms can be coerced to a Power, Bezier or a B-spline type via the NewType of POWER_TYPE, BEZIER_TYPE or the BSPLINE_TYPE. If a scalar (E1 or P1) curve is coerced to E2 or P2 curve or a scalar (E1 or P1), the surface is coerced to an E3 or P3 surface, and the Y (YZ) coordinate(s) is (are) updated to hold the parametric domain of the curve (surface). That is X = U (Y = V). Curves, Surfaces, and Trivariates can be coerced to/from Multivariates using the CURVE_TYPE, SURFACE_TYPE, TRIVAR_TYPE and MULTIVAR_TYPE.

Example:

CrvE2 = COERCE( Crv, E2 ); MultiVar == COERCE( COERCE( MultiVar, surface_type ), multivar_type ); BzrSrfs = COERCE( BspSrf, bezier_type );

coerces Crv to a new curve that will have an E2 CtlPtType control points. Coerction of a projective curve (P1-P9) to a Euclidean curve (E1-E9) does not preseve the shape of the curve. The second example coerces a bivariate MultiVar into a Srf and back and compares the result to the original multivariate MultiVar... The third example coerces a B-spline surface BspSrf to a Bezier form, returning one or more Bezier surfaces representing the same geometry as BspSrf.

COMPOSE

CurveType COMPOSE( CurveType Crv1, CurveType Crv2 ) or CurveType COMPOSE( SurfaceType Srf, CurveType Crv )

symbolically compute the composition curve Crv1(Crv2(t)) or Srf(Crv(t)). In the above first form of Crv1(Crv2(t), Crv1 can be any curve while Crv2 is assumed to be a one-dimensional curve that is either E1 or P1 (higher dimensions are ignored). In the above second form of Srf(Crv(t)), the Srf can be any surface, while the Crv is assumed to be a two-dimensional curve, that is either E2 or P2 (higher dimensions are ignored). Both Crv2 in the curve's composition, and Crv is the surface's composition must be contained in the curve or surface parametric domain.

Example:

srf = sbezier( list( list( ctlpt( E3, 0.0, 0.0, 0.0 ), ctlpt( E3, 0.0, 0.5, 1.0 ), ctlpt( E3, 0.0, 1.0, 0.0 ) ), list( ctlpt( E3, 0.5, 0.0, 1.0 ), ctlpt( E3, 0.5, 0.5, 0.0 ), ctlpt( E3, 0.5, 1.0, 1.0 ) ), list( ctlpt( E3, 1.0, 0.0, 1.0 ), ctlpt( E3, 1.0, 0.5, 0.0 ), ctlpt( E3, 1.0, 1.0, 1.0 ) ) ) ); crv = circle( vector( 0.5, 0.5, 0.0 ), 0.4 ); comp_crv = COMPOSE( srf, crv );

composes a circle Crv to be on the surface Srf.

FIGURE: A circle in the parametric space of the freefrom surface is composed to create a closed loop curve on the surface using COMPOSE.

CON2

PolygonType CON2( VectorType Center, VectorType Direction, NumericType Radius1, NumericType Radius2, NumericType Caps )

creates a truncated CONE geometric object, defined by Center as the center of the main base of the CONE, with the Direction as both the CONE's axis and the length of CONE, and the two radii Radius1/2 of the two bases of the CONE. If Caps equals zero, no caps are created. If Caps equal one (two), only the bottom (top) cap is created. If Caps equal three, both the top and the bottom caps are created.

Unlike the regular cone (CONE) constructor which inherits discontinuities in its generated normals at the apex, CON2 can be used to form a (truncated) cone with continuous normals. See RESOLUTION for the accuracy of the CON2 approximation as a polygonal model. See also CONE. See IRITSTATE's "PrimRatSrfs" and "PrimRatSrfs" state variables.

Example:

Cone2 = CON2( vector( 0, 0, -1 ), vector( 0, 0, 4 ), 2, 1, 3 );

constructs a truncated cone with bases parallel to the XY plane at Z = -1 and Z = 3, and with radii of 2 and 1 respectively. Both caps are created.

FIGURE: A cone (left) can be constructed using the CONE constructor and a truncated cone (right) using the constructor CONE2.

CONE

PolygonType CONE( VectorType Center, VectorType Direction, NumericType Radius, NumericType Caps )

creates a CONE geometric object, defined by Center as the center of the base of the CONE, Direction as the CONE's axis and height, and Radius as the radius of the base of the CONE. If Caps equals zero, no cap is created. If Caps equal one, the bottom (top) cap is created. See RESOLUTION for accuracy of the CONE approximation as a polygonal model.

Example:

Cone1 = CONE( vector( 0, 0, 0 ), vector( 1, 1, 1 ), 1, 1 );

constructs a cone based in an XY parallel plane, centered at the origin with radius 1 and with tilted apex at ( 1, 1, 1 ). Only the bottom cap is created.

See IRITSTATE's "PrimRatSrfs" and "PrimRatSrfs" state variables. See also CON2.

CONICSEC

CurveType CONICSEC( ListType ABCDEF, NumericType ZLevel, PointType StartPoint, PointType EndPoint ) or {PolygonType | SurfaceType } CONICSEC( ListType TwoCurves, NumericType ZLevel, NumericType Dist, NumericType EvalCurve )

In the first form, this will construct a quadratic form that represents the planar conic section prescribed by the list of six coefficients ABCDEF as:

    A x^2 + B xy + C y^2 + D x + E y + F = 0,

The conic will be parallel to the XY plane at Z level of Zlevel. The section of the curve will be from StartPoint to EndPoint, or alternatively, unlimited by specifying 'off' for StartPoint and EndPoint. The conic might be rational (for circles and ellipses, for example) or intergral (for parabolas).

Alternatively, in the second form, if the first list object parameter contains two planar curves in the XY plane, a piecewise linear curve at Z level of Zlevel is computed that presents the elliptic/hyperbolic distance Dist from the given two curves. The elliptic distance refers to the sum of distance (that equal Dist) to the two curves, while hyperbolic distance refers to the difference of distances. Finally, if EvalCurve = 0, the surface whose zero set is the desired curve, is returned instead. If EvalCurve = 1, distance curves are returned in the parametric space as correspondence between the two curves' parameters. If EvalCurve = 2, the conic curves themselves are returned. Note only elliptic surfaces are compact and are reconstructed in whole.

Example:

Circ2 = CONICSEC( list( 1, 0, 1, 0, -0.5, -1 ), 0.0, point( 1.0, 0.0, 0.0 ) * ty( 0.25 ), point( -0.707, -0.707, 0.0 ) * ty( 0.25 ) ); Elp1 = CONICSEC( list( 1, 2, 4, 0.5, 2, -0.2 ), 0.0, off, off ); Prb1 = CONICSEC( list( 0.1, 0, 0, 0, 1, -1 ), 2, off, off ) * sc( 0.1 );

constructs a (portion of a) circle, an ellipse and a parabola as conic sections, and,

c1 = cbspline( 3, list( ctlpt( E2, -1, -1 ), ctlpt( E2, 1, -1 ), ctlpt( E2, 1, 1 ), ctlpt( E2, -1, 1 ) ), list( KV_OPEN ) ); c2 = -c1 * sx( -1 ) * tx( 5 ); view( list( c1, c2 ), 1 ); resolution = 15; DistCrvE = list( CONICSEC( list( c1, c2 ), 1.0, 10, 2 ), CONICSEC( list( c1, c2 ), 1.0, 9, 2 ), CONICSEC( list( c1, c2 ), 1.0, 8, 2 ), CONICSEC( list( c1, c2 ), 1.0, 7, 2 ), CONICSEC( list( c1, c2 ), 1.0, 6, 2 ) ); color( DistCrvE, green );

computes the conic distance to the two curves c1 and c2 at distances of 6, 7, 8, 9, and 10.

See also QUADRIC.

CONTOUR

PolygonType CONTOUR( SurfaceType ContouredSrf, PlaneType ContourPlane ) or PolygonType CONTOUR( SurfaceType ContouredSrf, PlaneType ContourPlane, SurfaceType MappedSrf ) or PolygonType CONTOUR( SurfaceType ContouredSrf, PlaneType ContourPlane, SurfaceType MappedSrf, ListType ValidatePt )

contours surface ContouredSrf by intersecting plane ContourPlane with a polygonal approximating ContouredSrf with resolution set via variable RESOLUTION (10 is a good starting resolution value, 20 is extreme). If ContouredSrf is a scalar field surface of type E1 or P1 and MappedSrf is provided, ContouredSrf is contoured above its parametric domain (U is X, V is Y) and the resulting parametric curve is composed with MappedSrf to yield the returned value. Further, if ValidatePt is prescribed, it should contain two elements, a vector, V, and an angle, A, in degrees. Only the contour points for which the normal of surface MappedSrf there has less than A degrees from V are returned.

Example:

resolution = 20; nglass = snrmlsrf( glass ) * vector( 1, 1, 1 ); sils = contour( nglass, plane( 1, 0, 0, 0 ), glass ); color( sils, cyan ); attrib( sils, "dwidth", 4 ); view( list( axes, glass, sils ), on );

computes the normal field of the surface glass, projects it onto the viewing direction of (1, 1, 1) and contours the resulting scalar field with the plane X = 0, to extract the silhouette curves from viewing direction (1, 1, 1).

FIGURE: Computes the silhouette of a freeform glass surface from viewing direction (1, 1, 1). On the left, the original view is seen. On the right, a different, general, view is provided.

CONVEX

PolygonType CONVEX( PolygonType Object ) or ListType CONVEX( ListType Object )

convert non-convex polygons in Object, into convex ones. New vertices are introduced into the polygonal data during this process. The Boolean operations require the input to have convex polygons only (although it may return non convex polygons...) and it automatically converts non-convex input polygons into convex ones, using this same routine.

However, some external tools (such as irit2ray and poly3d-h) require convex polygons. This function must be used on the objects to guarantee that only convex polygons are saved into data files for these external tools.

Example:

CnvxObj = CONVEX( Obj ); save( "data", CnvxObj );

converts non-convex polygons into convex ones, so that the data file can be used by external tools requiring convex polygons.

COORD

AnyType COORD( AnyType Object, NumericType Index )

extracts an element from a given Object, at index Index. From a PointType, VectorType, PlaneType, CtlPtType and MatrixType. A NumericType is returned with Index 0 for the X axis, 1 for the Y axis etc. Index 0 denotes the weight of CtlPtType. For a PolygonType that contains more than one polygon, the Indexth polygon is returned. For a PolygonType that contains a single Polygon, the Indexth vertex is returned. For a freeform object (curve, surface, etc.), the Indexth CtlPtType is returned. For a ListType, COORD behaves like NTH and returns the Indexth object in the list. For a StringType, the Indexth character is returned as its ASCII numeric code.

Example:

a = vector( 1, 2, 3 ); vector( COORD( a, 0 ), COORD( a, 1 ), COORD( a, 2 ) ); a = ctlpt( P2, 6, 7, 8, 9 ); ctlpt( P3, coord( a, 0 ), coord( a, 1 ), coord( a, 2 ), coord( a, 3 ) ); a = plane( 10, 11, 12, 13 ); plane( COORD( a, 0 ), COORD( a, 1 ), COORD( a, 2 ), COORD( a, 3 ) );

constructs a vector/ctlpt/plane and reconstructs it by extracting the constructed scalar components of the objects using COORD.

See also COERCE.

COVERISO

CurveType COVERISO( TrivarType TV, NumericType NewOfStrokes, NumericType StrokeType, PointType MinMaxPwrLen, NumericType StepSize, NumericType IsoVal, VectorType ViewDir )

computes a coverage for an iso surface of a trivariate function TV, using curves. NewOfStrokes strokes are distributed on the iso surface with a length that is set via MinMaxPwrLen. MinMaxPwrLen is a triplet of the form (Min, Max, Power) that determines the length of the strokes as,

       Avg = (Max + Min) / 2,             Dev = (Max - Min) / 2

       Length = Avg + Dev * Random(0, 1) ^ Pwr.

StepSize controls the steps size of the piecewise linear approximation formed and should typically be smaller than Min. StrokeType can be one of,

1	Draw strokes along minimal principal curvature.
2	Draw strokes along maximal principal curvature.
3	Draw strokes along both principal curvatures.
4	Draw strokes along constant X planes.
5	Draw strokes along constant Y planes.
6	Draw strokes along constant Z planes.

IsoVal controls the constant value of the iso surface level. See also ADAPISO, COVERPT, MRCHCUBE, TVLOAD. Finally, ViewDir is the direction of view, used for silhouette computation.

Example:

IsoVal = 0.12; Cover = CoverIso( ThreeCyls, 500, 1, vector( 3, 10, 1.0 ), 0.2, IsoVal );

draws 500 strokes on the iso surface of trivariate ThreeCyls at iso value IsoVal and step size of 0.2. Strokes are drawn in length of 3 to 10 along lines of curvatures of minimal curvature.

FIGURE: A uniform coverage of 500 curved strokes of an iso surface of a trivariate function, computed using COVERISO command.

COVERPT

PolygonType COVERPT( PolygonType Model, NumericType NumOfPts, VectorType ViewDir )

computes a uniform point distribution on the given polygonal Model. Approximately NumOfPts points are uniformly distributed on the model's surface, provided ViewDir is the zero vector. If ViewDir is a non zero vector, the distribution is made to be uniform from this given viewing direction. In all cases, NumOfPts is an upper bound of the the real number of distributed points, which will be in the same order.

See also ADAPISO, COVERISO, FFPTDIST.

Example:

Pts1 = CoverPt( solid1, 1000, vector( 0, 0, 0 ) ); Pts2 = CoverPt( solid1, 3000, vector( 0, 0, -1 ) );

computes two uniform distributions of 1000 and 3000 points on Solid1. Pts1 is uniform in three space, while Pts2 is viewed uniform from the -Z direction.

FIGURE: A uniform coverage of 1000 and 3000 points of a polygonal model in three space, computed using the COVERPT command. On the left, the distribution is directional, from the viewing direction, while on the right, shows a point distribution that is uniform in 3-space. Distant points are smaller, emulating point depth cueing.

CPINCLUDE

NumericType PPINCLUDE( CurveType Crv, PointType Pt )

tests if a point Pt is inside a 2D closed curve Crv. Returns TRUE if inside, FALSE otherwise.

Example:

if ( CPINCLUDE( Crv, pt ), ... );

See also PPINCLUDE.

CPOWER

CurveType CPOWER( ListType CtlPtList )

creates a polynomial/rational curve out of the provided control point list. The created curve is employing the monomial power basis. CtlPtList is a list of control points, all of which must be of type (E1-E9 P1-P9), or regular PointType defining the curve's control polygon. The curve's point type will be of a space which is the union of the spaces of all points.

Example:

c = CPOWER( list( ctlpt( E3, 0, 1, 0 ), ctlpt( E3, 1, 0, 0 ), ctlpt( E3, 0, 0, 1 ) ) ); c == coerce( coerce( c, bezier_type ), power_type );

constructs a quadratic power basis curve, coerces it to a Bezier form, coerces the Bezier form back to the power basis, and then compares the result for equality.

See also CBEZIER, CBSPLINE and SPOWER.

CRAISE

CurveType CRAISE( CurveType Curve, NumericType NewOrder )

Raise Curve to the NewOrder Order specified.

Example:

Crv = cbezier( list( ctlpt( E2, -0.7, 0.3 ), ctlpt( E2, 0.0, 1.0 ), ctlpt( E2, 0.7, 0.0 ) ) ); Crv2 = CRAISE( Crv, 5 );

raises the 90 degrees corner Bezier curve Crv to be a quadratic.

FIGURE: Raises a 90 degrees corner quadratic Bezier curve to a quintic using CRAISE. The control polygons are also shown.
See also CREDUCE, TRAISE, SRAISE, and MRAISE.

CRC2CRVTAN

ListType CRC2CRVTAN( CurveType Crv1, CurveType Crv2, NumericType Radius, NumericType Tol )

computes all circles that are bi-tangent to the given two curves Crv1 and Crv2. The circles will posses a radius of Radius. The accuracy of the computation is governed by the tolerance Tol. Returned is a list center point locations with "Params" attributes of parameter values of the tangent locations at the two curves.

Example:

Cntrs = CRC2CRVTAN( c1, c2, R, 1e-3 );

computes all the circles of radius 0.1 that are bi-tangent to the two curves c1 and c2. Tolerance of computation is 1e-3.

FIGURE: Computes all the bi-tangent circles to the given two curves via the CRC2CRVTAN function.
See also SKEL2DINT, CRV2TANS, TNSCRCR.

CREDUCE

CurveType CREDUCE( CurveType Curve, NumericType NewOrder )

reduces the Curve to the NewOrder Order specified. This function approximates the lower order curve in the infinity norm sense, minimizing the maximal deviation between the original curve Curve and the low order curve NewOrder. NewOrder will identify with Curve only if Curve was degree raised before.

Example:

Crv = cbezier( list( ctlpt( E2, -0.7, 0.3 ), ctlpt( E2, 0.0, 1.0 ), ctlpt( E2, 0.7, 0.0 ) ) ); Crv2 = CREDUCE( craise( Crv, 5 ), 3 ); Crv == Crv2;

Should restore the original quadratic order. I.e. Crv2 should identify with Crv and "Crv == Crv2;" should return TRUE.

See also CRAISE.

CREFINE

CurveType CREFINE( CurveType Curve, NumericType Replace, ListType KnotList )

provides the ability to Replace a knot vector of Curve, or refine it. KnotList is a list of knots at which to refine Curve. All knots should be contained in the parametric domain of the Curve. If the knot vector is replaced, the length of KnotList should be identical to the length of the original knot vector of the Curve. If Curve is a Bezier curve, it is automatically promoted to be a B-spline curve.

Example:

Crv2 = CREFINE( Crv, FALSE, list( 0.25, 0.5, 0.75 ) );

refines Crv and adds three new knots at 0.25, 0.5, and 0.75.

FIGURE: Refines a 90 degrees corner quadratic Bezier curve at three interior knots (the result is a B-spline curve) using CREFINE. The control polygons are also shown.
See also SREFINE, TREFINE, and MREFINE.

CREGION

CurveType CREGION( CurveType Curve, NumericType MinParam, NumericType MaxParam )

extracts a region from the Curve between MinParam and MaxParam. Both MinParam and MaxParam should be contained in the parametric domain of the Curve, except for Bezier curves when MinParam and MaxParam can be arbitrary (extrapolating if not between zero and one).

Example:

SubCrv = CREGION( Crv, 0.3, 0.6 );

extracts the region from the Crv from the parameter value 0.3 to the parameter value 0.6.

FIGURE: Extracts a sub region from a curve using CREGION.
See also SREGION, TREGION, and MREGION.

CREPARAM

CurveType CREPARAM( CurveType Curve, NumericType MinParam, NumericType MaxParam )

reparametrizes the Curve over a new domain from MinParam to MaxParam. This operation does not affect the geometry of the curve and only affine transforms its knot vector. A Bezier curve will automatically be promoted into a B-spline curve by this function.

If MinParam equals MaxParam and both equates with one of the parameterization keywords of PARAM_UNIFORM, PARAM_CENTRIP, PARAM_CHORD, or PARAM_NIELFOL, then that parametrization is approximated for the curve, by changing the knot sequence. Note this last operation affects the geometry of the curve.

Example:

arc1 = arc( vector( 0.0, 0.0, 0.0 ), vector( 0.5, 2.0, 0.0 ), vector( 1.0, 0.0, 0.0 ) ); crv1 = arc( vector( 1.0, 0.0, 0.75 ), vector( 0.75, 0.0, 0.7 ), vector( 0.5, 0.0, 0.85 ) ) + arc( vector( 0.5, 0.0, 0.75 ), vector( 0.75, 0.0, 0.8 ), vector( 1.0, 0.0, 0.65 ) ); arc1 = CREPARAM( arc1, 0, 10 ); crv1 = CREPARAM( crv1, 0, 10 );

sets the domain of the given two curves to be from zero to ten. The Bezier curve arc1 is promoted to a B-spline curve. See also SREPARAM, TREPARAM, and MREPARAM.

CROSSEC

PolygonType CROSSEC( PolygonType Object )

This feature is NOT implemented.

CRV2TANS

ListType CRV2TANS( CurveType Crv, NumericType FineNess )

computes all the bi-tangents of Crv, in the XY plane. That is, all lines that are tangent to Crv at two different locations. A list of points with X and Y coefficients representing the parametric locations on Crv of the bi-tangent is returned. FineNess controls the numerical accuracy of the computation. A value of 10 will provide a good start and the larger this number is, the better the accuracy will be. See also CRVPTTAN and CNVXHULL.

Example:

Tans = nil(); Crv2Tns = Crv2Tans( Crv, 10 ); for ( i = 1, 1, sizeof( Crv2Tns ), pt = nth( Crv2Tns, i ): snoc( ceval( Crv, coord( pt, 0 ) ) + ceval( Crv, coord( pt, 1 ) ), Tans ) );

finds the bi-tangents of Crv and converts them to a set of line segments.

FIGURE: Computes the bi-tangents of a freeform curve, using CRV2TANS.
See also CRC2CRVTAN, TNSCRCR

CRVKERNEL

AnyType CRVKERNEL( CurveType Crv, NumericType Gamma, NumericType Euclid, AnyType Fineness, NumericType Mode )

computes the (gamma) kernel of a given planar curve Crv. If Gamma is zero, regular kernel is computed. Else, the gamma curves of Gamma degrees is being computed. If Euclid is TRUE then the result is returned in the Euclidean space, or if zero, in the parametric space. Mode can be 0 for a (gamma) kernel solution, 1 to extract silhouette sampling only out of the trivariate function, and 2 for the gamma kernel surface/trivariate functions themselves to be returned. Fineness controls the refinement that is applied to the numeric solution. For Mode 0 it sets the number of knots to insert into the (x, y, t) trivariate function. In Mode 2, it lists two numeric values, the subdivision and numeric tolerances, of the silhouette extraction process (See MZERO for their meaning). In Mode 2, it controls the extent of the surfaces/trivariates.

Example:

Krnl = CrvKernel( Crv, 0, 0, list( 2, 3, 1 ), 0 );

computes the regular kernel of curve Crv with a refinement of (2, 3, 1) in the three (x, y, t) axes of the computed trivariate function.

CRVLNDST

NumericType CRVLNDST( CurveType Crv, PointType PtOnLine, VectorType LnDir, NumericType IsMinDist, NumericType Epsilon ) or ListType CRVLNDST( CurveType Crv, PointType PtOnLine, VectorType LnDir, NumericType IsMinDist, NumericType Epsilon )

compute the closest (if IsMinDist is TRUE, farthest if FALSE) point on the Curve to the line specified by PtOnLine and LnDir as a point on the line and a line direction. Since this operation is partially numeric, Epsilon is used to set the needed accuracy. It returns the parameter value of the location on Crv closest to the line. If, however, Epsilon is negative, -Epsilon is used instead, and all local extrema in the distance function are returned as a list (both minima and maxima). If the line and the curve intersect, the point of intersection is returned as the minimum.

Example:

Param = CRVLNDST( Crv, linePt, lineVec, TRUE, 0.001 );

finds the closest point on Crv to the line defined by linePt and lineVec.

FIGURE: Computes the locations on the freeform curve with local extreme distance to the given line, using CRVLNDST.

CRVPTDST

NumericType CRVPTDST( CurveType Crv, PointType Point, NumericType IsMinDist, NumericType Epsilon ) or ListType CRVPTDST( CurveType Crv, PointType Point, NumericType IsMinDist, NumericType Epsilon )

compute the closest (if IsMinDist is TRUE, farthest if FALSE) point on Crv to Point. Since this operation is partially numeric, Epsilon is used to set the needed accuracy. It returns the parameter value of the location on Crv closest to Point. If, however, Epsilon is negative, -Epsilon is used instead, and all local extrema in the distance function are returned as a list (both minima and maxima).

Example:

Param = CRVPTDST( Crv, Pt, FALSE, 0.0001 );

finds the farthest point on Crv from point Pt.

FIGURE: Computes the locations on the freeform curve with local extreme distance to the given point, using CRVPTDST.

CRVPTTAN

ListType CRVPTTAN( CurveType Crv, PointType Pt, NumericType FineNess )

computes all the tangents to Crv that go through point Pt, all in the XY plane. A list of points with X and Y coefficients representing the parametric locations on Crv of the bi-tangent is returned. FineNess controls the numerical accuracy of the computation. A value of 0.01 will provide a good start, and the smaller this number is, the better the accuracy will be. See also CRV2TANS and CNVXHULL.

Example:

Tans = nil(); Pt = point( 2, 0, 0 ); CrvPtTns = CrvPtTan( Crv, Pt, 0.01 ); for ( i = 1, 1, sizeof( CrvPtTns ), snoc( ceval( Crv, nth( CrvPtTns, i ) ) + coerce( Pt, e3 ), Tans ) );

finds the tangents of Crv through Pt and converts them to a set of line segments.

FIGURE: Computes the tangents of a freeform curve through a point, using CRVPTTAN.

CSPIRAL

CurveType CSPIRAL( NumericType NumLoops, NumericType Pitch, NumericType Samples, NumericType CtlPtsPerLoop )

constructs a polynomial approximation of a spiral planar curve of NumLoops loops and specified Pitch. The curve is approximated as a least sqaures fit of Samples samples and CtlPtsPerLoop control points per loop.

Example:

Spiral = cspiral( 5, 0.7, 500, 6 );

See figure for this spiral of 5 loops.

FIGURE: Approximates a spiral curve using CSPIRAL.

CSURFACE

CurveType CSURFACE( SurfaceType Srf, ConstantType Direction, NumericType Param ) or CurveType CSURFACE( TriSrfType Srf, ConstantType Direction, NumericType Param )

extract an isoparametric curve out of Srf in the specified Direction (ROW or COL (or DEPTH for triangular surface) at the specified parameter value Param. Param must be contained in the parametric domain of Srf in Direction direction. The returned curve is in the surface Srf.

Example:

Crv = CSURFACE( Srf, COL, 0.45 );

extracts an isoparametric curve in the COLumn direction at the parameter value of 0.15 from surface Srf. See also CMESH, COMPOSE, STRIVAR, MFROMMV.

FIGURE: Extracts an isoparametric curve from the given surface, using CSURFACE.

CTANGENT

VectorType CTANGENT( CurveType Curve, NumericType Param, NumericType Normalize )

computes the tangent vector to the Curve at the parameter value Param. The returned vector will have a unit length, if Normalize is TRUE.

Example:

Tang = CTANGENT( Crv, 0.5, true );

computes the unit tangent vector to Crv at the parameter value of 0.5. See also CNORMAL, CNRMLCRV.

CTLPT

CPt = CTLPT( ConstantType PtType, NumericType Coord1, ... )

constructs a single control point to be used in the construction of curves and surfaces. Points can have from one to five dimensions, and may be either Euclidean or Projective (rational). Point type is set via the constants E1 to E9 and P1 to P9. The coordinates of the point are specified in order; weight is first if rational.

Examples:

CPt1 = CTLPT( E3, 0.0, 0.0, 0.0 ); CPt2 = CTLPT( P2, 0.707, 0.707, 0.707 );

constructs an E3 point at the origin and a P2 rational point with a weight of 0.707. The Projective Pi points are specified as CTLPT(Pn, W, W X1, ... , W Xn).

CTRIMSRF

ListType CTRIMSRF( TrimSrfType TSrf, NumericType Parametric )

extracts the trimming curves of a trimmed surface TSrf. If Parametric is not zero, then the trimming curves are extracted as parametric space curves of TSrf. Otherwise, the trimming curves are evaluated into Euclidean space as curves on the surface TSrf.

Example:

TrimCrvs = CTRIMSRF( TrimSrf, FALSE );

extracts the trimming curves of TrimSrf as Euclidean curves on TrimSrf.

FIGURE: Extracts the trimming curves in Euclidean space (middle) and parametric space (right) of a trimmed surface (left), using CTRIMSRF.

CUBICCRVS

ListType CUBICCRVS( CurveType Crv, NumericType Tolerance, NumericType MaxLen )

approximates given curve Crv using piecewise cubic curves upto the prescribed tolerance Tolerance. If MaxLen is positive it is used to limit the arc length of the cubic curves' segments.

Example:

PCubicCrvs = CUBICCRVS( Crv, 0.01, 0.5 );

creates a piecewise cubic approximation to curve Crv upto tolerance 0.01 and maximal arc length of cubic segments of 0.5. See also QUADCRVS, CBIARCS.

CVIEWMAP

PolygonType CVIEWMAP( CurveType Crv, CurveType ViewCrv, NumericType SubdivTol, NumericType NumerTol, NumericType TrimInvisible )

computes algebraic constraints that reflects the visible domain of planar curve Crv as seen from direction prescribed by planar vector curve ViewCrv. ViewCrv is typically a unit circle curve, parametrizing all possible (360 degrees) planar views. See MZERO for the meaning of the SubdivTol and NumerTol tolerances. If TrimInvisible is FALSE, the return set prescribes the 2D silhouette locations on Crv from the specific view direction. If TrimInvisible is TRUE, attempt ismade to remove the invisile portions. Result is returned as 3D polylines, in (t, v, r) space where t and r parametrize Crv and v parametrizes ViewCrv. This, since a silhouette point Crv(t) could hide a independent curve location Crv(r).

Example:

ViewMap = CVIEWMAP( Crv, pcircle( vector( 0, 0, 0 ), 1 ), 0.1, 1e-6, 0 );

See also CANGLEMAP, CVISIBLE, CARRANGMNT.

CVISIBLE

PolygonType CVIVISIBLE( CurveType Crv, PointType Pt, NumericType Eps ) or PolygonType CVIVISIBLE( CurveType Crv, VectorType Dir, NumericType Eps )

computes the visible regions of planar curve Crv as seen from either view point Pt or from view direction Dir. Eps controls the accuracy of the computation. Dir must have its Z components zero, whereas Pt's Z coefficient must be one.

Example:

Crvs = CVISIBLE( c, Pt, 1e-5 );

See figure for a example.

FIGURE: The visibility of the given curve on the left is sampled along its 360 degrees to create a visibility atlas of the curve on the right, using CVISIBLE. Then SETCOVER is used to find the minimal set that can see the entire curve, esselntially solving the so-called art-gallery problem.
See also CANGLEMAP, CVIEWMAP, CARRANGMNT, SETCOVER.

CYLIN

PolygonType CYLIN( VectorType Center, VectorType Direction, NumericType Radius, NumericType Caps )

creates a CYLINder geometric object, defined by Center as the center of the base of the CYLINder, Direction as the CYLINder's axis and height, and Radius as the radius of the base of the CYLINder. If Caps equals zero, no caps are created. If Caps equal one (two), only the bottom (top) cap is created. If Caps equal three, both the top and the bottom caps are created.

See RESOLUTION for the accuracy of the CYLINder approximation as a polygonal model. See IRITSTATE's "PrimRatSrfs" and "PrimRatSrfs" state variables.

Example:

Cylinder1 = CYLIN( vector( 0, 0, 0 ), vector( 1, 0, 0 ), 10, 3 );

constructs a cylinder with two caps of radius 10 along the X axis from the origin to X = 1.

FIGURE: A cylinder primitive can be constructed using the CYLIN constructor.

CZEROS

ListType CZEROS( CurveType Crv, NumericType Epsilon, NumericType Axis )

computes the zero set of the given Crv in the given axis (1 for X, 2 for Y, 3 for Z). Since this computation is numeric, an Epsilon is also required to specify the desired tolerance. It returns a list of all the parameter values (NumericType) the curve is zero.

Example:

xzeros = CZEROS( cb, 0.001, 1 ); pt_xzeros = nil(); pt = nil(); for ( i = 1, 1, sizeof( xzeros ), pt = ceval( cb, nth( xzeros, i ) ): snoc( pt, pt_xzeros ) ); interact( list( axes, cb, pt_xzeros ), 0 );

computes the X zero set of curve cb with error tolerance of 0.001. This set is then scanned in a loop and evaluated to the curve's locations, which are then displayed. See also CINFLECT.

FIGURE: Computes the zero set of a given freeform curve, in the given axis, using CZEROS.

DIST2FF

SurfaceType DIST2FF( CurveType Crv1, CurveType Crv2, NumericType DistType ) or MultivarType DIST2FF( CurveType Crv1, SurfaceType Srf2, NumericType DistType ) or MultivarType DIST2FF( SurfaceType Srf1, SurfaceType Srf2, NumericType DistType )

computes the distance function between the two given freeform shapes. The returned variety is bi-variate, tri-variate, or a four-variate, depending on the dimensionality of the input, in order. Based on DistType, the following distance functions could be used:

DistType Value	Description
0	Computes the distance vector function, (V1 - V2).
1	Computes the distance square function, (V1 - V2)^2.
2	Projection of the distance vector onto the normal
	field of the first varietly, < V1 - V2, N1 >.
3	Projection of the distance vector onto the normal
	field of the second varietly, < V1 - V2, N2 >.

In cases 2 and 3, the normal field is not a unit field.

Example:

Crv1 = cbezier( list( ctlpt( E1, .2 ), ctlpt( E2, 0.5, 4 ), ctlpt( E2, 1.3, 0.05 ) ) ) * sy( 0.2 ); Crv2 = cbezier( list( ctlpt( E1, -.2 ), ctlpt( E2, 0.25, 1.9 ), ctlpt( E2, 1.3, 0.05 ) ) ) * ty( 0.3 ) * sx( 1.5 ); bb = bbox( dist2ff( Crv1, Crv2, 1 ) );

computes a bound on the minimal and maximal distance square between the given two curves, by computing a bounding box on this scalar distance square field.

DUALITY

CurveType DUALITY( CurveType Curve ) or SurfaceType DUALITY( SurfaceType Srf )

computes the dual curve/surface to the given curve/surface. The dual shape is a mapping of every point to a line (plane) in R2 (R3).

Example:

Ellipsoid = sphereSrf( 1.1 ) * sx( 2 ) * sy( 1.2 ); DualEllip = DUALITY( Ellipsoid );

FIGURE: Two examples of a dual curve (left) and a dual surface (right) computed using the DUALITY function. The duals are shown in thin black color.

ELLIPSE3PT

ListType ELLIPSE3PT( PointType Pt1, PointType Pt2, PointType Pt3, NumericType Offset )

computes the 6 coefficients A-F of,

    Ax^2 + Bxy + Cy^2 + Dx + Ey + F = 0,

defining the ellipse of minimal area that bounds these 3 points Pti. computation is conducted in the XY plane, with Z ignored. If Offset is not zero, the ellipse is offset approximated by Offset amount.

Example:

Pt1 = point( random( -0.5, 0.5 ), random( -0.5, 0.5 ), 0 ); Pt2 = point( random( -0.5, 0.5 ), random( -0.5, 0.5 ), 0 ); Pt3 = point( random( -0.5, 0.5 ), random( -0.5, 0.5 ), 0 ); EllImp = ELLIPSE3PT( Pt1, Pt2, Pt3, 0 ); Ell = ConicSec( EllImp, 0, off, off ); color( Ell, yellow ); adwidth( Ell, 2 );

creates three random points in the XY plane and compute the implicit minimal area ellipse for these three points. the Ellipse is realized geometrically using the ConicSec function. See also CONICSEC, IMPLCTTRANS, QUADRIC, MAP3PT2EQL.

EVOLUTE

CurveType EVOLUTE( CurveType Curve ) or SurfaceType EVOLUTE( SurfaceType Srf )

compute the evolute of a curve or a surface. For curves, the evolute is defined as,

              N(t)

E(t) = C(t) + ----

              k(t)

where N(t) is the unit normal of C(t), and k(t) is its curvature.

E(t) is computed symbolically as the symbolic sum of C(t) and

N(t) / k(t).

For surfaces, this function computes the mean evolute which is equal to,

                     n(u, v)

E(u, v) = S(u, v) + ---------

                    2 H(u, v)

where n(u, v) is the unit normal of S(u, v), and H(u, v) is its mean

curvature. E(u, v) is computed symbolically.

The result of this symbolic computation is exact (upto machine precision), unlike similar operations such as OFFSET or AOFFSET, that are only approximated.

Example:

crv = cbspline( 3, list( ctlpt( E3, -1.0, 0.1, 0.2 ), ctlpt( E3, -0.1, 1.0, 0.1 ), ctlpt( E3, 0.1, 0.1, 1.0 ), ctlpt( E3, 1.0, 0.1, 0.1 ), ctlpt( E3, 0.1, 1.0, 0.2 ) ), list( KV_OPEN ) ); cev = EVOLUTE( Crv );

FIGURE: The evolute (thick) of a freeform curve (thin) can be computed using EVOLUTE.
See also SMEAN.

EXTRUDE

PolygonType EXTRUDE( PolygonType Object, VectorType Dir, NumericType Caps ) or SurfaceType EXTRUDE( CurveType Object, VectorType Dir, NumericType Caps ) or TrivarType EXTRUDE( SurfaceType Object, VectorType Dir, NumericType Caps )

create an extrusion of the given Object. If the Object is a PolygonObject, its first polygon is used as the base for the extrusion in Dir direction. If the Object is a CurveType, an extrusion surface is constructed. If the Object is a SurfaceType, an extrusion trivariate is constructed. If Caps equals zero, no caps are created. If Caps equal one (two), only the bottom (top) cap is created. If Caps equal three, both the top and the bottom caps are created. Note that caps are created for a closed Object only, so the Object must be either a polygon or a closed curve for caps to be generated. Direction Dir cannot be coplanar with the polygon plane. The curve may be nonplanar.

Example:

Cross = cbspline( 3, list( ctlpt( E2, -0.018, 0.001 ), ctlpt( E2, 0.018, 0.001 ), ctlpt( E2, 0.019, 0.002 ), ctlpt( E2, 0.018, 0.004 ), ctlpt( E2, -0.018, 0.004 ), ctlpt( E2, -0.019, 0.001 ) ), list( KV_OPEN ) ); Cross = Cross + -Cross * scale( vector( 1, -1, 1 ) ); Napkin = EXTRUDE( Cross * scale( vector( 1.6, 1.6, 1.6 ) ), vector( 0.02, 0.03, 0.2 ), 0 );

constructs a closed cross section Cross by duplicating one half of it in reverse and merging the two sub-curves. Cross is then used as the cross section for the extrusion operation.

FIGURE: An extrusion of a freeform curve using EXTRUDE to create a freeform surface.

FFCMPCRV

FFCMPCRV( CurveType Crv1, CurveType Crv2, NumericType Tolerance )

compares the given two curves, Crv1 and Crv2 for an identical trace. Curves could have identical trace while with different degrees (via degree raising of one of them), differet knot sequences (by applying refinements to either curves or both), or even different speed (via composition). This function reduces both curves to a canonical representation by reverse engineering unnecessary degree raising, refinements, or composition and then compare the two curves upto the given tolerance Tolerance. Returned is a list of 5 numeric values. The first number equals 1 if the curves are the same, 2 if the are the same but domain is not exactly the same, or 3 f the curves are different. The other four numbers in the list are the domains of the two given curves that overlap as (Start1, End1, Start2, End2).

Example:

Similarity = FFCMPCRV( Crv1, Crv2, 1e-6 );

FFCOMPAT

FFCOMPAT( CurveType Crv1, CurveType Crv2 ) or FFCOMPAT( SurfaceType Srf1, SurfaceType Srf2 )

make the given two curves or surfaces compatible by making them share the same point type, the same curve type, the same degree, and the same continuity. The same point type is gained by promoting a lower dimension into a higher one, and non-rational to rational points. Bezier curves are promoted to B-spline curves if necessary, for curve type compatibility. Degree compatibility is achieved by raising the degree of the lower order curve. Continuity is achieved by refining both curves to the space with the same (unioned) knot vector. This function returns nothing and compatibility is made in place}.

Example:

FFCOMPAT( Srf1, Srf2 );

See also CMORPH and SMORPH.

FFCTLPTS

ListType FFCTLPTS( FreeformType Freeform );

returns all the control points of the given Freeform in a single list. See Also FFPTTYPE, FFGTYPE, FFKNTVEC, FFMSIZE, FFORDER.

Example:

Ctls = FFCTLPTS( Srf1 );

FFEXTREME

CtlPtType FFEXTREME( CurveType Crv, NumericType Minimum ) or CtlPtType FFEXTREME( SurfaceType Srf, NumericType Minimum )

compute a bound on the extreme values a curves Crv or surface Srf can assume. Returned control points provide a bound on the minimum (maximum) values that can be assumed if Minimum is TRUE (FALSE).

Example:

Bound = FFEXTREME( Srf, false );

computes a bound on the maximal values Srf can assume.

FFGTYPE

NumericType FFGTYPE( FreeformType Freeform )

returns the geometric type (BEZIER_TYPE, BSPLINE_TYPE etc.) of the given freeform. See Also FFGTYPE, FFCTLPTS, FFKNTVEC, FFMSIZE, FFORDER, PDOMAIN.

FFKNTVEC

ListType FFKNTVEC( FreeformType Freeform )

returns all the knot vector(s) of the given Freeform in a list of knot vector(s). See Also FFPTTYPE, FFGTYPE, FFCTLPTS, FFMSIZE, FFORDER.

Example:

KVs = FFKNTVEC( Srf1 );

FFMATCH

FFMATCH( CurveType Crv1, CurveType Crv2, NumericType Reduce, NumericType Samples, NumericType ReparamOrder, NumericType Rotate, NumericType NormType )

computes a reparametrization to Crv2 so it fits Crv1, the best under some prescribed norm, NormType. Currently the following norms are valid for NormType

Value	Description
1	Suitable for ruled and blended curves, for modeling.
	See RULEDSRF.
2	Suitable for metamorphosis of curves. See CMORPH.
3	Distance norm in "walking the dog" notion.
4	Bisector (skeleton) matching norm for two curves.

Whenever negative norms can result (for example, in cases were self intersection cannot be prevented in ruled surface constructions), one can allow negativity with no extra penalty by applying negative NormType. Use of positive-only norms would yield no output at all if no matching with positive weights can be established, whereas allowing negative norm values would result in a globally optimal result, but with possible self intersectiions.

The reparametrization is computed by sampling a fixed set of size Samples off both curves, and fitting a B-spline curve of length Reduce as the reparametrization curve. Hence, Reduce must be less than or equal to Samples. The reparametrization curve will have order of ReparamOrder. If Rotate is TRUE or ON, then attempt is made to rotate the reparametrization of the curves. Rotation can be used on closed curves only.

See RULEDSRF and CMORPH for examples.

FFMERGE

CurveType FFMERGE( ListType E1Curves, NumericType PointType ) or SurfaceType FFMERGE( ListType E1Surfaces, NumericType PointType ) or MultivarType FFMERGE( ListType E1Multivars, NumericType PointType )

merge the scalar curves/surfaces/multivariates in the list of curves E1Curves or list of surfaces E1Surfaces or list of multivariates E1Multivars to one vector curve/surface/multivariate of point type PointType.

Example:

Srf = FFMERGE( list( SrfW, SrfX, SrfY ), P2 );

merges three scalar surfaces into a single surface with point type P2. See also FFSPLIT.

FFMESH

ListType FFMESH( FreeformType Freeform )

returns the control mesh/polygon of the given Freeform in a list. See Also FFCTLPTS, FFKNTVEC, FFORDER, FFPTTYPE, FFMSIZE.

Example:

SrfMesh = FFMESH( Srf );

FFMSIZE

ListType FFMSIZE( FreeformType Freeform )

returns the size of the control mesh/polygon of the given freeform in a list. See Also MESHSIZE, FFMESH, FFPTTYPE, FFGTYPE, FFCTLPTS, FFKNTVEC, FFORDER, PDOMAIN.

Example:

MSizes = FFMSIZE( Srf1 );

FFORDER

ListType FFORDER( FreeformType Freeform )

returns all the orders of the given Freeform in a single list. See Also FFPTTYPE, FFGTYPE, FFCTLPTS, FFKNTVEC, FFMSIZE, PDOMAIN.

Example:

Orders = FFORDER( Srf1 );

FFPOLES

NumericType FFPOLES( FreeformType Freeform );

returns TRUE if the given Freeform has poles, FALSE otherwise. Poles are zeros in the weights of rational functions.

Example:

HasPoles = FFPOLES( Srf1 );

FFPTDIST

ListType FFPTDIST( CurveType Crv, NumericType Param, NumericType NumOfPts ) or ListType FFPTDIST( SurfaceType Srf, NumericType Param, NumericType NumOfPts )

compute a uniform point distribution for Crv or Srf. If Param is FALSE, the distribution is selected to be uniform in the Euclidean space; otherwise if TRUE, the distribution is made uniform in the parametric space. NumOfPts sets the number of points in the distribution.

The returned list of points prescribes parameter values in the freeforms. For Crv, the returned list is a list of reals, in the parameter space of Crv. For Srf, the returned list is a list of points, whose X and Y coefficients hold the U and V parameters of Srf. See also COVERPT.

Example:

c1 = cbezier( list( ctlpt( E2, -1.0, 0.0 ), ctlpt( E2, -1.0, 0.1 ), ctlpt( E2, -0.9, -0.1 ), ctlpt( E2, 0.9, 0.0 ) ) ); color( c1, magenta ); pts = FFPTDIST( c1, true, 300 ); e2pts = nil(); for ( i = 1, 10, sizeof( pts ), pt = ceval( c1, coord( nth( pts, i ), 0 ) ): snoc( pt, e2pts ) ); interact( list( e2pts, c1 ) ); pts = FFPTDIST( c1, false, 300 ); e2pts = nil(); for ( i = 1, 10, sizeof( pts ), pt = ceval( c1, coord( nth( pts, i ), 0 ) ): snoc( pt, e2pts ) ); interact( list( e2pts, c1 ) );

computes the distribution of 100 points in curve c1 which has highly nonuniform speed characteristics. Two distributions are computed, one to be uniform in the parametric space and one to be uniform in the Euclidean space.

FIGURE: (top) A distribution of 30 points uniformly in Euclidean space. (bottom) A distribution of 30 points uniformly in parameteric space. Both examples were computed using FFPTDIST.

FFPTTYPE

NumericType FFPTTYPE( FreeformType Freeform )

returns the point type (E2, P4 etc.) of the given freeform. See Also FFGTYPE, FFCTLPTS, FFKNTVEC, FFMSIZE, FFORDER, PDOMAIN.

FFSPLIT

ListType FFSPLIT( CurveType Crv ) or ListType FFSPLIT( SurfaceType Srf ) or ListType FFSPLIT( MultivarType MV )

split the given curve Crv or surface Srf or multivariate MV into its scalar components that are returned as a list of scalar curves/surfaces/multivariates.

Example:

E1Srfs = FFSPLIT( circle( vector( 0, 0, 0 ), 1 ) );

splits the circle which is a curve in P3 into four scalar curves (W, X, Y, Z) that are returned in a single list. See also FFMERGE, FFPTTYPE.

FITPMODEL

ListType FITPMODEL( PolygonType PlObj, NumericType FitType, NumericType Tol, NumericType NumIters )

fits a primitive object to the given polygonal model, PlObj. The numeric fitting process is controled via a bound on the number of iterations NumIters and the resulting tolerance of the fit that is required, Tol. Returned is a list of numeric values with the error of the fit as the first value. The rest of the list numeric values are the coefficients of the algebraic fitted form (see table below). FitType can be one of:

0	A Planar face. Returned list holds (A, B, C, D), the four
	coefficients of the plane equation.
1	A Sphere. Returned list holds (Xcntr, Ycntr, Zcntr, Radius)
	of the fitted sphere.
2	A Cylinder. Returned list holds (Xcntr, Ycntr, Zcntr,
	Xdir, Ydir, Zdir, Radius) of the fitted cylinder.
3	A Circle. Returned list holds (Xcntr, Ycntr, Radius) of
	the fitted circle.
4	A Cone. Returned list holds (Xcntr, Ycntr, Zcntr,
	Xdir, Ydir, Zdir, Radius) of the fitted cone.

Example:

resolution = 20; x1 = triangl( sphere( vector( 1, 2, 3 ), 4 ), 1 ); SprParams = FitPModel( x1, 1, 0.01, 100 );

Computes a fitted sphere to a polygonal approximation of a sphere. See also ANALYFIT.

FIXPLGEOM

PolygonType FIXPLGEOM( PolygonType PlObj, NumericType Oper, NumericType Eps ) or ListType FIXPLGEOM( ListType Obj, NumericType Oper, NumericType Eps )

cleans polygonal geometry. based on Oper, the following will be conducted:

0	Remove identical duplicated polygons.
1	Remove zero length edges.

The clean up of an object will be applied individually to each part found in the object list Obj.

Example:

Obj2 = FIXPLGEOM( Obj, 0 ); Obj3 = FIXPLGEOM( Obj2, 1 ); Obj4 = FIXPLNRML( Obj3, 2 );

cleans duplicated polygons, zero length edges, and then reorient the result. See also FIXPLNRML.

FIXPLNRML

PolygonType FIXPLNRML( PolygonType PlObj, NumericType TrustInfo ) or ListType FIXPLNRML( ListType Obj, NumericType TrustInfo )

corrects inconsistencies in polygonal geometry, between normals of polygons and normals at the vertices based on TrustInfo. If TrustInfo is

0	Trust the normals at the vertices.
1	Trust the normals of the polygons.
2	Reorient all the polygon's normals and vertices
	normals to follow the orientation of first polygon.
3	Same as 2 but splits disjoints part in the input to
	different objects.

The computation on an object will be applied individually to each part found in the object list Obj. Option 2 of TrustInfo will correct cases where adjacent polygons are not oriented the same, based on detection of adjacencies.

Example:

Obj2 = FIXPLNRML( Obj, 2 );

See also FIXPLGEOM and SMOOTHNRML.

GBOX

PolygonType GBOX( VectorType Point, VectorType Dx, VectorType Dy, VectorType Dz )

creates a parallelepiped - generalized BOX polygonal object, defined by Point as its base position, and Dx, Dy, Dz as 3 3D vectors to define the 6 faces of this generalized BOX. The regular BOX object is a special case of GBOX where Dx = vector(Dx, 0, 0), Dy = vector(0, Dy, 0), and Dz = vector(0, 0, Dz).

Dx, Dy, Dz must all be independent in order to create an object with positive volume.

Example:

GB = GBOX( vector( 0.0, -0.35, 0.63 ), vector( 0.5, 0.0, 0.5 ), vector( -0.5, 0.0, 0.5 ), vector( 0.0, 0.7, 0.0 ) );

FIGURE: A warped box in a general position can be constructed using the GBOX constructor.

GETATTR

AnyType GETATTR( AnyType Obj, StringType Name )

provides a mechanism to fetch an attribute named Name from object Obj.

Example:

attrib( axes, "test", 15 ); a = GETATTR( axes, "test" );

will set the value of a to be 15.

GETLINE

AnyType GETLINE( NumericType RequestedType )

provides a method to get input from the keyboard within functions and or subroutines. RequestedType can be a NUMERIC_TYPE, POINT_TYPE, VECTOR_TYPE, or PLANE_TYPE in which the entered line will be parsed into one, three, or four numeric values (operated by either spaces or commas) and the proper object will be created and returned. In any other case, including failure to parse the numeric input, a STRING_TYPE object will be constructed from the entered line.

Example:

Pt = GETLINE( point_type );

to read one point (three numeric values) from stdin.

GETNAME

StringType GETNAME( ListType ListObj, NumericType Index )

gets the name of a sub object of index Index in list object ListObj. Index of the first element is one.

Example:

A = list( XX, Second, C ); GETNAME( A, 1 );

returns the name of the second element, "Second".

See also SETNAME.

GGINTER

ListType GGINTER( CurveType Srf1Axis, CurveType Srf1Rad, CurveType Srf2Aixs, CurveType Srf2Rad, NumericType Tolerance, NumericType ZeroSetFunc )

computes the intersection curves of the given two ring surfaces, defined as spine surfaces with axis SrfiAxis, i = 1, 2 and circular cross section along the normal plane of the axis curve with radii SrfiRad.

The ring ring intersection (RRI) problem is tranformed into a zero set finding on another function. If ZeroSetFunc is true, the function whose zero set provides the RRIsolution is returned. Otherwise, if ZeroSetFunc is false, the RRI solution itself is returned. The zero set is computed via numerical zero set finding methods and Tolerance controls the fineness of the approximated solution.

FIGURE: Computation of the intersection curve between two ring surfaces via the GGINTER command. On the left, the zero set function is displayed while on the right, the computed intersection between two ocylinders is shown.

Example:

s1 = cylinSrf( 4, 1 ) * tz( -2 ); c1 = cbezier( list( ctlpt( E3, 0.0, 0.0, -1.0 ), ctlpt( E3, 0.0, 0.0, 1.0 ) ) ); r1 = cbezier( list( ctlpt( E1, 1.0 ) ) ); s2 = cylinSrf( 4, 1 ) * tz( -2 ) * rx( 90 ) * tx( 0.5 ); c2 = cbezier( list( ctlpt( E3, 0.5, -1.0, 0.0 ), ctlpt( E3, 0.5, 1.0, 0.0 ) ) ); r2 = cbezier( list( ctlpt( E1, 1.0 ) ) ); ZeroSetSrf = coerce( GGINTER( c1, r1, c2, r2, 10, true ), e3 ) * rotx( -90 ) * roty( -90 ); resolution = 100; ZeroSet = contour( ZeroSetSrf, plane( 0, 0, 1, 0 ) ); interact( list( ZeroSetSrf * sz( 0.1 ), ZeroSet, axes ) ); c = nth( GGINTER( c1, r1, c2, r2, 100, false ), 1 ); interact( list( s1, s2, c ) );

constructs two cylinders as s1 and s2, defines the same two cylinders as a ring surface with axes spines of c1 and c2 and a constant radius, one in r1 and r2, and computes the zero set of the intersection and the intersection curve itself. See also RRINTER, SSINTER and SSINTR2.

GPOLYGON

PolygonType GPOLYGON( GeometryTreeType Object, NumericType Normals )

approximates all Surface(s)/Trimmed surface(s)/Trivariate(s) in Object with polygons using the POLY_APPROX_OPT, POLY_APPROX_TRI, POLY_MERGE_COPLANAR, RESOLUTION and FLAT4PLY variables. If POLY_APPROX_OPT is FALSE, RESOLUTION vaguely prescribes the number of uniform (in parametric space) samples to sample the surface in each direction. If POLY_APPROX_OPT is TRUE, POLY_APPROX_TOL prescribes the maximal deviation of the polygonal approximation from the original surface, in object space coordinates. IF POLY_APPROX_TRI is TRUE, only triangles are generated on the output set. POLY_MERGE_COPLANAR controls the way coplanar adjacent polygons are merged into one (or not.) FLAT4PLY is a Boolean flag controlling the conversion of an (almost) flat patch into four (TRUE) or two (FALSE) polygons. Normals are computed to polygon vertices using surface normals, so Gouraud or Phong shading can be exploited. It returns a single polygonal object.

If Normals is set, surface normals will be evaluated at the vertices. Otherwise flat shading and constant normals across polygons are assumed.

Example:

Polys = GPOLYGON( list( Srf1, Srf2, Srf3 ), off );

converts to polygons the three surfaces Srf1, Srf2, and Srf3 with no normals. See also POLY_APPROX_OPT, POLY_APPROX_TOL, POLY_APPROX_TRI, POLY_APPROX_UV, POLY_MERGE_COPLANAR, RESOLUTION and FLAT4PLY.

GPOLYLINE

PolylineType GPOLYLINE( GeometryTreeType Object, NumericType Optimal )

converts all Curves(s), (Trimmed) Surface(s), and Trivariate(s) Object into polylines using the RESOLUTION variable. The larger the RESOLUTION is, the finer the resulting approximation will be. It returns a single polyline object.

If Optimal is false, the points are sampled at equally spaced intervals in the parametric space. If Optimal true, a better, more expensive computationally algorithm is used to derive optimal sampling locations so as to minimize the maximal distance between the curve and piecewise linear approximation (L infinity norm).

Example:

Polys = GPOLYLINE( list( Srf1, Srf2, Srf3, list( Crv1, Crv2, Crv3 ) ), on );

converts to polylines the three surfaces Srf1, Srf2, and Srf3 and the three curves Crv1, Crv2, and Crv3.

HAUSDORFF

ListType HAUSDORFF( PointType Obj1, CurveType Obj2, NumericType Eps, NumericType OneSided ) or ListType HAUSDORFF( CurveType Obj1, CurveType Obj2, NumericType Eps, NumericType OneSided )

computes the Hausdorff distance between Obj1 and Obj2, with Eps as the tolerance of the computation. Note obj1 or Obj2 can be either a point, a curve, and to a certain extent a surface. If OneSided is TRUE, the one sided Hausdorff distance from Obj1 to Obj2 is computed. Returned is a list of two items, the first prescribes the parameter location of the Hausdorff distance event on the Obj1 and the second prescribes the parameter location of the Hausdorff distance event on Obj2.

Example:

HDRes = hausdorff( O1, O2, Eps, false );

HERMITE

SurfaceType HERMITE( CurveType Bndry1, CurveType Bndry2, CurveType Tan1, CurveType Tan2 ) or CurveType HERMITE( PointType Bndry1, PointType Bndry2, VectorType Tan1, VectorType Tan2 )

construct a cubic fit between Bndry1 and Bndry2 so that first derivative continuity constraints, as prescribed by Tan1 at Bndry1 and Tan2 at Bndry2, are preserved.

It returns either a curve or a surface, according to type of input parameters.

Example:

h00 = HERMITE( point( 0, 0, 0 ), point( 1, 1, 0 ), vector( 1, 0, 0 ), vector( 1, 0, 0 ) );

constructs a curve in the shape of the first basis function of the cubic Hermite basis functions. See also BLHERMITE and BLSHERMITE.

IMPLCTTRANS

ListType IMPLCTTRANS( 1, ListType ImplicitConicSec, MatrixType Mat ) or ListType IMPLCTTRANS( 2, ListType ImplicitQuadric, MatrixType Mat )

transforms a given conic section as the 6 coefficients A-F of:

    Ax^2 + Bxy + Cy^2 + Dx + Ey + F = 0,

Ax^2 + Bxy + Cy^2 + Dx + Ey + F = 0, in which case 6 coefficients are expected in ImplicitQuadric or transforms a given quadric section given as the 10 coefficients A-J,

    A x^2 + B y^2 + C z^2 + D xy + E xz + F yz + G x + H y + I z + J = 0,

using the given transformation matrix Mat.

Example:

ImplicitMappedEllipse = IMPLCTRANS( 1, ImplicitEllipse, Mat );

See also CONICSEC, QUADRIC, ELLIPSE3PT, MAP3PT2EQL.

INSTANCE

InstanceType INSTANCE( StringType GeomName, MatrixType Mat );

creates an instance of the geometry prescribed by GeomName to be related to a different position as specified by matrix Mat.

The use of instances is advantageous where the same geometry is to be displayed/processed in several different locations in space. A modification of the original geometry Geom will affect all instances that reference it. The reference is by the original object's name. The original object can be a single object or a whole hierarchy of objects.

Example:

Tea1 = INSTANCE( "Teapot", tx( 10 ) ); Tea2 = INSTANCE( "Teapot", tx( 20 ) ); Tea3 = INSTANCE( "Teapot", tx( 30 ) ); viewobj( list( Teapot, Tea1, Tea2, Tea3 ) );

will display four teapots 10 units apart along X.

IRITSTATE

AnyType IRITSTATE( StringType State, AnyType Data )

sets a state variable in the IRIT Solid Modeller and returns the old value, if applicative. Current supported state variables are:

State Name	Data Type	Comments

BoolPerturb	NumericType	Controls epsilon-pertubation in Booleans. Zero
		value to disable.
CmpObjEps	NumericType	Sets the epsilon to use to compare two objects.
BspProdMethod	NumericType	1 for B-spline sym. products via
		interpolation, 2 for blossoming B-spline based
		product, and 0 for B-spline sym. products
		via Bezier decomposition.
CnvxPl2Vrtcs	NumericType	TRUE to try and split non convex polygons toward
		vertices, which is usually more efficient.
Coplanar	NumericType	If TRUE, Coplanar polygons are handled by
		the Boolean operations.
CursorKeep	NumericType	If TRUE, keep mouse events reported by the
		display devices for CLNTCRSR to read.
DebugMalloc	StringType	If "Reset", memory allocation is cleared/reset.
		No "Free unallocated pointer" test after
		"Reset". If "Print", all allocated blocks are
		printed. Otherwise, used as "address, n": ptr
		address to search for with abort() called after
		n mallocs.
DebugFunc	NumericType	>0 user func. debug information. >2 print params
		on entry, ret. val. on exit. >4 global var. list
		operations.
Dependency	NumericType	0 for no object dependency propagations, 1 for
		automatic dependency propagation, in evaluation.
DoGraphics	NumericType	TRUE to enable any graphics display thru the
		display devices. FALSE to disable it.
DumpLevel	NumericType	Bitmask to control the way variables/expressions
		are dumped. Only object names/types if all 0.
		Scalars and vectors are dumped if 0x01.
		Curves and Surfaces are dumped if 0x02.
		Polygons/lines are dumped if DumpLvl 0x04.
		List objects are traversed recursively if 0x10.
		List objects are dumped verbatim if 0x20.
		Dependency information is dumped if 0x40.
EchoSource	NumericType	If TRUE, IRIT scripts are echoed to stdout.
FastPolys	NumericType	If 0x01, surface polygons are computed fast and
		are only approximated. If 0x02, surface normals
		are computed fast and are only approximated. If
		0x01 \| 0x02, both are fast and approximated.
FlatLoad	NumericType	If TRUE, the hierarchy of loaded objects is
		flattened into a linear list.
FloatFrmt	StringType	Specifies a new printf floating point format.
GMEpsilon	NumericType	Controls the epsilon of the basic geometry
		processing computation (point on plane etc.)

InterCrv	NumericType	If TRUE, Boolean operations creates only
		intersection curves. If FALSE, full Boolean
		operation results.
InterUV	NumericType	If TRUE, Boolean operations creates only UV
		intersection curves (if InterCrv is set).
LoadFont	StringType	Specifies a new IRIT font file to use in
		TEXTGEOM commands.
MvDmnReduce	NumericType	TRUE to use domain reduction in multivariate
		zero set finding, FALSE to disable.
MvGradPrecond	NumericType	TRUE to apply gradient preconditioning in the
		multivariate zero set finding, FALSE to disable.
MvHPlnTst	NumericType	TRUE to use hyperplane tests in multivariate
		zero set finding, FALSE to disable.
MvNConeTst	NumericType	TRUE to use normal cone tests in multivariate
		zero set finding, FALSE to ignore such tests.
PolySort	NumericType	Axis of Polygon Intersection sweep in Boolean
		operations: 0 for X axis, 1 for Y axis, 2 for
		Z axis.
PrimRatSrfs	NumericType	TRUE for rational exact primitive surfaces,
		FALSE for approximated polynomial (integral)
		surfaces. See also PrimSrfs.
PrimSrfs	NumericType	TRUE for primitive construction as freeform
		surfaces, FALSE for polygonal primitives.
		See also PrimRatSrfs.
RandomInit	NumericType	Initialize the seed random number generator
		in IRIT. See also the RANDOM function.
TrimCrvs	NumericType	Number of samples the higher order trimmed
		curves are sampled, in piecewise linear
		approximation. If zero, computed
		symbolically as composition.
UVBoolean	NumericType	If TRUE, Boolean between surfaces returns UV
		instead of Euclidean curves.

Example:

IRITSTATE( "DebugFunc", 3 ); IRITSTATE( "FloatFrmt", "%8.5lg" );

To print parameters of user defined functions on entry, and return value on exit. Also selects a floating point printf format of "%8.5lg".

ISGEOM

ListType ISGEOM( AnyType Obj, NumericType GeomType, NumericType Eps )

verifies if the given freeform geometry in Obj is a line, circle, plane, sphere, surface of revolution, extrusion, ruled surface, or a sweep surface, upto some tolerance Eps. GeomType prescribes the type to check for as one of the GEOM_LINE/CIRCLE etc. constants. The return value is a list of two objects. The first is a numeric value with the success/failure of the result. A zero is returned in a failure case whereas non zero value hints on the direction relevant. As an example a ruled surface along U will return 1 and a ruled surface along V will return a 2. The second object is a list with the construction entities of Obj, if any. For example, for a detected sphere, the center and radius will be returned.

Example:

b = nth( ISGEOM( Crv, GEOM_LINE ), 1 ) || nth( ISGEOM( Crv, GEOM_CIRCLE ), 1 );

checks if Crv is either line or a circle, ignoring the construction entities.

ISOCLINE

SurfaceType ISOCLINE( SurfaceType Srf, VectorType ViewDir, NumericType Theta, NumericType Euc, NumericType Mode )

computes the isocline edges of the given Srf from the prescribed viewing direction ViewDir. Isocline curves are curves on the surface at which location the surface normal forms a fixed angle, Theta, in degrees, with the prescribed viewing direction, ViewDir. The selection of 90 degrees for Theta results in the extraction of silhouette edges. The end result is a piecewise linear approximation of the exact isocline edges, and its accuracy is controlled via the RESOLUTION variable. IfMode is zero, the isoclines are simply computed and returned. IfMode is either -1 or +1, the surface regions with normals with angles of less than or great than Theta are returned as trimmed surfaces. IfMode is either -2, the surface regions with normals with angles of less than than Theta are returned along with ruled surface that are stitched along the removed region. This -2 mode is useful in mold design. If Euc is TRUE, the isocline edges are returned on the surface, in Euclidean space. Otherwise, the isocline edges are returned in the parametric space of Srf.

Example:

Resolution = 10; Isocs = ISOCLINE( glass, vector( 1, -2, 1 ), 80, true, 0 );

computes the isocline edges forming 80 degrees between the surface normal and the given viewing direction (1, -2, 1) for surface glass, and returns the isocline edges in the Euclidean space. See also SILHOUETTE.

KNOTCLEAN

CurveType KNOTCLEAN( CurveType Crv )

cleans unnecessary knots from the given curve Crv. The returned curve is identical to the given curve, but in, possibly, a sub space with less knots. Note this function can undo refinement operations.

c1 = pcircle( vector( 0, 0, 0 ), 1 ); c1r1 = crefine( c1, FALSE, list( 0.1, 0.3, 0.7, 1.5, 1.7, 1.7, 1.7, 1.7, 2.3, 2.3, 2.7, 3.5, 3.5, 3.5 ) ); c1r2 = KNOTCLEAN( c1r1 ); c1 == c1r2;

refines a polynomial circle approximation and then restores the original curve via the KNOTCLEAN operation. The last line validates this cleaning. See also KNOTREMOVE.

KNOTREMOVE

CurveType KNOTREMOVE( CurveType Crv, NumericType Tolerance )

removes knots from curve Crv so as to keep the global error less than the Tolerance.

c1r = KNOTREMOVE( c1, 0.01 );

curve c1r is the curve with the minimum number of knots possible such that the global error (distance between c1 and c1r) is less than 0.01. See also KNOTCLEAN.

LINTERP

ListType LINTERP( ListType PtList)

computes a least squares fit of a line to a list of points, PtList. A list of three elements, a point on the fitted line, a unit vector in the direction of the line and the average distance between a point and the fitted line, is returned.

Example:

R = 10; Rx = Random( -1, 1 ); Ry = Random( -1, 1 ); Rz = Random( -1, 1 ); Pts = nil(); Len = 1.0; NumPts = 100; for ( i = 1, 1, NumPts, Pt = ctlpt( E3, ( Random( -R, R ) + Rx * i * 2 ) / NumPts, ( Random( -R, R ) + Ry * i * -5 ) / NumPts, ( Random( -R, R ) + Rz * i * Pi ) / NumPts ): snoc( Pt, Pts ) ); Pts = Pts * trans( vector( random( -10, -10 ), random( -10, -10 ), random( -10, -10 ) ) ); LnFit = LINTERP( Pts ); LnPos = nth( LnFit, 1 ); LnDir = nth( LnFit, 2 ); LnErr = nth( LnFit, 3 );

randomly samples 100 points to be approximately along a line and computes a least squares fit of a line to this data. LnPos, LnDir, and LnErr contain a point on the fitted line, the unit direction of the fitted line and the average distance between a point and the line, respectively. See also CINTERP and SINTERP.

LOFFSET

CurveType LOFFSET( CurveType Crv, NumericType OffsetDistance, NumericType NumOfSamples, NumericType NumOfDOF, NumericType Order )

approximates an offset of OffsetDistance by sampling NumOfSamples samples along the offset curve and least square fitting them using a B-spline curve of order Order and NumOfDOF control points.

Example:

OffCrv1 = LOFFSET( Crv, -0.4, 100, 10, 4 );

See also OFFSET, TOFFSET, AOFFSET, and MOFFSET.

MATDECOMP

ListType MATDECOMP( MatrixType Mat );

decomposes a given homogeneous transformation into its scaling and translation vectors, and a pure (orthogonal) rotation matrix.

Example:

MATDECOMP( rx( 45 ) * sy( 3 ) * sx( 2 ) * tx( 5 ) * ty( 7 ) );

would result in the "(2, 3, 1)" scaling vector, "(5, 7, 0)" translation vector and a rotation around X matrix of 45 degrees, all in one returned list object.

MAXEDGELEN

PolyType MAXEDGELEN( PolyType Pl, NumericType MaxLen );

splits all triangles in polygonal object Pl to triangles with edges no greater than MaxLen in length.

Example:

PlNew = MAXEDGELEN( Pl, 0.5 );

See also TRIANGL

MBEZIER

MultivarType MBEZIER( ListType Orders, ListType CtlPts )

creates a Bezier polynomial/rational multivariate out of the provided control mesh. Orders is a list of orders whose size define the number of dimensions that the multivariate has. CtlPts is a linear list of control points. All control points must be of type (E1-E9, P1-P9), or regular PointType defining the multivariate's control mesh. The multivariate's point type will be of a space which is the union of the spaces of all points.

Example:

MV = MBEZIER( list( 4 ), list( ctlpt( E3, -1, 0.5, 2 ), ctlpt( E1, 3 ), ctlpt( E3, 0, -1.5, 0 ), ctlpt( E2, -1, 3.5 ) ) );

constructs a univariate cubic multivariate object. See also MPOWER and MBSPLINE

MBISECTOR

ListType MBISECTOR( MultivarType MV1, MultivarType MV2, NumericType RetType, NumericType SubdivTol, NumericType NumerTol )

computes the bisector surface in R3 of two surfaces or a curve and a surface, posed as multivariate functions.

The returned results depend upon the value of RetType. If RetType = 1, the algebraic constraints are returned as a list of multivariates. If RetType = 2, a list of points in R3 on the bisector sheet(s) is returned. If RetType = 3, a list of points in (u, v, x, y, z) space, as E5 points, is returned, where (u, v) are the respective parameter locations of the (must be) surface MV1. These E5 points can then directly be employed by SINTERP through which to fit a surface. Finally, if RetType = 4, marching cubes is applied to extract a piecewise linear approximation of the solution, in Euclidean space.

This bisector problem is posed as a set of two multivariate algebraic constraints with three variables. The simultaneous solution of these constraints is computed using the MZERO function. See MZERO for the meaning of the SubdivTol and NumerTol tolerances.

Example:

s1 = sbezier( list( list( ctlpt( E3, 0, 0, 0 ), ctlpt( E3, 2, 0, 0 ) ), list( ctlpt( E3, 0, 2, 0 ), ctlpt( E3, 2, 2, 0 ) ) ) ) * tx( -1 ) * ty( -1 ); color( s1, red ); s2 = sbezier( list( list( ctlpt( E3, 0, 0, 2 ), ctlpt( E3, 1, 0, 1 ), ctlpt( E3, 2, 0, 2 ) ), list( ctlpt( E3, 0, 1, 1 ), ctlpt( E3, 1, 1, 0 ), ctlpt( E3, 2, 1, 1 ) ), list( ctlpt( E3, 0, 2, 2 ), ctlpt( E3, 1, 2, 1 ), ctlpt( E3, 2, 2, 2 ) ) ) )* tx( -1 ) * ty( -1 ); color( s2, magenta ); ms1 = coerce( s1, multivar_type ); ms2 = coerce( s2, multivar_type ); mb1 = MBISECTOR( ms1, ms2, 3, 0.3, -0.001 ); b1 = sinterp( mb1, 3, 3, 4, 4, PARAM_UNIFORM ); mb2 = MBISECTOR( ms1, ms2, 2, 0.3, -0.001 ); interact( list( s1, s2, mb2, b1 ) ); c = cbezier( list( ctlpt( E3, 0, 0, 0 ), ctlpt( E3, 0, 0, 2 ) ) ); color( c, red ); mc = coerce( c, multivar_type ); mb1 = MBISECTOR( mc, ms1, 3, 0.2, -0.001 ); b1 = sinterp( mb1, 3, 3, 8, 8, PARAM_UNIFORM ); mb2 = MBISECTOR( mc, ms1, 2, 0.2, -0.001 ); interact( list( c, s1, mb2, b1 ) );

computes two examples of a bisector between a plane and a biquadratic surface and between a plane and a line. The cloud of points is computed twice, once interpolated by a surface, and also displayed as is.

FIGURE: A bisector between two surfaces (left) and a plane and a line (right) computed using MBISECTOR.

MBSPLINE

MultivarType MBSPLINE( ListType Lengths, ListType Orders, ListType CtlPts, ListType KVLst )

creates a Bspline polynomial/rational multivariate out of the provided control mesh of lengths Lengths and orders Orders in each axis. The sizes of Lengths and Orders define the number of dimensions that the multivariate has. CtlPts is a linear list of control points. All control points must be of type (E1-E9, P1-P9), or regular PointType defining the multivariate's control mesh. The multivariate's point type will be of a space which is the union of the spaces of all points. KVLst is a list of knot sequences of the new Bspline multivariate.

Example:

MV = MBSPLINE( list( 3, 3 ), list( 3, 3 ), list( ctlpt( E1, 0 ), ctlpt( E2, 0.25, 1 ), ctlpt( E3, 0.5, 0.25, 2 ), ctlpt( E3, 0.5, -1, 3 ), ctlpt( E3, 0.75, 0.25, 4 ), ctlpt( E3, 1, -0.5, 5 ), ctlpt( E3, 1, 0, 6 ), ctlpt( E3, 1.25, 1, 7 ), ctlpt( E3, 1.3, 0.25, 8 ) ), list( list( kv_open ), list( kv_open ) ) );

constructs a bivariate quadratic multivariate object. See also MPOWER and MBEZIER.

MDERIVE

MultivarType MDERIVE( MultivarType MV, NumericType Dir )

returns a vector field multivariate representing the differentiated multivariate MV, in the given direction. Evaluation of the returned multivariate at a given parameter value will return a vector tangent to TV in Dir at that parameter value.

DMV = MDERIVE( MV, 2 );

computes the partial derivative of the multivariate MV with respect to its second variable. See also CDERIVE, SDERIVE, and TDERIVE.

MDIVIDE

MultivarType MDIVIDE( MultivarType MV, ConstantType Direction, NumericType Param )

subdivides a multivariate into two at the specified parameter value Param in the specified Direction. MV can be either a B-spline multivariate in which Param must be contained in the parametric domain of the multivariate, or a Bezier multivariate in which Param can be arbitrary, extrapolating if not in the range of zero to one.

It returns a list of the two sub-multivariates. The individual multivariates may be extracted from the list using the NTH command.

Example:

MvDiv = MDIVIDE( Mv2, 3, 0.3 ); Mv2a = nth( MvDiv, 1 ) * tx( -2.2 ); Mv2b = nth( MvDiv, 2 ) * tx( 2.0 );

subdivides Mv2 at the parameter value of 0.3 in the direction 3 and then extracts the two subdivided multivariate. See also CDIVIDE, SDIVIDE, and TDIVIDE.

MERGPLLN

PolygonType MERGPLLN( PolygonType PolyList, NumericType Eps ) or PolygonType MERGPLLN( ListType PolyList, NumericType Eps )

merges a set of polylines/polyline objects in PolyList to larger polyline object. All elements in the PolyList in the second form must be of PolygonType type. This function merges two polylines if their end point is the same upto Eps.

Example:

Vrtx1 = vector( -3, -2, -1 ); Vrtx2 = vector( 3, -2, -1 ); Vrtx3 = vector( 3, 2, -1 ); Vrtx4 = vector( -3, 2, -1 ); Polys = list( poly( list( Vrtx1, Vrtx2 ), true ), poly( list( Vrtx3, Vrtx2 ), true ), poly( list( Vrtx3, Vrtx4 ), true ), poly( list( Vrtx1, Vrtx4 ), true ) ); Polys = MERGEPLLN( Polys );

will merge the four 2-vertices polylines into one polyline prescribing a square. Note polylines might be reversed in the merging process. See also MERGEPOLY.

MERGPOLY

PolygonType MERGEPOLY( ListType PolyList )

merges a set of polygonal objects in the PolyList list to a single polygonal object. All elements in the ObjectList must be of PolygonType type. This function performs the same operation as the overloaded ^ operator would, but may be more convenient to use under some circumstances.

Example:

Vrtx1 = vector( -3, -2, -1 ); Vrtx2 = vector( 3, -2, -1 ); Vrtx3 = vector( 3, 2, -1 ); Vrtx4 = vector( -3, 2, -1 ); Poly1 = poly( list( Vrtx1, Vrtx2, Vrtx3, Vrtx4 ), false ); Vrtx1 = vector( -3, 2, 1 ); Vrtx2 = vector( 3, 2, 1 ); Vrtx3 = vector( 3, -2, 1 ); Vrtx4 = vector( -3, -2, 1 ); Poly2 = poly( list( Vrtx1, Vrtx2, Vrtx3, Vrtx4 ), false ); Vrtx1 = vector( -3, -2, 1 ); Vrtx2 = vector( 3, -2, 1 ); Vrtx3 = vector( 3, -2, -1 ); Vrtx4 = vector( -3, -2, -1 ); Poly3 = poly( list( Vrtx1, Vrtx2, Vrtx3, Vrtx4 ), false ); PolyObj = MERGEPOLY( list( Poly1, Poly2, Poly3 ) );

FIGURE: Individual polygons can be merged into a complete model using MERGEPOLY.
See also INSERTPOLY, SPLITLST.

MEVAL

CtlPtType MEVAL( MultivarType MV, ListType Params )

evaluates the provided multivariate MV at the given Params values. Params is a list of NumericTypes of length equal to the dimension of the multivariate that must be contained in the multivariate parametric domain, if MV is a B-spline multivariate, or all between zero and one if MV is a Bezier multivariate. The returned control point has the same type as the control points of MV.

Example:

CPt = MEVAL( MV1, list( 0.1, 0.25, 0.22, 0.7 ) );

evaluates the four-variate MV1 at the parameter values of (0.1, 0.25, 0.22, 0.7). See also CEVAL, SEVAL, TEVAL.

MFROMMESH

MultivarType MFROMMESH( MultivarType MV, MumericType Dir, NumericType Index )

extracts a multivariate out of a multivariate, MV, as the Index's plane of the control mesh of MV in direction Dir.

Example:

cmesh( s, row, 2 ) == coerce( MFROMMESH( coerce( s, multivar_type ), 1, 2 ), curve_type );

coerces surface s to a multivariate, extracts a one-dimensional-less multivariate (a curve) from the second direction (first direction is direction zero), at index 2 and compares the result for equality to the curve extracted using cmesh from s.

MFROMMV

MultivarType MFROMMV( MultivarType MV, NumericType Dir, NumericType Param )

extracts a multivariate of one lower dimension from multivariate MV by extracting an iso-variate of MV in direction Dir at parameter value Param.

Example:

MVFirst = MFROMMV( MV, 0, FirstParam );

extracts a multivariate for one less dimension than MV as the constant first parameter of MV at parameter value FirstParam. See also STRIVAR, CSURFACE.

MMERGE

MultivarType MMERGE( MultivarType MV1, MultivarType MV2, NumericType Dir, NumericType Discont )

merges MV1 and MV2 together into one multivariate along the direction Dir. The first direction starts from zero. If Discont, the merge is assumed to be along a discontoinuous edge.

Example:

MVFirst = MMERGE( M1, M2, 2, false );

merges M1 and M2 along the third direction. See also SMERGE,

MOFFSET

CurveType MOFFSET( CurveType Crv, NumericType OffsetDistance, NumericType AngularError )

computes an offset of OffsetDistance with a globally bounded error (controlled by AngularError). The smaller the AngularError is, the better the approximation to the offset. The bounded error is achieved by adaptive refinement of the Crv. The offset is computed via matching of the tangent fields of the given curve Crv and an arc spanning the same angular domain. Further, AngularError measures the angular deviation allowed between the two tangent fields.

Example:

OffCrv1 = MOFFSET( Crv, -0.4, 10 ); OffCrv2 = MOFFSET( Crv, -0.4, 5 );

computes an offset approximation to Crv with OffsetDistance of -0.4 and AngularError of 10 and 5 degrees, respectively. See also OFFSET, TOFFSET, AOFFSET, LOFFSET, and FFMATCH.

MOMENT

PointType MOMENT( CurveType Crv, 0 ); or VectorType MOMENT( CurveType Crv, 1 );

approximate the zero and first moments of curve Crv.

Example:

a = circle( vector( 0, 0, 0 ), 1 ); a = cregion( a, 0, 1 ); p = moment( a, 0 ); v = moment( a, 1 ); view(list(a, p, v), on); a = cregion( a, 0, 1 ) * rz( 45 ); p = moment( a, 0 ); v = moment( a, 1 ); view(list(a, p, v), on);

computes and displays the zero and first moments of a quarter of a circle in two orientations.

MPOWER

MultivarType MPOWER( ListType Orders, ListType CtlPts )

creates a polynomial/rational multivariate out of the provided control mesh. Orders is a list of orders whose size define the number of dimensions that the multivariate has. The created multivariate employs the monomial power basis. CtlPts is a linear list of control points. All control points must be of type (E1-E9, P1-P9), or regular PointType defining the multivariate's control mesh. The multivariate's point type will be of a space which is the union of the spaces of all points.

Example:

MV = MPOWER( list( 4 ), list( ctlpt( E3, -1, 0.5, 2 ), ctlpt( E3, 3, -1.5, 0 ), ctlpt( E3, 0, -1.5, 0 ), ctlpt( E3, -1, 3.5, 0 ) ) );

constructs a univariate cubic multivariate object. See also MBEZIER and MBSPLINE.

MRAISE

MultivarType MRAISE( MultivarType TV, ConstantType Direction, NumericType NewOrder )

raises Srf to the specified NewOrder in the specified Direction.

Example:

MV2 = MRAISE( MRAISE( MV2, 0, 4 ), 1, 4 );

raises multivariate MV1 to a cubic in the first and second directions. See also TRAISE, SRAISE, and CRAISE.

MRCHCUBE

PolygonType MRCHCUBE( ListType VolumeSpec, PointType CubeDim, NumericType SkipFactor, NumericType IsoVal )

applies (a variation of) the marching cubes algorithm (see W. E. Lorensen and H. E. Cline. "Marching Cubes: A High Resolution 3D Surface Construction Algorithm." Computer Graphics (SIGGRAPH '87 Proceedings), Vol. 21, No. 4, pp 163-169, July 1987.) to the given volumetric data set or trivariate. VolumeSpec can be a list of four or five objects as follows:

1	a list of image file names.
4	a 4-tuple of the form
	(TrivarType TV, NumericType Axis, NumericType SamplingFactor,
	NumericType TVNormal)
5	a 5-tuple of the form
	(StringType FileName, NumericType DataType, NumericType Width,
	NumericType Height, NumericType Depth )

In the first case, the list of images are considered slices in the volume. All images are read in and stacked together to form the volume. The RGB colors are converted into a gray scale values.

In the second case, the trivariate TV is iso surface contoured at level IsoVal along the prescribed Axis (Note a trivariate need not be a scalar function, whereas Marching Cubes assumes a scalar function). The sampling rate of the trivariate is governed by SamplingFactor with SamplingFactor equal 1.0 sets sampling rate that equates with the dimensions of the trivaariate (control mesh volume size). If TVNormals is not zero, much more accurate normals are derived using the trivariate function though it is also slower. Otherwise, first order differencing on the cubes is employed for normal estimation.

In the third case, the volume file prescribed by FileName is loaded and iso surface contoured. The file is assumed to hold Width * Height * Depth (Width first, Depth order last) scalar numeric values of type DataType:

1	Regular float or int ASCII (separated by white spaces)
2	Two bytes short integer.
3	Four bytes long integer.
4	One byte (char) integer.
5	Four bytes float.
6	Eight bytes double.

Beware of the little vs big Endian problem! We assume here that you have read the volume in the same machine type in which this file was written.

CubeDim allows the user to prescribe the real cell size (not necessarily cubical). SkipFactor allows the skipping of data in large data sets. SkipFactor = 1 skips nothing. SkipFactor = 2, skips every other scalar value, reducing in half all dimensions, etc. Last but not least, IsoVal sets the iso surface level.

See also COVERISO, TVLOAD, and TMORPH.

Example:

IsoSrf = MRCHCUBE( list( ThreeCyls, 1, 1, TRUE ), point( 1, 1, 1 ), 1, 0.12 );

iso surface contours the X axis of trivariate ThreeCyls and uses the trivariate to get better normals' estimations. Cell size is unit cube like, no dat is skipped and the iso surface level is 0.12.

FIGURE: The result of applying Marching Cubes to a trivariate scalar function using the MRCHCUBE command.

MREFINE

MultivarType MREFINE( MultivarType TV, ConstantType Direction, NumericType Replace, ListType KnotList )

provides the ability to Replace a knot vector of MV or refine it in the specified direction Direction. KnotList is a list of knots at which to refine MV. All knots should be contained in the parametric domain of MV in Direction. If the knot vector is replaced, the length of KnotList should be identical to the length of the original knot vector of MV in Direction. If MV is a Bezier multivariate, it is automatically promoted to be a B-spline multivariate.

Example:

MV = MREFINE( MREFINE( MREFINE( MV, 0, FALSE, list( 0.333, 0.667 ) ), 1, FALSE, list( 0.333, 0.667 ) ), 2, FALSE, list( 0.333, 0.667 ) );

refines MV in the first three directions by adding two more knots at 0.333 and 0.667. See also CREFINE, SREFINE, and TREFINE.

MREGION

MultivarType MREGION( MultivarType MV, ConstantType Direction, NumericType MinParam, NumericType MaxParam )

extracts a region of MV between MinParam and MaxParam in the specified Direction. Both MinParam and MaxParam should be contained in the parametric domain of MV in Direction.

Example:

MV1r1 = MREGION( MV1, 3, 0.1, 0.2 ); MV1r2 = MREGION( MV1, 3, 0.4, 0.6 ); MV1r3 = MREGION( MV1, 3, 0.99, 1.0 );

extracts three regions of MV1 along the 4th (directions are counted from zero) direction. See also CREGION, SREGION, and TREGION.

MREPARAM

MultivarType MREPARAM( MultivarType MV, ConstantType Direction, NumericType MinParam, NumericType MaxParam )

reparametrizes MV over a new domain from MinParam to MaxParam, in the prescribed Direction. This operation does not affect the geometry of the multivariate and only affine transforms its knot vectors. A Bezier multivariate will automatically be promoted into a B-spline surface by this function.

Example:

MV = MREPARAM( MREPARAM( MV, 0, 0.1, 1.9 ), 1, 0.1, 0.9 );

ensures that the multivariate MV is defined over [0.1, 0.9] in the first two directions. See also CREPARAM, SREPARAM, and TREPARAM.

MREVERSE

MultivarType MREVERSE( MultivarType MV, NumericType Dir1, NumericType Dir2 )

reverses MV by flipping the given two parametric directions, Dir1 and Dir2, (starting to count directions from zero).

Example:

RevMV = MREVERSE( MV, 2, 4 );

reverses MV by flipping the third and fifth directions of MV. See also SREVERSE.

MSCIRC

CurveType MSCIRC( PolyType Poly, ListType Tols ) or CurveType MSCIRC( ListType Geom, ListType Tols )

computes a minimum spanning circle to polyline(s) (first form), or to a list of curves (second form). Tols is a list of two numeric values, SubdivTol and NumerTol, that are used only if the minimum spannng circle of a set of curves is required. See MZERO for the meaning of the SubdivTol and NumerTol tolerances. The returned circle will have 'center' and 'radius' attributes with the circles parameters. If a cone is returned, 'angle' and 'center' of the cone will be returned.

Example:

Msc = MSCIRC( Crvs, list( 0.01, 1e-10 ) ):

See figure for minimum spanning circle of curves.

FIGURE: The minimum spanning circle of a set of planar curves is computed with the aid of MSCIRC. Two examples are shown.

MSCONE

ListType MSCONE( ListType Vecs )

computes the minimum spanning cone of a set of input vectors, Vecs. Returned is a list of the cone's parameters as well as a geometry representation of the cone.

Example:

MSC = MSCONE( Vecs );

See also MSCIRC and MSSPHERE

MSSPHERE

SurfaceType MSSPHERE( ListType Pts )

computes a minimum spanning sphere to a list of 3D points. Returned is a geometric representation of the cone with "radius" and "center" attributes of the parameters of the sphere.

Example:

MSS = MSSPHERE( Pts );

MVCONTACT

MultivarType MVCONTACT( SurfaceType S1, SurfaceType S2, ListType MotionCrvs, NumericType SubdivTol, NumericType NumerTol, NumericType UseExprTrees )

computes the contact locations, if any, when S1 is stationary and S2 is moving along the MotionCrvs animation curves. Currently only "MOV_XYZ" and "SCL" animation curves are supported. SubdivTol and NumerTol control the tolerance of the computation as in MZERO. If UseExpreTrees, expression trees are used in the computation which is typically faster.

Example:

Cntct = MVCONTACT( s1, s2, list( mov_xyz ), 0.02, -1e-14, true );

MVEXPLICIT

MultivarType MVEXPLICIT( NumericType Dim, StringType Expression )

constructs a multivariate power basis from the given polynomial Expression. The Expression can be any infix notational expression using +-/*^ with no parenthesis. The parameters are the 26 letters A-Z. The dimension of the multivariate is set by Dim and should be in line with the variables used. A stands for the first dimension, B for the second, etc., so if Dim equal 3, only A, B, and C could appear in Expression. Having a higher letter with a lower dimension constitutes an error.

Example:

M1 = coerce( mvexplicit( 2, "A^2 + B^2 - 1" ), bezier_type ); M2 = coerce( mvexplicit( 2, "4 * A^2 + B^2 / 4 - 1" ), bezier_type );

constructs two scalar saddle Bezier bivariate surfaces, represented as multivariates.

MVINTER

MultivarType MVINTER( ListType Geometry, NumericType SubdivTol, NumericType NumerTol, NumericType UseExprTrees )

computes the intersection of two planar curves (Geometry is a list of two planar curves) or three surfaces (Geometry is a list of three surfaces). SubdivTol and NumerTol control the tolerance of the computation as in MZERO. If UseExpreTrees, expression trees are used in the computation which is typically faster.

Example:

Sln1 = MVINTER( list( c1, c2 ), 0.001, 1e-8, true );

NCCNTRPATH

ListType NCCNTRPATH( PolyType Obj, NumericType Offset, NumericType ZBaseLevel, NumericType TPathSpace, NumericType Units ) or ListType NCCNTRPATH( SurfaceType Obj, NumericType Offset, NumericType ZBaseLevel, NumericType TPathSpace, NumericType Units )

builds Numerically controlled (NC) tool path to mill (machine) the given Obj geometry. The Offset prescribes the necessary offset, due to the tool's ball end radius. ZBaseLevel sets a base level the toolpath will not go below. and Units sets the used units with 0 for inches and 1 for mm. The toolpath is built as parallel contours of the (offset of the) input Obj, contours that are TPathSpace spacing apart.

The following attributes are supported by NCCNTRPATH:

NCCntrBBox	A string attribute with six numeric values as
	"XMin XMax YMin YMax ZMin ZMax". Bounds the working
	space of the contouring.
NCCntrClip	A closed polyline object to clip the final toolpath to
	be confined to its interior.

Example:

Tea = load( "teapot" ); NCPath = NCCntrPath( Tea, 1/4, 0.0, 1/8, 0 ); attrib( NCPath, "NCRetractZLevel", 3.5 ); attrib( NCPath, "NCMaxXYBridgeGap", 0.25 ); save( "NCPath.nc", NCPath );

NC data can be saved using the SAVE command in G-code if the saved file type is ".nc". See SAVE for more, including the meaning of the different attributes in the above example. See also NCPCKTPATH.

NCPCKTPATH

ListType NCPCKTPATH( PolyType Obj, NumericType ToolRadius, NumericType RoughOffset, NumericType TPathSpace, NumericType TPathJoin, NumericType Units, NumericType TrimSelfInters )

computes tool path to 2D pocket machining from +Z direction the given Obj geometry (a closed curve or a closed polygon). ToolRadius sets the offset to use in the pocket whereas RoughOffset sets the offset to use during roughing (RoughOffset better be larger than ToolRadius). TPathSpace sets the space between adjacent pockets slices in the zigzag motion and TPathJoin prescribes the maximum distance to connect adjacent slices (if larger a full retracting will be performed). Units sets the used units with 0 for inches and 1 for mm and if TrimSelfInters is TRUE also attempts to eliminate self intersections due to the applied offsets.

Example:

TPath = NCPcktPath( Crv, 0.05, 0.06, 0.02, 0.05, 0, true ); attrib( TPath, "NCRetractZLevel", 1.0 ); attrib( TPath, "NCMaxXYBridgeGap", 0.05 ); save( "TPath.nc", TPath );

NC data can be saved using the SAVE command in G-code if the saved file type is ".nc". See SAVE for more, including the meaning of the different attributes in the above example. See also NCCNTRPATH.

MZERO

ListType MZERO( ListType MVs, NumericType SubdivTol, NumericType NumerTol )

computes the simultaneous zeros of several scalar multivariate functions, in MVs. SubdivTol specifies the subdivision tolerance in the parametric domain of the multivariates, whereas NumerTol prescribes the tolerance of the numerical improvement stage. A numerical improvement stage is applied if |NumerTol| < SubdivTol. If NumerTol is negative, and a numeric improvement stage is indeed applied, all points that fail to improve to the requested accuracy are purged away.

A list of control points, each designating one location in the parameter space of the multivariates, is returned.

The number of multivariates cannot exceed the dimension of the multivariates. That is, if the MVs are trivariates, then, at most, three of them may be provided. If less are provided, then the dimension of the solution space is larger than zero and a finite cloud of points sampled from that solution space will be returned.

Example:

ZeroMVs = MZERO( list( MV1, MV2, MV3 ), 0.01, -1e-6 );

See also CONTOUR. See MZERO for the meaning of SubdivTol and NumerTol.

MPROMOTE

PromMV = MPROMOTE( MultivarType MV, ListType AddDir ); or PromMV = MPROMOTE( MultivarType MV, ListType NewDimStartAxis );

promote the multivariate MV to a higher dimension. In the first form (a list of one numeric value), the multivariate will be promoted to have one more dimension (i.e. a bivariate would become a trivariate). The new added axis will be AddDir.

The second form (a list of two numeric values) allows the original multivariate to be placed at axes from StartAxis and have a new dimensional NewDim.

Example:

ms = coerce( srf, multivar_type ); coerce( mfrommv( MPROMOTE( ms, list( 0 ) ), 0, 0.5 ), surface_type ) == srf;

coerces a surface to a multivariate, promotes it to a trivariate-multivariate, extracts an iso-surface bivariate-multivariate along the new introduced axis from the trivariate-multivariate and compares it to the original surface. It should be equal!

NIL

ListType NIL()

creates an empty list so data can be accumulated in it. See CINFLECT or CZEROS for examples. See also LIST and SNOC.

OFFSET

PolygonType OFFSET( PolygonType Poly, NumericType OffsetDistance, NumericType Smoothing, NumericType MiterEdge ) or CurveType OFFSET( CurveType Crv, NumericType OffsetDistance, NumericType Tolerance, NumericType BezInterp ) or CurveType OFFSET( CurveType Crv, CurveType OffsetDistance, NumericType Tolerance, NumericType BezInterp ) or SurfaceType OFFSET( SurfaceType Srf, NumericType OffsetDistance, NumericType Tolerance, NumericType BezInterp ) or TrimSrfType OFFSET( TrimSrfType TrimSrf, NumericType OffsetDistance, NumericType Tolerance, NumericType BezInterp )

offset Poly, Crv, Srf or a TrimSrf, by translating all the vertices or control points in the direction of the normal of the poly/curve or of the (trimmed) surface by an OffsetDistance amount. For a Poly object, the input can be a single polygon or a single polyline, in which case the offset is computed in the XY plane, or can be a polygonal model in which case the offset is computed in R^3. In the former case, the result is an offset of the original polygon/line in the XY plane and is exact. In the latter case, the normals at the vertices of the polygonal model are employed (and are locally estimated if non detected), and all vertices are moved in the vertices normals, scaled by this offset distance. For offset in R^3, if Smoothing is TRUE, normals at the vertices are always recomputed and smoothed out. Also for an offset in R^3, if MiterEdge is TRUE, attempts to properly compenstate for miter edges' based offset is made.

Otherwise, each control point has a node parameter value associated with it, which is used to compute the normal. The returned curve or surface only approximates the real offset. If the resulting approximation does not satisfy the accuracy required by Tolerance, Crv or Srf or TrimSrf is subdivided and an offset approximation fit is computed for the two halves. For curves, one can request a Bezier interpolation scheme in the offset approximation by setting BezInterp. BezInterp is not yet supported for (trimmed) surfaces. Negative OffsetDistance denotes offset in the reversed direction of the normal. If OffsetDistance is a (scalar) curve, the curve's first coordinate is used to prescribe a variable offset amount along the curve for which we compute the variable offset. Both Crv and OffsetDistance must share the same parametric domain.

Example:

OffCrv = OFFSET( Crv, -0.4, 0.1, off );

offsets Crv by the amount of -0.4 in the reversed normal direction, Tolerance of 0.1 and no Bezier interpolation. See also TOFFSET, AOFFSET, LOFFSET and MOFFSET.

FIGURE: Offset approximation (thick) of a B-spline curve (thin).

ORTHOTOMC

CurveType ORTHOTOMC( CurveType Crv, PointType Pt, NumericType K ) or, SurfaceType ORTHOTOMC( SurfaceType Srf, PointType Pt, NumericType K )

compute the K-orthotomic of freeform curves and surfaces. See Fundamentals of Computer Aided Geometric Design, by J. Hoschek and D. Lasser.

Example:

pt = point( 0, 0.35, 0 ); crv = cbezier( list( ctlpt( E2, -0.8, -0.6 ), ctlpt( E2, -0.3, -0.2 ), ctlpt( E2, 0.0, 0.0 ), ctlpt( E2, 0.8, -0.6 ) ) ); Orth = ORTHOTOMC( crv, pt, 2 ); interact( list( Orth, crv, pt ) * tx( 0.5 ) ) );

computes the orthotomic of a cubic Bezier curve that has an inflection point. Note that inflection points are reduced to cusps in the orthotomic result.

FIGURE: An orthotomic (thick) of a cubic Bezier curve. The inflection point in the cubic Bezier is reduced to a cusp in the orthotomic. Computed using the ORTHOTOMC command.

PATTRIB

AnyType PATTRIB( PolyType Poly, NumericType Index, StringType Name, AnyType Value )

provides a mechanism to set/get an attribute to a vertex of a polygon. Unlike the regular ATTRIB/RMATTR functions, PATTRIB allows access to the Index vertex in polygon Poly, access that is otherwise impossible. Index starts at zero for the first vertex. The attribute will have a name Name and a value Value. If Value is NIL(), no attributes are set and the named attribute, if any, is returned. This PATTRIB function only allows numeric values or strings as Value.

For example,

PATTRIB( Tri, 0, "rgb", "255,0,0"); PATTRIB( Tri, 1, "rgb", "0,255,0"); PATTRIB( Tri, 2, "rgb", "0,0,255");

sets the RGB values of the three vertices of triangle Tri. See also PNORMAL, ATTRIB, ATTRPROP, GETATTR, RMATTR, CPATTR.

PCIRCLE

CurveType PCIRCLE( VectorType Center, NumericType Radius )

is the same as CIRCLE but approximates the circle as a polynomial curve. See also CIRCLE.

PCRVTR

PolyType PCRVTR( PolyType Pl, NumericType NumOfRings, NumericType CubicFit )

estimates curvature properties of given polygonal model Pl, assuming Pl originated from a continuous freeform surfaces. NumOfRings sets the number of rings around a vertex that will be used to estimate the curvature properties of the vertex. If (CubicFit is TRUE, a cubic fit is computed to the local vertex neighborhood, or a quadratic fit, if FALSE. The return polygonal object is identical to Pl, but with the following attributes set at each vertex:

"K1Curv"	First principal curvature value
"K2Curv"	Second principal curvature value
"KCurv"	The Gaussian Curvature
"HCurv"	The Mean Curvature
"D1"	The first principal direction
"D2"	The second principal direction

PDECIMATE

PolygonType PDECIMATE( PolygonType Obj, NumericType DecimType, NumericType Threshold )

Given a polygonal model, Obj, decimate and merge polygons, effectively reducing the size of the data subject to a maximal deviation distance as controlled via Threshold and DecimType. DecimType can be either TRUE when Threshold has a continuous zero to one control over the output size or FALSE when Threshold prescribes the exact number of polygons desired.

Example:

gcross = cbspline( 3, list( ctlpt( E3, 0.3, 0.0, 0.0 ), ctlpt( E3, 0.1, 0.0, 0.1 ), ctlpt( E3, 0.1, 0.0, 0.4 ), ctlpt( E3, 0.5, 0.0, 0.5 ), ctlpt( E3, 0.6, 0.0, 0.8 ) ), list( KV_OPEN ) ); resolution = 30; glass = surfprev( gcross ); pglass = gpolygon( glass, false ); dglass = PDECIMATE( pglass, false, 0.5 );

creates a surface of a glass, approximates it with polygons and then decimates the latter.

FIGURE: A polygonal object (left) can be decimated and reduced (right) to within a given tolerance by using PDECIMATE.

PDOMAIN

ListType PDOMAIN( FreeformType Freeform )

returns the parametric domain of the given Freeform. See also MESHSIZE, FFCTLPTS, FFKNTVEC, FFMESH, FFMSIZE, FFPTTYPE, FFORDER.

Example:

circ_domain = PDOMAIN( circle( vector( 0.0, 0.0, 0.0 ), 1.0 ) );

PIMPRTNC

PolyType PIMPRTNC( PolyType Pl, NumericType GenImprtncPolylines )

computes the importance of a local neighborhood in a triangular polygonal mesh {bf Pl}, based on the dihedral angles of the edges in that neighborhood. If GenImprtncPolylines FALSE, every vertex in the returned mesh will have a "SilImp" (See the connection of this importance to silhouettes?) attribute with its importance. Otherwise, if GenImprtncPolylines TRUE, polylines that stylistically convey the importance of the different regions in this mesh are returned.

Example:

Pl = triangl( box( vector( 0, 0, 0 ), 1, 2, 3 ), 1 ); PlImp = PIMPRTNC( Pl, 0 );

PLANE

PointType PLANE( NumericType A, NumericType B, NumericType C, NumericType D )

creates a plane type object, using the four provided NumericType coefficients. See also VECTOR, POINT.

PLANECLIP

ListType PLANECLIP( PolyType Poly, PlaneType Pln )

clips a polygonal model Poly against a plane Pln. Three polygonal objects are returned in a list: polygons on the positive side of the plane, polygons that intersect the plane, and polygons on the negative side of the plane, in this order. If one of these lists is empty, a numeric zero is substituted.

Example:

Pls = PLANECLIP( Pl, plane( 1, 1, 0, 0 ) );

clips polygonal object Pl against the plane X+Y=0.

PLN3PTS

PlaneType PLN3PTS( PointType Pt1, PointType Pt2, PointType Pt3 )

computes a plane out of three points.

Example:

Pl1 = PLN3PTS( point( 0, 0, 0 ), point( 0, 1, 0 ), point( 1, 0, 0 ) );

PMORPH

PlaneType PMORPH( PolyType Pl1, PolyType Pl2, NumericType Blend )

creates a new polygonal object which is a metamorph of the two given polygonal objects that share the same topology. That is, Pl1 and Pl2 must share the same number of polygons and the i'th polygon in Pl1 must be equal in its number of vertices to the i'th polygon of Pl2. This is very useful if a sequence that "morphs" one polygonal model to another is to be created.

Example:

Pl1 = con2( vector( 0.0, -0.5, -0.5 ), vector( 0.0, 0.0, 1.0 ), 0.4, 0.1, 3 ); Pl2 = con2( vector( 0.0, 0.5, 0.0 ), vector( 0.0, 0.0, 1.0 ), 0.1, 0.4, 3 ); Pl = PMORPH( Pl1, Pl2, 0.5 );

creates a cylinder out of two truncated cones, using PMORPH. See also CMORPH and SMORPH.

PNORMAL

PointType PNORMAL( PolyType Poly, NumericType Index, VectorType Normal )

provides a mechanism to set/get the normal of vertex number Index in a polygon Poly. Index starts at zero for the first vertex. Normal replaces the current normal that is also returned. If Normal is not a VectorType, no new normal is set but the current normal is still returned, allowing normals to be queried.

For example,

PNORMAL( Tri, 0, vector( 1, 0, 0 ) ); PNORMAL( Tri, 1, vector( 0, 1, 0 ) );

sets the normals of the first two vertices in triangle Tri to be the X and Y axes, respectively.

See also PATTRIB.

POINT

PointType POINT( NumericType X, NumericType Y, NumericType Z )

creates a point type object, using the three provided NumericType scalars. See also VECTOR, PLANE.

POLARSIL

PolygonType POLARSIL( SurfaceType Srf, VectorType ViewDir, NumericType EuclideanSpace )

computes the polar silhouettes of surface Srf from view direction ViewDir. if EuclideanSpace TRUE, the polar silhouettes are returned in Euclidean space, over Srf. Otherwise, the polar silhouettes are returned in the parametric domain of Srf.

Example:

pSil = polarsil( glass, vector( 1, 0, 0 ), true );

See figure for this example.

FIGURE: Polar silhouette computed for this glass shaped surface using the POLARSIL

POLY

PolygonType POLY( ListType VrtxList, NumericType IsPolyline )

creates a single polygon/polyline (and therefore open) object, defined by the vertices in VrtxList (see LIST). All elements in VrtxList must be one of PointType, VectorType, CtlPtType, or PolygonType types. If IsPolyline, a polyline is created; otherwise, a polygon.

Example:

V1 = vector( 0.0, 0.0, 0.0 ); V2 = vector( 0.3, 0.0, 0.0 ); V3 = vector( 0.3, 0.0, 0.1 ); V4 = vector( 0.2, 0.0, 0.1 ); V5 = vector( 0.2, 0.0, 0.5 ); V6 = vector( 0.3, 0.0, 0.5 ); V7 = vector( 0.3, 0.0, 0.6 ); V8 = vector( 0.0, 0.0, 0.6 ); V9 = vector( 0.0, 0.0, 0.5 ); V10 = vector( 0.1, 0.0, 0.5 ); V11 = vector( 0.1, 0.0, 0.1 ); V12 = vector( 0.0, 0.0, 0.1 ); I = POLY( list( V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12 ), FALSE );

constructs an object with a single polygon in the shape of the letter I.

FIGURE: Polygons or polylines can be manually constructed using the POLY constructor.

POLYHOLES

PolygonType POLYHOLES( PolygonType OuterPoly, PolygonType Island ) or PolygonType POLYHOLES( PolygonType OuterPoly, ListType Islands )

merges the given Island(s) into the main polygon OuterPoly, creating a polygon with holes. The outer polygon OuterPoly is assumed to be oriented in the opposite direction to that of the Island(s).

PPINCLUDE

NumericType PPINCLUDE( PolyType Pl, PointType Pt )

tests if a point Pt is inside a 3D closed polyhedra Pl in 3-space or if a point Pt is inside a 2D closed polygon Pl in 2-space, if Pl contains only one (planar) polygon. Returns TRUE if inside, FALSE otherwise.

Example:

if ( PPINCLUDE( Pl, pt ), ... );

See also CPINCLUDE.

PPINTER

ListType PPINTER( PolyType Pl1, PolyType Pl2 )

computes the intersection of two individual polygons in R3, Pl1 and Pl2. Similar results can also be obtained via Boolean operations.

Example:

Pl1 = poly( list( point( -1, -1, 0 ), point( -1, 1, 0 ), point( 1, 1, 0 ), point( 1, -1, 0 ) ), false ); Pl2 = Pl1 * rx( 70 ) * tx( 0.5 ); Inter1 = PPINTER( Pl1, Pl2 ); iritstate( "intercrv", true ); Inter2 = Pl1 * Pl2;

computes the intersection edge of two polygons in two different ways. Note, however, that while PPINTER considers only the first polygon in a polygonal object, the Boolean operations considers them all.

PPROPFTCH

PolyType PPROPFTCH( PolyType Pl, NumericType PropType, ListType PropParam )

computes piecwise linear curves over polygonal mesh Pl. The extracted curves could be one of,

Property	PropType	PropParam
Attribute Value	0	list( AttrName, AttrValue )
Isophotes	1	list( ViewDir, InclinationAngle )
Gaussian Crvtr	2	list( NumRingCrvtrAprx, CrvtrVal )
Mean Crvtr	3	list( NumRingCrvtrAprx, CrvtrVal )

The NumRingCrvtrAprx specifies how many rings around a vertex should be considered when the curvature of the vertex is estimated. Typically 1.

Example:

Pl1 = PPropFtch( Srf, 1, list( normalize( vector( 1, 1, 1 ) ), 90 ) ); Pl2 = PPropFtch( Srf, 1, list( normalize( vector( 1, -1, 1 ) ), 90 ) ); Pl3 = PPropFtch( Srf, 1, list( normalize( vector( 1, 0, 1 ) ), 90 ) );

extracts silhouettes from surface Srf (note an InclinationAngle of 90 degrees extract silhouettes), from three different viewing direction. See also PCRVTR, SILHOUETTE, ISOCLINE, PPROPFTCH and SASPCTGRPH.

PRINTER

ListType PRINTER( PolyType Pl, NumericType RayPt, NumericType RayDir )

computes the number of XY planar intersection of ray (RayPt, RayDir) with a single polygon Pl. Returned is the number of interesections found.

PRISA

ListType PRISA( SurfaceType Srfs, NumericType SamplesPerCurve, NumericType Epsilon, ConstantType Dir, VectorType Space, NumericType CrossSecs ) or ListType PRISA( TrimSrfType TrimSrfs, NumericType SamplesPerCurve, NumericType Epsilon, ConstantType Dir, VectorType Space, NumericType CrossSecs )

compute a layout (prisa) of the given surface(s) Srfs or {TrimSrfs}, and return a list of (trimmed) surface objects representing the layout. The surface is approximated to within Epsilon in direction Dir into a set of ruled surfaces, and then developable surfaces that are laid out flat onto the XY plane. If Epsilon is negative, the piecewise ruled surface approximation in 3-space is returned. SamplesPerCurve controls the piecewise linear approximation of the boundary of the ruled/developable surfaces. Space is a vector whose X component controls the space between the different surfaces' layout, and whose Y component controls the space between different layout pieces. If CrossSecs is not zero, the 3D cross sections, approximated as planar, of each laid out region are also provided.

Example:

cross = cbspline( 3, list( ctlpt( E3, 0.7, 0.0, 0. ), ctlpt( E3, 0.7, 0.0, 0.06 ), ctlpt( E3, 0.1, 0.0, 0.1 ), ctlpt( E3, 0.1, 0.0, 0.6 ), ctlpt( E3, 0.6, 0.0, 0.6 ), ctlpt( E3, 0.8, 0.0, 0.8 ), ctlpt( E3, 0.8, 0.0, 1.4 ), ctlpt( E3, 0.6, 0.0, 1.6 ) ), list( KV_OPEN ) ); wglass = surfrev( cross ); wgl_ruled = PRISA( wglass, 6, -0.1, COL, vector( 0, 0.25, 0.0 ), false ); wgl_prisa = PRISA( wglass, 6, 0.1, COL, vector( 0, 0.25, 0.0 ), true );

computes a layout of a wine glass in wgl_prisa and a three-dimensional ruled surface approximation of wglass in wgl_ruled.

FIGURE: The layout (prisa in hebrew...) of a freeform surface can be approximated using the PRISA function.

PT3BARY

VectorType PT3BARY( PointType Pt1, PointType Pt2, PointType Pt3, PointType InteriorPt )

computes the barycentric coordinates of InterPt with respect to the triangle defined by Pt1, Pt2, Pt3. A vector of three coefficents, which are the weights of the three points of the triangle, are returned. InteriorPt is assumed to be in the triangle.

Example:

Coeffs = PT3BARY( point( 0, 0, 0 ), point( 1, 0, 0 ), point( 0, 1, 0 ), point( 0.25, 0.25, 0.0 ) );

PTHMSPR

ListType PTHMSPR( NumericType Size )

computes a fairly uniform distribution of points on a hemisphere. Size hints at the distance between adjacent placed points.

Example:

Pts = PTHMSPR( 0.1 );

PTLNPLN

VectorType PTLNPLN( PointType LineOrig, VectorType LineRay, PlaneType Plane )

computes the point of intersection of given line LineOrig, LineRay with plane Plane.

Example:

InterPt = PtLnPln( point( 1, 0, 1 ), vector( 1, 1, 1 ), Plane( 0, 0, 1, 0 ) );

PTPTLN

VectorType PTPTLN( PointType Point, PointType LineOrig, VectorType LineRay )

computes the point on line LineOrig, LineRay that is closest to point Point. See also DSTPTLN.

Example:

ClosestPt = PTPTLN( point( 0, 0, 0 ), point( 1, 1, 0 ), vector( 1, 1, 1 ) );

PTREGISTER

MatrixType PTREGISTER( ListType PtSet1, ListType PtSet2, NumericType StepSize, NumericType Tolerance )

registers one points set, PtSet1, with another, PtSet2. The two points sets are assumed to be rigid motion of one another. StepSize controls the step size of the numerical process and must be a positive real less than 1.0. The larger StepSize is, the faster the convergance with less stability. Finally, Tolerance prescribes the necessary accuraacy in L-infinity sense. This function will converge for small rotational deviations only.

Pt1 = nil(); for (i = 0, 1, 15, Pt = point( random( -.7, .7 ), random( -.7, .7 ), random( -.7, .7 ) ): snoc( Pt * tx( 0 ), Pt1 ) ); Pt2 = Pt1 * rx( 13 ) * ry( 5 ) * rz( 11 ) * tx( 0.1 ) * ty( 0.03 ) * tz( -0.05 ); Tr = PTREGISTER( Pt1, Pt2, 1, 1e-6 );

PTS2PLLN

ListType PTS2PLLN( ListType Points, NumericType MaxMatchDist )

matches the given cloud of points in a list of polylines. MaxMatchDist is used as the maximal distance between two adjacent points to connect.

Example:

Pts = nil(); for ( i = 0, 1, 100, t = random( 0, 2 * Pi ): snoc( point( cos( t ), sin( t ), 0 ), Pts ) ); Pll = PTS2PLLN( Pts, 0.1 );

connects 100 random points on the unit circle into a polyline approximating an (almost) complete circle.

PTS2PLYS

PolylineType PTS2PLYS( ListType Points, NumericType MergeTol )

merges a list of points Points to polylines. Merges the points until two adjacent points are at most MergeTol apart. Points is a list of with PointType or CtlPtType. In the later case the control point can be of arbitrary dimension.

PTSLNLN

ListType PTSLNLN( PointType Line1Orig, VectorType Line1Ray, PointType Line2Orig, VectorType Line2Ray )

computes the closest two points on the two lines defined by point LineiOrig and ray LineiRay. See also DSTLNLN. A list object with the two points is returned.

Example:

ClosestPts = PtsLnLn( point( 1, 0, 0 ), vector( 0, 1, 0 ), point( 0, 1, 0 ), vector( 1, 0, 0 ) );

QUADCRVS

ListType QUADCRVS( CurveType Crv, NumericType Tolerance, NumericType MaxLen )

approximates given curve Crv using piecewise quadratic curves upto the prescribed tolerance Tolerance. If MaxLen is positive it is used to limit the arc length of the cubic curves segments.

Example:

PQaudCrv = QUADCRVS( Crv, 0.01, 0.5 );

creates a piecewise quadratic approximation to curve Crv upto tolerance 0.01 and maximal arc length of cubic segments of 0.5. See also CUBICCRVS, CBIARCS.

QUADRIC

ListType QUADRIC( ListType ABCDEFGHIJ ) ) or ListType QUADRIC( ListType ABCDEFZ ) )

in the first form, constructs a quadric parametric surface whose coefficients are the ten coefficients in the list ABCDEFGHIJ:

    A x^2 + B y^2 + C z^2 + D xy + E xz + F yz + G x + H y + I z + J = 0.

In the second form, promotes the given conic curve whose coefficients are the first six coefficients in the list ABCDEFZ:

    A x^2 + B xy + C y^2 + D x + E y + F = 0.

into a quadric surface with height in z of Z amount, the seven'th list element.

Example:

Sph = QUADRIC( list( 1, 1 , 1 , 0, 0, 0, 0, 0, 0, -1 ) ); Hyp1s = QUADRIC( list( 1, 1, -1, 0, 0, 0, 0, 0, 0, -1 ) ); Hyp2s = QUADRIC( list( 1, -1, -1, 0, 0, 0, 0, 0, 0, -1 ) ); Ellipse = list( 1, 0, 2, 0, 0, -1 ): Ellipsoid = QUADRIC( Ellipse + list( 0.1 ) );

constructs four quadric surfaces, a sphere, a portion of a hyperboloid of one sheet, a portion of a hyperboloid of two sheets, and promotes an ellipse to an ellipsoid of Z height of 0.1. Note only elliptic surfaces are compact and are reconstructed in whole. Because the parametrization of the quadric is predetermined, one might need to use SREGION and SMOEBIUS to extract subregions and/or reparametrize the surface.

See also CONICSEC, IMPLCTTRANS, ELLIPSE3PT.

RAYTRAPS

ListType RAYTRAPS( ListType Crvs, NumericType Orient NumericType SubdivTol, NumericType NumerTol, NumericType UserExprTree ) or ListType RAYTRAPS( ListType Srfs, NumericType Orient NumericType SubdivTol, NumericType NumerTol, NumericType UserExprTree )

computes locations on the given planar curves or 3-space surfaces that would bounce rays from one object to the next, in an infinite cycle. Such traps are denoted ray traps. Ray-traps are computed for the given list of Crvs or Srfs, in the given order. The ray-trap problem is posed as a set of n multivariate algebraic constraints with n variables, given n objects prescribed in Crvs or Srfs. The simultaneous solution of these constraints is computed using the MZERO function. See MZERO for the meaning of the SubdivTol and NumerTol tolerances. If Orient, attempt is made to orient the curves/surfaces which is likely to speed up the process. If UserExprTree, expression trees constraints are used instead of tensor products. Again, typically faster and much less memory use.

Example:

Crv1 = pcircle( vector( -0.75, -0.75, 0 ), 0.5 ); Crv2 = Crv1 * sc( 1.5 ) * tx( 2 ); Crv3 = Crv1 * sc( 0.5 ) * tx( 0.2 ) * ty( 0.6 ); Tris = RayTraps( list( Crv1, Crv2, Crv3 ), 0.1, -1e-6 );

computes the ray-traps between three circles.

FIGURE: Computes all ray-traps between three circles, using RAYTRAPS.

RFLCTLN

ListType RFLCTLN( SurfaceType Srf, VectorType ViewDir, ListType LinesSprs, NumericType Euclidean )

computes reflection lines/ovals to the given surface Srf as seen from view direction ViewDir. The resulting piecewise linear curves are in Euclidean space if Euclidean is TRUE and in Srf parameter space, otherwise.

The reflection/ovals themselves are defined via LinesSprs. For reflection lines, LinesSprs consists of

list( LineDir, list( LinePos1, LinePos2, ... , LinePosN ) );

defining n parallel lines with direction LineDir through point LinePos1 to LinePosN.

For reflection ovals, LinesSprs consists of

list( SprCntr, list( Rad1, Rad2, ... , RadN ) );

defining n co-spherical spheres, all located at SprCntr with radii of Rad1 to RadN.

Example:

resolution = 20; RefLns = RflctLn( Srf, vector( 0, 1, 2 ), list( vector( 0, 0, 1 ), list( point( -3.0, 2, 0 ), point( -1.5, 2, 0 ), point( 0.0, 2, 0 ), point( 1.5, 2, 0 ), point( 3.0, 2, 0 ) ) ), true ); RefOvals = RflctLn( Srf, vector( 1, 1, 0 ), list( point( 0, 2, 0 ), list( 5, 25, 45, 65, 85 ) ), true );

computes the reflection lines of surface Srf from viewing direction ( 0, 1, 2 ) having five reflected lines and computes five reflection ovals from viewing direction ( 1, 1, 0 ). See also ReflectLns attributes in the display devices.

RRINTER

ListType RRINTER( CurveType Srf1Crv1, CurveType Srf1Crv2, CurveType Srf2Crv1, CurveType Srf2Crv2, NumericType Tolerance, NumericType ZeroSetFunc )

computes the intersection curves of the given two ruled surfaces, defined as

       SrfiCrv1 * v + SrfiCrv2 * (1 - v)", i = 1, 2, v in [0,1].

The ruled ruled intersection (RRI) problem is tranformed into a zero set finding on another function. If ZeroSetFunc is true, the function whose zero set provides the RRIsolution is returned. Otherwise, if ZeroSetFunc is false, the RRI solution itself is returned. The zero set is computed via numerical zero set finding methods and Tolerance controls the fineness of the approximated solution. If Tolerance is negative, the absolute value is employed as Tolerance but the intersection curves are computed as if the two ruled surfaces are infinite (i.e. v is unbounded).

FIGURE: Computation of the intersection curve between two ruled surfaces via the RRINTER command. On the left, the four intersection curves are shown, while (right) shows the computed function whose zero set provides the request RRI solution.

Example:

c1 = cbezier( list( ctlpt( E3, -1.0, -1.0, -1.0 ), ctlpt( E3, -0.5, 8.0, -1.0 ), ctlpt( E3, 0.0, -15.0, -1.0 ), ctlpt( E3, 0.5, 8.0, -1.0 ), ctlpt( E3, 1.0, -1.0, -1.0 ) ) ); c2 = c1 * sc( 0.7 ) * tz( 1.7 ); r1 = ruledSrf( c1, c2 ); c1 = pcircle( vector( 0, 0, 0 ), 0.3 ) * tz( 2 ); c2 = c1 * sc( 0.5 ) * tz( -3 ); r2 = ruledSrf( c1, c2 ) * ry( 90 ); c = RRINTER( cMesh( r1, row, 0 ), cMesh( r1, row, 1 ), cMesh( r2, row, 0 ), cMesh( r2, row, 1 ), 25, false ); interact( list( r1, r2, nth( c, 1 ) ) );

See also SSINTER, SSINTR2 and GGINTER.

RULEDSRF

SurfaceType RULEDSRF( CurveType Crv1, CurveType Crv2 ) or PolygonType RULEDSRF( PolygonType Poly1, PolygonType Poly2 )

construct a ruled surface between the two curves Crv1 and Crv2 or two polylines Poly1 and Poly2. The curves do not have to have the same order or type, and will be promoted to their least common denominator. The polys must have the same number of points and both must be either polygons or polylines.

Example:

c1 = cbspline( 3, list( ctlpt(E3, 1.7, 0.0 , 0 ), ctlpt(E3, 0.7, 0.7 , 0 ), ctlpt(E3, 1.7, 0.3 , 0 ), ctlpt(E3, 1.5, 0.8 , 0 ), ctlpt(E3, 1.6, 1.0 , 0 ) ), list( KV_OPEN ) ); c2 = cbspline( 3, list( ctlpt(E3, 0.7, 0.0 , 0 ), ctlpt(E3,-0.7, 0.2 , 0 ), ctlpt(E3, 0.7, 0.5 , 0 ), ctlpt(E3,-0.7, 0.7 , 0 ), ctlpt(E3, 0.7, 1.0 , 0 ) ) , list( KV_OPEN ) ); srf1 = RULEDSRF( c1, c2 ); interact( list( c1, c2, srf1 ), on ); c2a = ffmatch( c1, c2, 50, 100, 2, false, 1 ); srf2 = RULEDSRF( c1, c2a ); interact( list( c1, c2, srf2 ), on );

constructs a planar ruled surface between two curves, c1 and c2. The naive construction causes self intersection, but by employing FFMATCH the self intersection can be resolved.

FIGURE: A naive construction of a ruled surface (left) using RULEDSRF results in self intersection. FFMATCH is employed (right) to automatically resolve this self intersection.

See also FFMATCH.

RULEDTV

TrivarType RULEDTV( SurfaceType Srf1, SurfaceType Srf2 )

constructs a ruled trivariate between the two surfaces Srf1 and Srf2. The surfaces do not have to have the same order or type, and will be promoted to their least common denominator.

Example:

s1 = boolone( pcircle( vector( 0, 0, 0 ), 1 ) ); s2 = boolone( pcircle( vector( 0, 0, 1 ), 0.5 ) ); tv = RULEDTV( s1, s2 );

constructs a truncated cone-volume as a ruled trivariate between two surfaces, s1 and s2.

FIGURE: A ruled volume as a trivariate between two disc surfaces, created via the RULEDTV function.

See also EXTRUDE, TFROMSRFS.

SACCESS

ListType SACCESS( SurfaceType AccessSrf, AnyType OrientFieldSrf, SurfaceType CheckSrf, AnyType AccessLimitDir, NumericType SubdivTol, NumericType NumericTol )

computes the domain on the AccessSrf surface that is accessible from the orientation that is optionally prescribed by OrientFieldSrf, without gouging into the CheckSrf surface. If OrientFieldSrf is not a surface, the normal field of AccessSrf is employed. AccessSrf and OrientFieldSrf must share a (u, v) domain, whereas CheckSrf can present a different (s, t) domain.

If AccessLimitDir is indeed a vector, the access is limited for direction V such that the inner product of V and AccessLimitDir is positive.

The accuracy of the computation is governed by a two stage solution, a subdivision stage with tolerance SubdivTol followed by a numerical improvement stage with NumericTol accuracy. The second, numeric, stage is invoked only if NumericTol < SubdivTol.

The returned results are a set of points on the boundary of the accessible region. The points are in E4 space as (u, v, s, t) 4-tuples.

Example:

c = cregion( pcircle( vector( 0, 0, 0 ), 1 ), 1, 3 ) * ry( 90 ); pSphere = surfPRev( c ) * sc( 0.3 ) * tz( 1 ); Pln = ruledSrf( ctlpt( E3, -1, -1, 0 ) + ctlpt( E3, -1, 1, 0 ), ctlpt( E3, 1, -1, 0 ) + ctlpt( E3, 1, 1, 0 ) ); Pts = SACCESS( Pln, 0, pSphere, 0, 0.1, 1e-5 ); sPts = nil(); sPtsErr = nil(); for ( i = 1, 1, sizeof( Pts ), Pt = nth( Pts, i ): Err = getAttr( Pt, "Error"): if ( Err > 1e-5, snoc( seval( Pln, coord( Pt, 1 ), coord( Pt, 2 ) ), sPtsErr ), snoc( seval( Pln, coord( Pt, 1 ), coord( Pt, 2 ) ), sPts ) ) ); color( sPts, green ); color( sPtsErr, red ); interact( list( pSphere, Pln, sPts, sPtsErr ) );

computes the access domain of plane Pln along the normal, Z, direction while preventing gouging into the check surface pSphere.

FIGURE: The limit of the accessible area of the plane along the normal direction, without gouging into the sphere is computed and presented using the SACCESS function.
See MZERO for the meaning of SubdivTol and NumerTol.

SASPCTGRPH

PolyType SASPCTGRPH( SurfaceType Srf )

approximates the aspect graph of surface Srf by computing the principal directions with zero curvature at the parabolic points of Srf. The aspect graph is defined over the unit sphere and identifies all direction from which the silhouette curves of Srf change topology.

Example:

AG = SAspctGrph( Srf );

See also SILHOUETTE.

SASYMPEVAL

ListType SASYMPEVAL( SurfaceType Srf, NumericType U, NumericType V, NumericType Euclidean )

evalutes the asymptotic direction of surface Srf at parametric location (U, V), if any. If Euclidean is not zero, the directions are returned in Euclidean space, otherwise, in parametric space. Returned is a list of upto two vectors.

Example:

AsympDir = SAsympEval( Srf, u, v, true );

See also SCRVTR.

SBEZIER

SurfaceType SBEZIER( ListType CtlMesh )

creates a Bezier surface using the provided control mesh. CtlMesh is a list of rows, each of which is a list of control points. All control points must be of type (E1-E9, P1-P9), or regular PointType defining the surface's control mesh. The surface's point type will be of a space which is the union of the spaces of all points.

Example:

Srf = SBEZIER( list ( list( ctlpt( E3, 0.0, 0.0, 1.0 ), ctlpt( E3, 0.0, 1.0, 0.0 ), ctlpt( E3, 0.0, 2.0, 1.0 ) ), list( ctlpt( E3, 1.0, 0.0, 0.0 ), ctlpt( E3, 1.0, 1.0, 2.0 ), ctlpt( E3, 1.0, 2.0, 0.0 ) ), list( ctlpt( E3, 2.0, 0.0, 2.0 ), ctlpt( E3, 2.0, 1.0, 0.0 ), ctlpt( E3, 2.0, 2.0, 2.0 ) ), list( ctlpt( E3, 3.0, 0.0, 0.0 ), ctlpt( E3, 3.0, 1.0, 2.0 ), ctlpt( E3, 3.0, 2.0, 0.0 ) ), list( ctlpt( E3, 4.0, 0.0, 1.0 ), ctlpt( E3, 4.0, 1.0, 0.0 ), ctlpt( E3, 4.0, 2.0, 1.0 ) ) ) );

FIGURE: A Bezier surface (left) of degree 3 by 5 and a B-spline surface (right) of degree 3 by 3 (bi-quadratic). Both share the same control mesh.
See also CBEZIER, SBSPLINE and SPOWER.

SBISECTOR

SurfaceType SBISECTOR( SurfaceType Srf, PointType Pt )

computes the bisector surface of a given surface to a point. See also CBISECTOR2D, CBISECTOR3D.

Example:

s = ruledSrf( ctlpt( E3, -1.0, -1.0, 0.0 ) + ctlpt( E3, 1.0, -1.0, 0.0 ), ctlpt( E3, -1.0, 1.0, 0.0 ) + ctlpt( E3, 1.0, 1.0, 0.0 ) ); pt = point( 0.0, 0.0, 1.0 ); bisect = SBISECTOR( s, pt ); interact( list( s, pt, bisect ) );

computes the bisector surface of a plane and a point.

FIGURE: (a) Bisector surface of a plane and a point computed using the SBISECTOR command.

SBSPLINE

SurfaceType SBSPLINE( NumericType UOrder, NumericType VOrder, ListType CtlMesh, ListType KnotVectors )

creates a B-spline surface from the provided UOrder and VOrder orders, the control mesh CtlMesh, and the two knot vectors KnotVectors. CtlMesh is a list of rows, each of which is a list of control points. All control points must be of point type (E1-E9, P1-P9), or regular PointType defining the surface's control mesh. The surface's point type will be of a space which is the union of the spaces of all points. KnotVectors is a list of two knot vectors. Each knot vector is a list of NumericType knots of length #CtlPtList plus the Order. If, however, the length of the knot vector is equal to #CtlPtList + Order + Order - 1}, the curve is assumed to be periodic. The knot vector may also be a list of a single constant KV_OPEN or KV_FLOAT or KV_PERIODIC, in which a uniform knot vector with the appropriate length and with an open, floating or periodic end condition will be constructed automatically.

Example:

Mesh = list ( list( ctlpt( E3, 0.0, 0.0, 1.0 ), ctlpt( E3, 0.0, 1.0, 0.0 ), ctlpt( E3, 0.0, 2.0, 1.0 ) ), list( ctlpt( E3, 1.0, 0.0, 0.0 ), ctlpt( E3, 1.0, 1.0, 2.0 ), ctlpt( E3, 1.0, 2.0, 0.0 ) ), list( ctlpt( E3, 2.0, 0.0, 2.0 ), ctlpt( E3, 2.0, 1.0, 0.0 ), ctlpt( E3, 2.0, 2.0, 2.0 ) ), list( ctlpt( E3, 3.0, 0.0, 0.0 ), ctlpt( E3, 3.0, 1.0, 2.0 ), ctlpt( E3, 3.0, 2.0, 0.0 ) ), list( ctlpt( E3, 4.0, 0.0, 1.0 ), ctlpt( E3, 4.0, 1.0, 0.0 ), ctlpt( E3, 4.0, 2.0, 1.0 ) ) ); Srf = SBSPLINE( 3, 3, Mesh, list( list( KV_OPEN ), list( 3, 3, 3, 4, 5, 6, 6, 6 ) ) );

constructs a bi-quadratic B-spline surface with its first knot vector having a uniform knot spacing with open end conditions.

See also CBSPLINE, SBEZIER and SPOWER.

SCRVTR

SurfaceType SCRVTR( SurfaceType Srf, ConstType PtType, ConstType Dir )

symbolically computes the extreme curvature bound on Srf. If Dir is either ROW or COL, then the normal curvature square of Srf in Dir is computed symbolically and returned. Otherwise, an upper bound on the sum of the squares of the two principle curvatures is symbolically computed and returned.

The returned value is a surface that can be evaluated to the curvature bound, given a UV location. The returned surface value is a scalar field of point type P1 (scalar rational). However, if PtType is one of E1, P1, E3, or P3, the returned surface is coerced to this given type. If the types are one of E3, or P3, then the Y and Z axes are set to be equivalent to the U and V parametric domains.

  This function computes the square of the normal curvature scalar

field for surfaces as (in the U parametric direction, same for V),

d S

             < n , --- >

   u               du

  k (u, v) = ------------

                dS   ds

              < -- , -- >

                du   du

and computes the sum of the squares of the principle curvatures as,

 2    2  ( g11 l22 + g22 l11 - 2 g12 l12 )^2 - 2 |G| |L|

k  + k = -----------------------------------------------

 1    2                   |G|^2 ||n||^2

See also CCRVTR, SCRVTREVAL, SASYMPEVAL.

Example:

cross = cbspline( 3, list( ctlpt( E2, 0.0, 0.0 ), ctlpt( E2, 0.8, 0.0 ), ctlpt( E2, 0.8, 0.2 ), ctlpt( E2, 0.07, 1.4 ), ctlpt( E2, -0.07, 1.4 ), ctlpt( E2, -0.8, 0.2 ), ctlpt( E2, -0.8, 0.0 ), ctlpt( E2, 0.0, 0.0 ) ), list( KV_OPEN ) ); cross = coerce( cross, e3 ); s = sFromCrvs( list( cross, cross * trans( vector( 0.5, 0, 1 ) ), cross * trans( vector( 0, 0, 2 ) ) ), 3, KV_OPEN ); view( list( s, axes ), on ); UCrvtrZXY = scrvtr( s, E3, row ); VCrvtrZXY = scrvtr( s, E3, col ); UCrvtrXYZ = UCrvtrZXY * rotx( -90 ) * roty( -90 ) * scale( vector( 1, 1, 0.001 ) ); VCrvtrXYZ = VCrvtrZXY * rotx( -90 ) * roty( -90 ) * scale( vector( 1, 1, 10 ) ); color( UCrvtrXYZ, red ); color( VCrvtrXYZ, magenta ); view( list( UCrvtrXYZ, VCrvtrXYZ ), off ); CrvtrZXY = scrvtr( s, E3, off ); CrvtrXYZ = CrvtrZXY * rotx( -90 ) * roty( -90 ) * scale( vector( 1, 1, 0.001 ) ); color( CrvtrXYZ, green ); view( CrvtrXYZ, off );

computes the square of the normal curvature in the U and V directions, flips its scalar value from X to Z using rotations and scales the fields to reasonable values, and then displays them. It also displays a total bound on the normal curvature.

Due to the large degree of the resulting fields, be aware that rational surfaces will compute into large degree curvature bound fields. See also IRITSTATE "InterpProd" option for faster symbolic computation.

FIGURE: From left to right: original surface, normal curvature in the U direction, normal curvature in the V direction, sum of the square of principle curvatures (different scales). All computed using SCRVTR.

SCRVTREVAL

ListType SCRVTREVAL( SurfaceType Srf, NumericType U, NumericType V, NumericType Euclidean )

computes the principle curvatures and directions of surface Srf at parametric location (U, V). A list of four elements (k1, V1, k2, V2), with k1/V1 being the first principle curvature/direction and k2/V2 being the second, is returned. If Euclidean is TRUE then the principle curvatures are returned in Euclidean space. Consecutive calls with the same surface Srf to SCRVTREVAL will yield more efficient evaluations as derivative data is cached.

Example:

Crvtr = SCRVTREVAL( Srf, 0.5, 0.5, True ); K = nth( Crvtr, 1 ) * nth( Crvtr, 3 );

computes the Total (Gaussian) curvatures, K = k1 * k2, of Srf at (0.5, 0.5). See also SCRVTR.

SDDMMAP

PolyType SDDMMAP( SurfaceType BaseSrf, PolyType Bump, NumericType UDup, NumericTye VDup, NumericTye LclUVs )

Tiles a composition of Bump over surface BaseSrf UDup by VDup times, creating a detailed bump geometry. Bump can be any polygonal geometry whatsoever with XY coordinates that are contained in the unit square [0, 1] x [0, 1], while Z serves as the elevation above the surface. The composed geometry could inherit the UV texture ccordinates from the UV coordinates found in Bump if LclUVs is TRUE or inherit BaseSrf UV coordinates if LclUVs is FALSE.

Example:

BaseTorus = torusSrf( 1, 0.2 ); BumpTorus = SDDMMAP( BaseTorus, BumpPolyObj, 6, 8, on );

constructs a bumpy BumpTorus with a bump tiled 6 x 8 times over the surface.

FIGURE: Polygonal geometry (left) could be tiled over arbitrary surface, torus in this case (middle), to yield a bumpy shape (right) using the SDDMMAP function.

SDERIVE

SurfaceType SDERIVE( SurfaceType Srf, NumericType Dir )

returns a vector field surface representing the differentiated surface in the given direction (ROW or COL). Evaluation of the returned surface at a given parameter value will return a vector tangent to Srf in Dir at that parameter value.

DuSrf = SDERIVE( Srf, ROW ); DvSrf = SDERIVE( Srf, COL ); Normal = coerce( seval( DuSrf, 0.5, 0.5 ), VECTOR_TYPE ) ^ coerce( seval( DvSrf, 0.5, 0.5 ), VECTOR_TYPE );

computes the two partial derivatives of the surface Srf and computes its normal as their cross product, at the parametric location (0.5, 0.5). See also CDERIVE, TDERIVE, and MDERIVE.

SDIVIDE

SurfaceType SDIVIDE( SurfaceType Srf, ConstantType Direction, NumericType Param ) or TrimSrfType SDIVIDE( TrimSrfType Srf, ConstantType Direction, NumericType Param )

subdivide a (possibly trimmed) surface into two at the specified parameter value Param in the specified Direction (ROW or COL). Srf can be either a B-spline surface in which Param must be contained in the parametric domain of the surface, or a Bezier surface in which Param} can be arbitrary, extrapolating if not in the range of zero to one.

It returns a list of upto two sub-surfaces. The individual surfaces may be extracted from the list using the NTH command. If Srf is a trimmed surface, it may be the case that one of the two subdivided surfaces is completely trimmed out, and hence only one surface will be returned.

Example:

SrfLst = SDIVIDE( Srf, ROW, 0.5 ); Srf1 = nth( SrfLst, 1 ); Srf2 = nth( SrfLst, 2 );

subdivides Srf at the parameter value of 0.5 in the ROW direction.

FIGURE: A surface can be subdivided into two distinct regions using SDIVIDE.
See also CDIVIDE, TDIVIDE, and MDIVIDE

SELFINTER

ListType SELFINTER( CurveType Crv, NumericType SubdivTol, NumericType NumerTol, NumericType MinNrmlDeviation, NumericType Euclidean ) or ListType SELFINTER( CurveType Crv, NumericType SubdivTol, NumericType NumerTol, NumericType MinNrmlDeviation, NumericType Euclidean )

computes the self intersection locations / curves of a given curve or surface. Returned is a list of points / piecewise linear curves. The returned locations, if in the parameteric space (see below), are pairs of parameter values along the curve in case of a curve and a 4-tuple holding the pair of surface location, in case of surfaces. See MZERO for the meaning of SubdivTol and NumerTol. If MinNrmlDeviation is positive it specifies the minimal deviation angle required for the two normal at the self intersection (of the two different interesecting locations), in degrees. If negative, a different approach algother is used that eliminates the redundant diagonal factor in the self intersection constraint. If Euclidean, the returned data is in Euclidean space. Otherwise, the returned data is in parameteric space.

Example:

si1 = selfinter( crv, 0.001, 1e-10, 15.0, true ); si2 = selfinter( crv, 0.001, 1e-10, -1.0, true );

SETCOVER

ListType SETCOVER( ListType RangesSet, NumericType OverlapTolerance )

computes the minimal subset of the given set RangesSet, that covers the entire domain spanned by RangesSet. A range is a list object with two numeric values, the start and end of this specific range. Each element in RangesSet can be either a range, or a list of ranges. OverlapTolerance specifies the tolerance to use in overlapping ranges. Returned is a list of indices (first element zero) that prescribe the minimal coverage. Note that the former case of a single range per element is solved in an almost linear time whereas the later case of multiple ranges per element is exponential. Hence, do not attempt to find minimal coverage of more than a few elements in the later case.

Example:

Ranges = list( list( 0.0, 0.4 ), list( 0.1, 0.4 ), list( 0.3, 1.0 ), list( 0.1, 0.9 ) ); Indcs = SETCOVER( Ranges, 1e-7 );

and SETCOVER should return "list( 0, 2 )", the two indices of the ranges that cover this domain of [0, 1]. See also CVISIBLE.

SEDITPT

SurfaceType SEDITPT( SurfaceType Srf, CtlPtType CPt, NumericType UIndex, NumericType VIndex )

provides a simple mechanism to manually modify a single control point number UIndex and VIndex (base count is 0) in the control mesh of Srf by substituting CtlPt instead. CtlPt must have the same point type as the control points of Srf. The original surface Srf is not modified.

Example:

CPt = ctlpt( E3, 1, 2, 3 ); NewSrf = SEDITPT( Srf, CPt, 0, 0 );

constructs a NewSrf with the first control point of Srf being CPt.

SEVAL

CtlPtType SEVAL( SurfaceType Srf, NumericType UParam, NumericType VParam ) or CtlPtType SEVAL( TrimSrfType Srf, NumericType UParam, NumericType VParam )

evaluates the provided (possibly trimmed) surface Srf at the given UParam and VParam parameters. Both UParam and VParam should be contained in the surface parametric domain if Srf is a B-spline surface, or between zero and one if Srf is a Bezier surface. The returned control point has the same type as the control points of Srf.

Example:

CPt = SEVAL( Srf, 0.25, 0.22 );

evaluates Srf at the parameter values of (0.25, 0.22). See also CEVAL, MEVAL, TEVAL.

SFLECNODAL

SurfaceType SFLECNODAL( SurfaceType Srf, NumericType SubdivTol, NumericType NumericTol, NumericType MergeTol, NumericType ContactOrder )

computes the flecnodal curves over a given freeform geometry, Srf. The flecnodal curves are curves of contact of order four with a line in an asymptotic direction. SubdivTol and NumericTol controls the subdivision and numeric tolerances of the approximation. Typically the subdivision tolerance is fairly coarse. MergeTol prescribes the tolerance of merging individual points into polylines. A negative value will prescribe no merge. The ContactOrder should be 3 to compute flecnodal curves and 4 to compute flecnodal points.

Example:

flecs = SFlecnodal( srf, 0.05, -1e-6, 1e-1, 3 );

See MZERO for the meaning of SubdivTol and NumerTol.

SFOCAL

SurfaceType SFOCAL( SurfaceType Srf, NumericType Dir )

evaluates the focal surface field of surface Srf using the normal curvature in the isoparametric direction as given by Dir (either ROW or COL). Note this function is not using the principal curvatures as is generaly the case for focal surfaces.

Example:

gcross = cbspline( 3, list( ctlpt( E3, 0.3, 0.0, 0.0 ), ctlpt( E3, 0.1, 0.0, 0.1 ), ctlpt( E3, 0.1, 0.0, 0.4 ), ctlpt( E3, 0.5, 0.0, 0.5 ), ctlpt( E3, 0.6, 0.0, 0.8 ) ), list( KV_OPEN ) ); glass = surfprev( gcross ); color( glass, red ); gfocal = SFOCAL(glass, col);

evaluates the focal surface using the COL isoparametric direction's normal curvature of the glass surface.

FIGURE: A focal surface (right) of a glass surface (left) can be computed using SFOCAL.

SFROMCRVS

SurfaceType SFROMCRVS( ListType CrvList, NumericType OtherOrder, NumericType OtherEndCond )

constructs a surface by substituting the curves in CrvList as rows in a control mesh of a surface. The curves in CrvList are made compatible by promoting Bezier curves to B-splines if necessary, and raising the degrees and refining as required before substituting the control polygons of the curves as rows in the mesh. The other direction order is set by OtherOrder, which cannot be larger than the number of curves. If B-spline (OtherOrder is smaller than number of curves) end conditions are set via OtherEndCond and can be one of KV_OPEN, KV_FLOAT or KV_PERIODIC.

The surface interpolates the first and last curves only, if a Bezier or open end conditions are selected; otherwise, no curve is interpolated.

Example:

Crv1 = cbspline( 3, list( ctlpt( E3, 0.0, 0.0, 0.0 ), ctlpt( E3, 1.0, 0.0, 0.0 ), ctlpt( E3, 1.0, 1.0, 0.0 ) ), list( KV_OPEN ) ); Crv2 = Crv1 * trans( vector( 0.0, 0.0, 1.0 ) ); Crv3 = Crv2 * trans( vector( 0.0, 1.0, 0.0 ) ); Srf = SFROMCRVS( list( Crv1, Crv2, Crv3 ), 3, KV_OPEN );

FIGURE: A surface can be constructed from a list of curves substituted as rows into its mesh using SFROMCRVS. The surface does not necessarily interpolate the curves.

SGAUSS

SurfaceType SGAUSS( SurfaceType Srf, NumericType NumerOnly )

evaluates the Gaussian curvature (K) field of surface Srf. If NumerOnly is TRUE, only the numerator of the Gaussian curvature is derived. Otherwise, if NumerOnly is FALSE, the full exact Gaussian field is derived. NumerOnly TRUE may be used in cases where the zero set of K is needed (parabolic lines).

Example:

Srf1 = hermite( cbezier( list( ctlpt( E3, 0.0, 0.0, 0.0 ), ctlpt( E3, 0.5, 0.2, 0.0 ), ctlpt( E3, 1.0, 0.0, 0.0 ) ) ), cbezier( list( ctlpt( E3, 0.0, 1.0, 0.0 ), ctlpt( E3, 0.5, 0.8, 0.0 ), ctlpt( E3, 1.0, 1.0, 0.5 ) ) ), cbezier( list( ctlpt( E3, 0.0, 2.0, 0.0 ), ctlpt( E3, 0.0, 2.0, 0.0 ), ctlpt( E3, 0.0, 2.0, 0.0 ) ) ), cbezier( list( ctlpt( E3, 0.0, 2.0, 0.0 ), ctlpt( E3, 0.0, 2.0, 0.0 ), ctlpt( E3, 0.0, 2.0, 0.0 ) ) ) ); SGauss = SGAUSS( Srf1, false );

evaluates the Gaussian curvaure of Srf1.

FIGURE: The Gaussian curvature field (right) of the quadratic by cubic surface (left) is computed using SGAUSS. The Gaussian curvature field is scaled down to %1 to fit into the figure. Compare with figure~protectref{fig-smean}.
See also EVOLUTE and SMEAN.

SILHOUETTE

PolyType SILHOUETTE( SurfaceType Srf, VectorType ViewDir, NumericType Euc ) or PolyType SILHOUETTE( PolyType Pl, VectorType ViewDir, NumericType Euc )

compute the silhouette edges of the given Srf or Pl from the prescribed viewing direction ViewDir. The end result is a piecewise linear approximation of the exact silhouette, and its accuracy is controlled via the RESOLUTION variable, in the case of a freeform surface Srf. If Euc is TRUE, the silhouette curves are returned on the surface, in Euclidean space. Otherwise, the silhouette curves are returned in the parametric space of Srf. Both Euc and the RESOLUTION variables have no affect in the case of a polygonal model Pl.

Example:

Resolution = 10; Sils = SILHOUETTE( glass, vector( 1, -2, 1 ), true );

computes the silhouette curves of surface glass as viewed from viewing direction (1, -2, 1), and returns the silhouette curves in Euclidean space. See also ISOCLINE, PPROPFTCH and SASPCTGRPH.

SINTERP

SurfaceType SINTERP( ListType PtList, NumericType UOrder, NumericType VOrder, NumericType USize, NumericType VSize, ConstantType Param)

computes a B-spline polynomial surface that interpolates or approximates the rectangular grid or scattered set of points in PtList. The B-spline surface will have orders UOrder and VOrder and mesh of size USize by VSize control points. If the data is on a grid, the knots will be spaced according to Param which can be one of PARAM_UNIFORM, PARAM_CHORD, PARAM_CENTRIP or PARAM_NEILFOL. Currently, only PARAM_UNIFORM is supported. For a scattered point set, the Param parameter is ignored. PtList is a list of points for grid data in which all lists carry the same amount of points, thereby defining a rectangular grid. For scattered data, PtList is a linear list of points. All points in PtList must be of type (E1-E9, P1-P9) control point, or regular PointType. If USize and VSize are equal to the number of points in the grid data set of PtList, the resulting surface will interpolate the data set. Otherwise, if USize or VSize is less than the number of points in the grid of PtList, the point data set will be least square approximated. At no time can USize or VSize be larger that the number of points in PtList or lower than UOrder and VOrder, respectively. If USize or VSize are zero, the grid size is used, forcing an interpolation of the data set. If PtList contains a linear list of points, these points are treated as scattered. Each scattered point is assumed to be holding the parameteric location at which to interpolate its first two coefficients. The other coefficients are the interpolation values. In other words, to interpolate scattered data of type E3, E5 control points in a linear list must be provided in (u, v, x, y, z) format. Scattered data is interpolated over a unit square (0 to 1) parameteric domain in both u and v.

All interior knots will be distinctly preserving maximal continuity. The resulting B-spline surface will have open end conditions.

Example:

pl = nil(); pll = nil(); for ( x = -5, 1, 5, pl = nil(): for ( y = -5, 1, 5, snoc( point( x, y, sin( x * Pi / 2 ) * cos( y * Pi / 2 ) ), pl ) ): snoc( pl, pll ) ); s1 = SINTERP( pll, 3, 3, 8, 8, PARAM_UNIFORM ); s2 = SINTERP( pll, 3, 3, 11, 11, PARAM_UNIFORM );

samples an explicit surface sin(x) * cos(y) at a grid of 11 by 11 points, least square fit with a grid of size of 8 by 8 surface s1, and interpolates surface s2 using this data set. See also CINTERP and LINTERP.

FIGURE: A surface least square fitting a data set with insufficient degrees of freedom (left) and actually interpolating the data set (right), all using SINTERP.

SKEL2DINT

ListType SKEL2DINT( CurveType Crv1 | PointType Pt1 | CtlPtType Pt1, CurveType Crv2 | PointType Pt2 | CtlPtType Pt1, CurveType Crv3 | PointType Pt3 | CtlPtType Pt1, NumericType OutExtent, NumericType Epsilon, NumericType FineNess, ListType MZeroTols )

computes locations in the plane of points that are equadistant from the three given entities. Entities can be points or control points or curves, all in the XY plane. The equadistant points are computed as the mutual intersection of the bisectors of the entities. Infinite bisectors (such as the bisector of two points) are extended up to OutExtent. Epsilon controls the tolerances while FineNess controls the subdivision fineness in the bisector intersection computations. MZeroTols controls the subdivision/numeric tolerances of the MV solver, as a list of the two numeric tolerances.

Exanple:

Crv1 = pcircle( vector( -0.5, 0.7, 0.0 ), 0.3 ); Crv2 = pcircle( vector( -0.4, -0.6, 0.0 ), 0.5 ); Crv3 = pcircle( vector( 0.3, 0.2, 0.0 ), 0.4 ); EquaPt = SKEL2DINT( Crv1, Crv2, Crv3, 100, 0.1, 150, list( 1e-3, -1e-9 ) ):

computes the eight points that are equadistant to three circles.

FIGURE: Computes the eight points that are equadistant to three circles, using SKEL2DINT.
See also CRC2CRVTAN.

SMEAN

SurfaceType SMEAN( SurfaceType Srf, NumericType NumerOnly )

evaluates the mean curvature field of surface Srf as follows: if NumerOnly is true, it computes the numerator of only the Mean curvature. Otherwise, if NumerOnly is false, the square of the exact Mean curvature field is derived. NumerOnly TRUE may be used in cases where the zero set of H is needed (k1 == -k2 points).

Example:

Srf1 = hermite( cbezier( list( ctlpt( E3, 0.0, 0.0, 0.0 ), ctlpt( E3, 0.5, 0.2, 0.0 ), ctlpt( E3, 1.0, 0.0, 0.0 ) ) ), cbezier( list( ctlpt( E3, 0.0, 1.0, 0.0 ), ctlpt( E3, 0.5, 0.8, 0.0 ), ctlpt( E3, 1.0, 1.0, 0.5 ) ) ), cbezier( list( ctlpt( E3, 0.0, 2.0, 0.0 ), ctlpt( E3, 0.0, 2.0, 0.0 ), ctlpt( E3, 0.0, 2.0, 0.0 ) ) ), cbezier( list( ctlpt( E3, 0.0, 2.0, 0.0 ), ctlpt( E3, 0.0, 2.0, 0.0 ), ctlpt( E3, 0.0, 2.0, 0.0 ) ) ) ); SMean = SMEAN( Srf1, false );

evaluates the square of the mean curvature of Srf1.

FIGURE: The square of the mean curvature field (right) of the quadratic by cubic surface (left) is computed using SMEAN. The square of the mean curvature field is scaled down to %1 to fit into the figure. Compare with figure~protectref{fig-sgauss}.
See also EVOLUTE and SGAUSS.

SMERGE

SurfaceType SMERGE( SurfaceType Srf1, SurfaceType Srf2, NumericType Dir, NumericType SameEdge )

merges two surfaces along the requested direction (ROW or COL). If SameEdge is non-zero (ON or TRUE), then the common edge is assumed to be identical and copied only once. Otherwise (OFF or FALSE), a ruled surface is constructed between the two surfaces along the (not) common edge.

Example:

MergedSrf = SMERGE( Srf1, Srf2, ROW, TRUE );

See also MMERGE.

SMESH

SurfaceType SMESH( TrivarType TV, MumericType Dir, NumericType Index )

extracts a surface out of a trivariate, TV, as the Index's plane of the control mesh of TV in direction Dir. Dir can be one of COL, ROW, DEPTH.

Example:

tv = tbezier( list( list( list( ctlpt( E3, 0.1, 0.0, 0.8 ), ctlpt( E3, 0.2, 0.1, 2.4 ) ), list( ctlpt( E3, 0.3, 2.2, 0.2 ), ctlpt( E3, 0.4, 2.3, 2.0 ) ) ), list( list( ctlpt( E3, 2.4, 0.8, 0.1 ), ctlpt( E3, 2.2, 0.7, 2.3 ) ), list( ctlpt( E3, 2.3, 2.6, 0.5 ), ctlpt( E3, 2.1, 2.5, 2.7) ) ) ) ); s0 = SMESH( tv, col, 0 ); s1 = SMESH( tv, col, 1 );

extracts the two (first and last) planes in direction col out of trivariate tv.

See also STRIVAR, CMESH, MFROMMESH.

SMOEBIUS

CurveType SMOEBIUS( CurveType Crv, NumericType Ratio, NumericType Dir )

rebalances the weights of a rational surface using the Moebius transformation. The shape of the surface remains identical, while the speed is modified in the direction Dir. Ratio controls the ratio between the last and first weights of the first row/column. If Ratio = 0, the first and last weights are made equal.

See also CMOEBIUS.

SMOOTHNRML

ListType SMOOTHNRML( ListType Obj, NumericType MaxAngle ) or PolygonType SMOOTHNRML( PolygonType Obj, NumericType MaxAngle )

Given a (list of) polygonal object(s), Obj, compute normals to the vertices by averaging the normals of the polygons that share the vertices. Only vertices where the deviation between the polygons' normals and the averaged normal is less than MaxAngle are updated. If MaxAngle is negative, all vertices normals are cleared and all polygon normals reevaluated. This is useful for polygonal data sets that have no vertex normals.

Example:

A = box( vector( -1, -1, -1 ), 2, 2, 2 ); B = SMOOTHNRML( A, 90 );

computes average normals to a curve resulting in the smoothly shaded display of a cube. See also FIXPLNRML.

SMOMENTS

SurfaceType SMOMENTS( SurfaceType Srf, NumericType Moment, NumericType Axis1, NumericType Axis2, NumericType Eval ) or NumericType SMOMENTS( SurfaceType Srf, NumericType Moment, NumericType Axis1, NumericType Axis2, NumericType Eval )

compute the integral moment surface, MSrf, of the given surface Srf, up to a sign. The computed moment can be either a first order moment when Moment = 1, or a second order moment when Moment = 2. If Srf is a closed surface with domain (u0, v0) to (u1, v1), then the difference of MSrf(u1, v1) - MSrf(u0, v0) is the requested moment. Otherwise, the computation is for the volume occupied between the surface Srf and the XY plane. If Eval is TRUE, the actual numerical value of the moment is returned. The moment integral surface is returned if Eval is FALSE. Axis1 and Axis2 prescribe the two axes to compute the moments for a second order moment computation. For a first order moment computation only Axis1 is considered.

Example:

Spr = surfPRev( cregion( pcircle( vector( 0, 0, 0 ), 1 ), 1, 3 ) * ry( 90 ) ); SMOMENTS( Spr, 2, 1, 1, 2, 1 );

computes the second order XX moment of a polynomial approximation of a unit sphere, using method one. See also SVOLUME and CAREA.

SMORPH

SurfaceType SMORPH( SurfaceType Srf1, SurfaceType Srf2, NumericType Blend )

creates a new surface which is a convex blend of the two given surfaces. The two given surfaces must be compatible (see FFCOMPAT) before this blend is invoked. This is very useful if a sequence that "morphs" one surface to another is to be created.

Example:

for ( i = 0.0, 1.0, 11.0, Msrf = SMORPH( Srf1, Srf2, i / 11.0 ): color( Msrf, white ): attrib( Msrf, "rgb", "255,255,255" ): attrib( Msrf, "reflect", "0.7" ): save( "morp1-" + i, Msrf ) );

creates a sequence of 12 surfaces, morphed from Srf1 to Srf2 and saves them in the files "morph-0.itd" to "morph-11.itd". See also PMORPH, CMORPH and TMORPH.

FIGURE: A morphing sequence between a bottle and a glass. Snapshots computed using SMORPH.

SNORMAL

VectorType SNORMAL( SurfaceType Srf, NumericType UParam, NumericType VParam ) or VectorType SNORMAL( TrimSrfType Srf, NumericType UParam, NumericType VParam )

compute the normal vector to (possibly trimmed) surface Srf at the parameter values UParam and VParam. The returned vector has a unit length.

Example:

Normal = SNORMAL( Srf, 0.5, 0.5 );

computes the normal to Srf at the parameter values (0.5, 0.5). See also SNRMLSRF.

SNRMLSRF

SurfaceType SNRMLSRF( SurfaceType Srf )

symbolically computes a vector field surface representing the non-normalized normals of the given surface. That is, the normal surface, evaluated at (u, v), provides a vector in the direction of the normal of the original surface at (u, v). The normal surface is computed as the symbolic cross product of the two surfaces representing the partial derivatives of the original surface.

Example:

NrmlSrf = SNRMLSRF( Srf );

FIGURE: A vector field normal (right) computed for a unit sphere (left) using SNRMLSRF. The normal field degenerates at the north and south poles because the surface is not regular there.

SPARABOLC

ListType SPARABOLC( SurfaceType Srf, NumericType Euclidean )

computes the parabolic edges of a freeform surface, Srf, as the zero set of the Gaussian curvature. A scalar field with the sign of the Gauss curvature is computed and its zero is derived. If Euclidean is false, the list of (piecewise linear) parabolic curves is returned in the parametric space of Srf. Otherwise, if Euclidean is true, the parabolic curves are mapped onto Srf.

Example:

pl = nil(); pll = nil(); for ( x = -3, 1, 3, pl = nil(): for ( y = -3, 1, 3, snoc( point( x, y, sin( x * Pi / 2 ) * cos( y * Pi / 2 ) ), pl ) ): snoc( pl, pll ) ); EggBase = sinterp( pll, 4, 4, 0, 0, PARAM_UNIFORM ); Resolution = 15; Parab = SPARABOLC( EggBase, true );

constructs a surface in the shape of an egg carton's base and then derives its parabolic edges in Euclidean space.

SPHERE

PolygonType SPHERE( VectorType Center, NumericType Radius )

creates a SPHERE geometric object, defined by Center as the center of the SPHERE, and with Radius as the radius of the SPHERE. See RESOLUTION for accuracy of SPHERE approximation as a polygonal model. See IRITSTATE's "PrimRatSrfs" and "PrimRatSrfs" state variables.

SPLITLST

ListType SPLITLST( AnyType LinkedListObj )

splits an objected of several linked list data elements such as polygons, curves, or suraces, into a list object that contains an object for each of the individual objects.

Example:

ObjLst = SPLITLST( axes );

splits the axes object into a list object of several objects each holding a single polyline.

SPOWER

SurfaceType SPOWER( ListType CtlMesh )

creates a polynomial/rational surface out of the provided control mesh. The created surface employs the monomial power basis. CtlMesh is a list of rows, each of which is a list of control points. All control points must be of type (E1-E9, P1-P9), or regular PointType defining the surface's control mesh. The surface's point type will be of a space which is the union of the spaces of all points.

Example:

s = SPOWER( list( list( ctlpt( E3, 1, 0, 1 ), ctlpt( E3, 0, 1, 1 ) ), list( ctlpt( E3, 0, 0, 1 ), ctlpt( E3, 0, 0, 1 ) ) ) ); s == coerce( coerce( s, bezier_type ), power_type );

constructs a bilinear power basis surface, coerces it to a Bezier form, coerces the Bezier form back to a power basis, and then compares the result for equality.

See also CBEZIER, SBSPLINE and SPOWER.

SRADCRVTR

SurfaceType SRADCRVTR( SurfaceType Srf, VectorType ViewDir, NumericType SubdivTol, NumericType SubdivTol, NUmericType MergeTol )

computes the radial curvature of surface Srf, as viewed from view direction ViewDir. See MZERO for the meaning of the SubdivTol and NumerTol tolerances. MergeTol specifies the tolerance to use to merge points into polygons,

SRAISE

SurfaceType SRAISE( SurfaceType Srf, ConstantType Direction, NumericType NewOrder )

raises Srf to the specified NewOrder in the specified Direction.

Example:

Srf = ruledSrf( cbezier( list( ctlpt( E3, -0.5, -0.5, 0.0 ), ctlpt( E3, 0.5, -0.5, 0.0 ) ) ), cbezier( list( ctlpt( E3, -0.5, 0.5, 0.0 ), ctlpt( E3, 0.5, 0.5, 0.0 ) ) ) ); Srf = SRAISE( SRAISE( Srf, ROW, 3 ), COL, 3 );

constructs a bilinear flat-ruled surface and raises both its directions to be a bi-quadratic surface. See also TRAISE, MRAISE, and CRAISE.

SRAYCLIP

ListType SRAYCLIP( PointType Pt, VectorType Dir, SurfaceType Srf )

computes the intersection of ray (Pt, Dir) with Bezier surface Srf, using the Bezier clipping scheme. The returned list is of the form "list( NumInters, UV0, EucPt0, ..., UVn, EucPtn )".

Example:

InterPts = SRayClip( point( 0, 0, 0 ), vector( 0, 0, 1 ), Srf );

computes the intersection of surface Srf with the positive Z axis.

SREFINE

SurfaceType SREFINE( SurfaceType Srf, ConstantType Direction, NumericType Replace, ListType KnotList )

provides the ability to Replace a knot vector of Srf or refine it in the specified direction Direction (ROW or COL). KnotList is a list of knots at which to refine Srf. All knots should be contained in the parametric domain of Srf in Direction. If the knot vector is replaced, the length of KnotList should be identical to the length of the original knot vector of Srf in Direction. If Srf is a Bezier surface, it is automatically promoted to be a B-spline surface.

Example:

Srf = SREFINE( SREFINE( Srf, ROW, FALSE, list( 0.333, 0.667 ) ), COL, FALSE, list( 0.333, 0.667 ) );

refines Srf in both directions by adding two more knots at 0.333 and 0.667. See also CREFINE, TREFINE, and MREFINE.

SREGION

SurfaceType SREGION( SurfaceType Srf, ConstantType Direction, NumericType MinParam, NumericType MaxParam ) or TrimSrfType SREGION( TrimSrfType Srf, ConstantType Direction, NumericType MinParam, NumericType MaxParam )

extract a region of Srf between MinParam and MaxParam in the specified Direction. Both MinParam and MaxParam should be contained in the parametric domain of Srf in Direction, except for Bezier surfaces when MinParam and MaxParam can be arbitrary (extrapolating if not between zero and one).

Example:

Srf = ruledSrf( cbezier( list( ctlpt( E3, -0.5, -0.5, 0.5 ), ctlpt( E3, 0.0, 0.5, 0.0 ), ctlpt( E3, 0.5, -0.5, 0.0 ) ) ), cbezier( list( ctlpt( E3, -0.5, 0.5, 0.0 ), ctlpt( E3, 0.0, 0.0, 0.0 ), ctlpt( E3, 0.5, 0.5, 0.5 ) ) ) ); SubSrf = SREGION( Srf, ROW, 0.3, 0.6 );

extracts the region of Srf from the parameter value 0.3 to the parameter value 0.6 along the ROW direction. The COLumn direction is extracted as a whole.

FIGURE: A region can be extracted from a freeform surface using SREGION.
See also CREGION, TREGION, and MREGION.

SREPARAM

SurfaceType SREPARAM( SurfaceType Srf, ConstantType Direction, NumericType MinParam, NumericType MaxParam ) or TrimSrfType SREPARAM( TrimSrfType Srf, ConstantType Direction, NumericType MinParam, NumericType MaxParam )

reparametrize Srf over a new domain from MinParam to MaxParam, in the prescribed Direction. This operation does not affect the geometry of the (trimmed) surface and only affine transforms its knot vectors. A Bezier (trimmed) surface will automatically be promoted into a B-spline surface by this function.

If MinParam equals MaxParam and both equates with one of the parameterization keywords of PARAM_CENTRIP, PARAM_CENTRIP, PARAM_CHORD, or PARAM_NIELFOL, then that parametrization is approximated for the surface, by changing the knot sequence. Note this last operation affects the geometry of the surface.

Example:

srf = sbspline( 2, 4, list( list( ctlpt( E3, 0.0, 0.0, 1.0 ), ctlpt( E2, 0.0, 1.0 ), ctlpt( E3, 0.0, 2.0, 1.0 ) ), list( ctlpt( E2, 1.0, 0.0 ), ctlpt( E3, 1.0, 1.0, 2.0 ), ctlpt( E2, 1.0, 2.0 ) ), list( ctlpt( E3, 2.0, 0.0, 2.0 ), ctlpt( E2, 2.0, 1.0 ), ctlpt( E3, 2.0, 2.0, 2.0 ) ), list( ctlpt( E2, 3.0, 0.0 ), ctlpt( E3, 3.0, 1.0, 2.0 ), ctlpt( E2, 3.0, 2.0 ) ), list( ctlpt( E3, 4.0, 0.0, 1.0 ), ctlpt( E2, 4.0, 1.0 ), ctlpt( E3, 4.0, 2.0, 1.0 ) ) ), list( list( KV_OPEN ), list( KV_OPEN ) ) ); srf = sreparam( sreparam( srf, ROW, 0, 1 ), COL, 0, 1 );

ensures that the (trimmed) B-spline surface is defined over the unit size parametric domain. See also CREPARAM, TREPARAM, and MREPARAM.

SREVERSE

SurfaceType SREVERSE( SurfaceType Srf ) or TrimSrfType SREVERSE( TrimSrfType Srf )

reverse Srf by flipping the U and V parametric directions. Note that the unary minus (i.e -Srf) also reverses the surface by reversing the U parametric direction. If the surface is a trimmed surface, the trimming curves are flipped accordingly to yield the same shape.

RevSrf = SREVERSE( Srf );

See also MREVERSE.

SRF2TANS

ListType SRF2TANS( SurfaceType Srfs, NumericType Orientation, NumericType SubdivTol, NumericType NumericTol, NumericType MergeTol )

computes the developable sheet(s) bi-tangent to given two surfaces Srfs. Srfs can be either a list of two surfaces or a single surface in which self bi-tangencies are being sought. If Orientation is 0 all bi-tangent sheet(s) are returned. Otherwise, if Orientation equal +1 or -1, bi-tangent sheets(s) with same or different tangency orienation are returned, respectively. See MZERO for the meaning of the SubdivTol and NumerTol tolerances. Returns are lists, one per developable sheet, of sample points in E4, having two pairs of parameter values of the bi-tangent points in the two surfaces, in their parametric domain.

Example:

c1 = cbspline( 3, list( ctlpt( E2, -1, -1 ), ctlpt( E2, 1, -1 ), ctlpt( E2, 1, 1 ), ctlpt( E2, -1, 1 ) ), list( kv_periodic ) ); c1 = coerce( c1, kv_open ); c2 = cbspline( 3, list( ctlpt( E3, 0.8, -0.2, -0.3 ), ctlpt( E3, 0.5, 0.0, -0.2 ), ctlpt( E2, -0.45, -0.21 ), ctlpt( E2, -0.45, 0.32 ), ctlpt( E3, 0.5, -0.0, 0.2 ), ctlpt( E3, 0.8, 0.28, 0.3 ) ), list( kv_open ) ); s = sregion( sweepSrf( c1 * sc( 0.1 ), c2, off ), col, 0, 0.5 ); BiTans = SRF2TANS( list( s, s ), 0, 0.1, -1e-6, 1e-1 );

computes the self bi-tangencies of a given bottle-like surface.

FIGURE: Extracts self bi-tangent developable out of the given surface using SRF2TANS.
See also SRF3TANS.

SRF3TANS

ListType SRF3TANS( ListType Srfs, NumericType Orientation, NumericType SubdivTol, NumericType NumericTol )

computes the plane(s) tri-tangent to given three surfaces Srfs. Srfs can be either a list of three surfaces or a list of one surface in which self bi-tangencies are being sought. If Orientation is 0 all tri-tangent planes are returned. Otherwise, if Orientation equal +1 or -1, tri-tangent sheets(s)with same or different tangency orienation are returned, respectively. See MZERO for the meaning of the SubdivTol and NumerTol tolerances. Returns are lists, one per developable sheet, of sample points in E6, having three pairs of parameter values of the tri-tangent points in the three surfaces, in their parametric domain.

Example:

c2 = cbspline( 3, list( ctlpt( E3, 0.8, -0.2, -0.3 ), ctlpt( E3, 0.5, 0.0, -0.2 ), ctlpt( E2, -0.45, -0.21 ), ctlpt( E2, -0.45, 0.32 ), ctlpt( E3, 0.5, -0.0, 0.2 ), ctlpt( E3, 0.8, 0.28, 0.3 ) ), list( kv_open ) ); s1 = sFromCrvs( list( c2 * sc( 0.001 ), c2, c2 * tz( 1.0 ), c2 * sc( 0.001 ) * tz( 1.0 ) ), 3, kv_open ) * sc( 0.1 ); s2 = s1 * ry( 14 ) * tx( 0.6 ) * tz( 0.02 ); s3 = s1 * rx( 12 ) * ty( 0.6 ) * tx( 0.3 ) * tz( 0.01 ); TriTans = SRF3TANS( list( s1, s2, s3 ) * sz( 1 ), 1, 0.5, -1e-6 ); Edges = nil(); for ( i = 1, 1, sizeof( TriTans ), Pt = nth( TriTans, i ): snoc( seval( s1, coord( Pt, 1 ), coord( Pt, 2 ) ) + seval( s2, coord( Pt, 3 ), coord( Pt, 4 ) ), Edges ): snoc( seval( s1, coord( Pt, 1 ), coord( Pt, 2 ) ) + seval( s3, coord( Pt, 5 ), coord( Pt, 6 ) ), Edges ): snoc( seval( s2, coord( Pt, 3 ), coord( Pt, 4 ) ) + seval( s3, coord( Pt, 5 ), coord( Pt, 6 ) ), Edges ) );

computes the two outer oriented tri-tangencies to three approximate ellipsoids. Extract and draw the two tri-tangent triangles.

FIGURE: Extracts tri-tangent planes out of the given three approximate ellipsoids using SRF3TANS.
See also SRF2TANS.

SRFFFORM

ListType SRFFFORM( SurfaceType Srf, NumericType Form )

derives the four coefficients of the 1st, 2nd or 3rd surface fundamental forms. Form can be one of 1, 2, or 3 only, designating the requested form. Since this 2x2 matrix is symmetric, only three coefficients are returned as a list of three scalar surfaces as (A11, A12 == A21, A22).

Example:

FFF = SRFFFORM( Srf, 1 ); SFF = SRFFFORM( Srf, 2 ); TFF = SRFFFORM( Srf, 3 );

computes the three fundamental forms of Srf.

SRFLNDST

PointType SRFLNDST( SurfaceType Srf, PointType LnPt, VectorType LnDir, NumericType IsMinDist, NumericType SubdivTol, NumericType NumerTol )

compute the minimal (IsMinDist TRUE) or maximal (IsMinDist FALSE) distance betweeb surface Srf and the line defined by LnPt, a point on the line, and LnDir, the direction of the line. See MZERO for the meaning of the SubdivTol and NumerTol tolerances.

Example:

Dst = SRFLNDST( Srf, LnPoint, vector( 1, 1, 1 ), TRUE, 0.1, 1e-6 );

computes the minimal distance between Srf and line LnPoint/Vector( 1, 1, 1 ). See also SRFPTDST, CRVLNDST.

PolyType SRFKERNEL( SurfaceType Srf, NumericType Fineness, NumericType SkipRate )

SRFKERNEL

PolyType SRFKERNEL( SurfaceType Srf, NumericType Fineness, NumericType SkipRate )

approximates the kernel of (closed and continuous) surface Srf by deriving the parabolic points of Srf and intersecting half planes tangent to Srf and placed at a sampled set of parabolic locations. The fineness of the parabolic curves' approximation is governed by Fineness and the sampling rate is controled by SkipRate.

Example:

Krnl = SRFKERNEL( Srf, 40, 15 );

estimates the kernel of Srf with Fineness of 40 and SkipRate of 15.

SRFPTDST

PointType SRFLNDST( SurfaceType Srf, PointType Pt NumericType IsMinDist, NumericType SubdivTol, NumericType NumerTol )

compute the minimal (IsMinDist TRUE) or maximal (IsMinDist FALSE) distance between surface Srf and point Pt. See MZERO for the meaning of the SubdivTol and NumerTol tolerances.

Example:

Dst = SRFPTDST( Srf, Pt1, FALSE, 0.1, 1e-6 );

computes the maximal distance between Srf and point Pt1. See also SRFLNDST, CRVPTDST.

SRINTER

PointType SRINTER( SurfaceType Srf, PointType RayOrigin, VectorType RayDirection, NumericType Tolerance )

computes the first intersection, if any, of the prescribed ray originating from RayOrigin in direction RayDirection with surface Srf. It returns the intersection point in the parametric space of Srf with the U and V coordinates as the X and Y coefficients of the returned value. The intersection is computed between the ray and a polygonal approximation of the surface Srf as set via the RESOLUTION variable. If RayDirection is the zero vector, the closest position on Srf to RayOrigin is returned instead. Tolerance sets the accuracy of the computation.

This function is tailored toward many invokations of ray-surface test against the same surface. Hence, it caches local data for faster processing. To signal the function that the processing of the current surface is complete, use a Tolerance of zero.

Example:

RayOrigin = point( 2, 0.1, 0.3 ); RayDir = vector( -4, 0, 0 ); RayLine = coerce( RayOrigin, E3 ) + coerce( RayOrigin + RayDir, E3 ); color( RayLine, magenta ); attrib( RayLine, "dwidth", 2 ); resolution = 80; InterPt = SRINTER( glass, RayOrigin, RayDir, 0.001 ); InterPtE3 = seval( glass, coord( InterPt, 0 ), coord( InterPt, 1 ) ); color( InterPtE3, cyan ); attrib( InterPtE3, "dwidth", 3 ); view( list( InterPtE3, RayLine, glass, axes ), 1 ); InterPt = SRINTER( glass, RayOrigin, RayDir, 0.0 );

This is a complete example of constructing a ray and intersecting it against a surface of a glass at two different resolutions, resulting in two different accuracies. See also RESOLUTION.

SSINTER

ListType SSINTER( SurfaceType Srf1, SurfaceType Srf2, NumericType Euclidean, NumericType Epsilon, NumericType Alignment )

computes the intersection curve of two surfaces, Srf1 and Srf2, up to Epsilon accuracy. The returned data is in Euclidean space if Euclidean is true; otherwise it is in the parametric space. A list of two lists (for the two surfaces) of n curves each, where n is the number of intersection curves, is returned. If Alignment is true, the surfaces are rotated to that one bbox of one surface whose axes are aligned, increasing the probability of detecting disjoint cases.

Example:

s1 = sphereSrf( 0.35 ) * trans( vector( 0.0, 0.1, 0.2 ) ); s2 = coneSrf( 1, 0.5 ); Inter = nth( SSINTER( s1, s2, true, 0.1, false ), 1 );

computes the Euclidean intersection curves of a cone and a sphere, in general positions. The Euclidean curves on the first surface are extracted while purging the Euclidean curves on the second surface. See also RRINTER, SSINTR2 and GGINTER.

SSINTR2

ListType SSINTR2( SurfaceType Srf1, SurfaceType Srf2, NumericType Step, NumericType SubdivTol, NumericType NumerTol, NumericType Euclidean )

computes the intersection curve of two surfaces, Srf1 and Srf2, up to SubdivTol/NumerTol accuracy. The returned data is in Euclidean space if Euclidean is true; otherwise it is in the parametric space. Step controls the forward step size while tracing the intersection curves. A list of pairs of (piecewise linear) intersection curves is returned, one for each connected component. If Euclidean is true a Euclidean curve is also evaluated and returned.

Example:

s1 = sphereSrf( 0.35 ) * trans( vector( 0.0, 0.1, 0.2 ) ); s2 = coneSrf( 1, 0.5 ); Inter = nth( SSINTR2( s1, s2, 0.01, 0.01, 1e-8, false ), 1 );

computes the intersection curves of a cone and a sphere in parameter spaces. See also RRINTER, SSINTER and GGINTER.

STANGENT

VectorType STANGENT( SurfaceType Srf, ConstantType Direction, NumericType UParam, NumericType VParam, NumericType Normalize ) or VectorType STANGENT( TrimSrfType Srf, ConstantType Direction, NumericType UParam, NumericType VParam, NumericType Normalize )

compute the tangent vector to the (possibly trimmed) surface Srf at the parameter values UParam and VParam in Direction. The returned vector has a unit length. If Normalize TRUE, the returned vector is normalized as well.

Example:

Tang = STANGENT( Srf, ROW, 0.5, 0.6, TRUE );

computes the unit tangent to Srf in the ROW direction at the parameter values (0.5, 0.6).

STRIMSRF

SurfaceType STRIMSRF( TrimSrfType TSrf )

extracts the surface of a trimmed surface TSrf.

Example:

Srf = STRIMSRF( TrimSrf );

extracts the surface of TrimSrf.

STRIVAR

SurfaceType STRIVAR( TrivarType TV, ConstantType Direction, NumericType Param ) )

extracts an iso surface from a trivariate function TV in the specified Direction (ROW or COL or DEPTH) at the specified parameter value Param. Param must be contained in the parametric domain of TV in Direction direction. The returned surface is in the trivariate TV.

Example:

TV1 = tbezier( list( list( list( ctlpt( E3, 0.1, 0.0, 0.8 ), ctlpt( E3, 0.2, 0.1, 2.4 ) ), list( ctlpt( E3, 0.3, 2.2, 0.2 ), ctlpt( E3, 0.4, 2.3, 2.0 ) ) ), list( list( ctlpt( E3, 2.4, 0.8, 0.1 ), ctlpt( E3, 2.2, 0.7, 2.3 ) ), list( ctlpt( E3, 2.3, 2.6, 0.5 ), ctlpt( E3, 2.1, 2.5, 2.7) ) ) ) ); Srf = STRIVAR( TV1, col, 0.4 );

extracts an iso surface of TV1, in the col direction at parameter value 0.4.

FIGURE: Extracts an iso bilinear surface from a trilinear function, using STRIVAR.
See also SMESH, CSURFACE, MFROMMV.

SURFPREV

SurfaceType SURFPREV( CurveType Object )

This is the same as SURFREV but approximates the surface of revolution as a polynomial surface. The object must be a polynomial curve. See SURFREV.

SURFREV

PolygonType SURFREV( PolygonType Object ) or SurfaceType SURFREV( CurveType Object )

create a surface of revolution by rotating the first polygon/curve of the given Object, around the Z axis. Use the linear transformation functions to position a surface of revolution in a different orientation.

Example:

VTailAntn = SURFREV( ctlpt( E3, 0.001, 0.0, 1.0 ) + ctlpt( E3, 0.01, 0.0, 1.0 ) + ctlpt( E3, 0.01, 0.0, 0.8 ) + ctlpt( E3, 0.03, 0.0, 0.7 ) + ctlpt( E3, 0.03, 0.0, 0.3 ) + ctlpt( E3, 0.001, 0.0, 0.0 ) );

constructs a piecewise linear B-spline curve in the XZ plane and uses it to construct a surface of revolution by rotating it around the Z axis. See also SURFPREV, SURFREVAXS, SURFREV2, SURFREVAX2.

FIGURE: A surface of revolution, VTailAntn in surfrev documentation, can be constructed using SURFREV or SURFPREV.

SURFREVAXS

PolygonType SURFREVAXS( PolygonType Object, VectorType Axis ) or SurfaceType SURFREVAXS( CurveType Object, VectorType Axis )

create a surface of revolution by rotating the first polygon/curve of the given Object, around the Axis axis. Use the linear transformation functions to position a surface of revolution in a different location.

Example:

Glass = SURFREVAXS( GCross, vector( 1, 0, 1 ) );

constructs a surface of revolution by rotating GCross around the axis of (1, 0, 1). See also SURFPREV, SURFREV, SURFREV2, SURFREVAX2.

SURFREV2

PolygonType SURFREV2( PolygonType Object, NumericType StartAngle, NumericType EndAngle ) or SurfaceType SURFREV2( CurveType Object, NumericType StartAngle, NumericType EndAngle )

create a surface of revolution by rotating the first polygon/curve of the given Object, around the Z axis. The rotation does not form a complete circle and is from the StartAngle to the EndAngle only, in degrees, starting from the X axis toward the Y axis, in the XY plane. Use the linear transformation functions to position a surface of revolution in a different orientation.

Example:

Glass = SURFREV2( GCross, 45, 180 );

constructs a surface of revolution by rotating it around the Z axis from 45 to 180 degrees. See also SURFPREV, SURFREVAXS, SURFREV, SURFREVAX2.

SURFREVAX2

PolygonType SURFREVAX2( PolygonType Object, NumericType StartAngle, NumericType EndAngle, VectorType Axis ) or SurfaceType SURFREVAX2( CurveType Object, NumericType StartAngle, NumericType EndAngle, VectorType Axis )

create a surface of revolution by rotating the first polygon/curve of the given Object, around the Axis axis. The rotation does not form a complete circle and is from the StartAngle to the EndAngle only, in degrees, starting from the X axis toward the Y axis, in the XY plane. Use the linear transformation functions to position a surface of revolution in a different location.

Example:

T4 = SURFREVAX2( PolyCross, 90, 360, vector( 1, 0, 1 ) );

constructs a polygonal surface of revolution by rotating PolygonType PolyCross around the axis (1, 0, 1), from 45 to 180 degrees. See also SURFPREV, SURFREVAXS, SURFREV2, SURFREV.

SVISIBLE

ListType SVISIBLE( SurfaceType Srf, NumericType Resolution, NumericType ConeSize )

computes a decomposition of a freeform surface Srf into regions, each visible with a cone visibility of ConeSize degrees from one direction. In other words, all points in one region have angular deviation of their surface normal of less than ConeSize degrees from the set viewing direction. Resolution controls the accuracy of the computation; the higher this value is, more exact the result. 20 is a good starting value. Each returned region is a trimmed surface that has a "ViewDir" attribute that contains the viewing direction of this region.

Example:

c1 = cbezier( list( ctlpt( E3, 1.0, 0.0, 0.5 ), ctlpt( E3, 1.1, 0.0, 0.0 ), ctlpt( E3, 1.0, 0.0, -0.5 ) ) ); Simp = sregion( surfPRev( c1 ), col, 0.0, 1.0 ) * rz( 45 ) * rx( 90 ); Decomp = SVISIBLE( Simp, 20, 30 * pi / 180 ); SimDecomp = nil(); Mod = 5; for ( i = 1, 1, sizeof( Decomp ), o = nth( Decomp, i ): v = getattr( o, "ViewDir" ): l = ( ctlpt( E3, 0, 0, 0 ) + coerce( v, e3 ) ) * sc( 1.5 ): j = floor( ( i - 1 ) / Mod ): snoc( list( o, Simp, l, axes ) * view_mat * tx( ( i - 1 - j * Mod ) * 2 - 4 ) * ty( -j * 2 ), SimDecomp ) ); view( SimDecomp, on );

decomposes a given surface Simp into regions of 30 degrees at most, goes over the decomposed regions and orders them five in a row.

FIGURE: A decomposition of a freeform surface into cone visible regions of 30 degrees. The direction of visibility is also presented. Computed using the SVISIBLE command.

SVOLUME

SurfaceType SVOLUME( SurfaceType Srf, NumericType Method, NumericType Eval ) or NumericType SVOLUME( SurfaceType Srf, NumericType Method, NumericType Eval )

computes the integral volume surface, VSrf, of the given surface Srf, up to a sign. If Srf is a closed surface with domain (u0, v0) to (u1, v1), then the difference of VSrf(u1, v1) - VSrf(u0, v0) is the requested volume. Otherwise, the computation is for the volume occupied between the surface Srf and the XY plane if Method equals one, and the volume occupied between the surface Srf and the origin if Method equals two. If Eval is TRUE, the actual numerical value of the volume is returned. The volume integral surface is returned if Eval is FALSE.

Example:

Spr = surfPRev( cregion( pcircle( vector( 0, 0, 0 ), 1 ), 1, 3 ) * ry( 90 ) ); SVOLUME( Spr, 1, 1 ) * 3 / 4; SVOLUME( Spr, 2, 1 ) * 3 / 4;

are yet another two ways of approximating the value of Pi. See also SMOMENTS and CAREA.

SWEEPSRF

SurfaceType SWEEPSRF( CurveType CrossSection | ListType CrossSectionList, CurveType Axis, CurveType FrameCrv | VectorType FrameVec | ConstType OFF )

constructs a generalized cylinder surface. This function sweeps a specified cross section CrossSection along the provided Axis. If a list of curves CrossSectionList is specified instead, the cross sections are blended along the Axis of the curve so that the first/last cross section in the list fits the first/last location on the Axis. By default, when frame specification is OFF, the orientation of the cross section is computed using the Axis curve tangent and normal. However, unlike the Frenet frame, attempt is made to minimize the normal change, as can happen along inflection points in Axis. If a VectorType FrameVec is provided as a frame orientation setting, it is used to fix the binormal direction to this value. In other words, the orientation frame has a fixed binormal. If a CurveType FrameCrv is specified as a frame orientation setting, this vector field curve is evaluated at each placement of the cross section to yield the needed binormal.

The resulting sweep is only an approximation of the real sweep. The resulting sweep surface will not be exact, in general. Refinement of the axis curve at the proper location, where accuracy is important, should improve the accuracy of the output. The parametric domains of FrameCrv do not have to match the parametric domain of Axis, and its parametric domain is automatically made compatible by this function.

Example:

Cross = arc( vector( 0.2, 0.0, 0.0 ), vector( 0.2, 0.2, 0.0 ), vector( 0.0, 0.2, 0.0 ) ) + arc( vector( 0.0, 0.4, 0.0 ), vector( 0.1, 0.4, 0.0 ), vector( 0.1, 0.5, 0.0 ) ) + arc( vector( 0.8, 0.5, 0.0 ), vector( 0.8, 0.3, 0.0 ), vector( 1.0, 0.3, 0.0 ) ) + arc( vector( 1.0, 0.1, 0.0 ), vector( 0.9, 0.1, 0.0 ), vector( 0.9, 0.0, 0.0 ) ) + ctlpt( E2, 0.2, 0.0 ); Axis = arc( vector( -1.0, 0.0, 0.0 ), vector( 0.0, 0.0, 0.1 ), vector( 1.0, 0.0, 0.0 ) ); Axis = crefine( Axis, FALSE, list( 0.25, 0.5, 0.75 ) ); Srf1 = SWEEPSRF( Cross, Axis, OFF ); Srf2 = SWEEPSRF( Cross, Axis, vector( 0.0, 1.0, 1.0 ) ); Srf3 = SWEEPSRF( Cross, Axis, cbezier( list( ctlpt( E3, 1.0, 0.0, 0.0 ), ctlpt( E3, 0.0, 1.0, 0.0 ), ctlpt( E3, -1.0, 0.0, 0.0 ) ) ) );

constructs a rounded rectangle cross section and sweeps it along an arc, while orienting it several ways. The axis curve Axis is manually refined to better approximate the requested shape.

See also SWPSCLSRF for sweep with scale.

FIGURE: Three examples of the use of SWEEPSRF (Srf1, Srf2, Srf3 from left to right in sweepsrf documentation).

SWPSCLSRF

SurfaceType SWPSCLSRF( CurveType CrossSection | ListType CrossSectionList, CurveType Axis, NumericType Scale | CurveType ScaleCrv, CurveType FrameCrv | VectorType FrameVec | ConstType OFF, NumericType ScaleRefine )

constructs a generalized cylinder surface. This function sweeps a specified cross section CrossSection along the provided Axis. If a list of curves CrossSectionList is specified instead, the cross sections are blended along the Axis of the curve so that the first/last cross section in the list fits the first/last location on the Axis. The cross section may be scaled by a constant value Scale, or scaled along the Axis parametric direction via a scaling curve ScaleCrv. By default, when frame specification is OFF, the orientation of the cross section is computed using the Axis curve tangent and normal. However, unlike the Frenet frame, attempt is made to minimize the normal change, as can happen along inflection points in Axis. If a VectorType FrameVec is provided as a frame orientation setting, it is used to fix the binormal direction to this value. In other words, the orientation frame has a fixed binormal. If a CurveType FrameCrv is specified as a frame orientation setting, this vector field curve is evaluated at each placement of the cross section to yield the needed binormal. ScaleRefine is an integer value to define possible refinement of the Axis to reflect the information in ScalingCrv. A value of zero will force no refinement while a value of n > 0 will insert n times the number of control points in ScaleCrv into Axis, better emulating the scaling requested. The resulting sweep is only an approximation of the real sweep. The scaling and axis placement will not be exact, in general. Manual refinement (in addition to ScaleRefine) of the axis curve at the proper location, where accuracy is important, should improve the accuracy of the output. The parametric domains of ScaleCrv and FrameCrv do not have to match the parametric domain of Axis, and their domains are made compatible by this function.

Example:

Cross = arc( vector( -0.11, -0.1, 0.0 ), vector( -0.1, -0.1, 0.0 ), vector( -0.1, -0.11, 0.0 ) ) + arc( vector( 0.1, -0.11, 0.0 ), vector( 0.1, -0.1, 0.0 ), vector( 0.11, -0.1, 0.0 ) ) + arc( vector( 0.11, 0.1, 0.0 ), vector( 0.1, 0.1, 0.0 ), vector( 0.1, 0.11, 0.0 ) ) + arc( vector( -0.1, 0.11, 0.0 ), vector( -0.1, 0.1, 0.0 ), vector( -0.11, 0.1, 0.0 ) ) + ctlpt( E2, -0.11, -0.1 ); scaleCrv = cbspline( 3, list( ctlpt( E2, 0.05, 1.0 ), ctlpt( E2, 0.1, 0.0 ), ctlpt( E2, 0.2, 2.0 ), ctlpt( E2, 0.3, 0.0 ), ctlpt( E2, 0.4, 2.0 ), ctlpt( E2, 0.5, 0.0 ), ctlpt( E2, 0.6, 2.0 ), ctlpt( E2, 0.7, 0.0 ), ctlpt( E2, 0.8, 2.0 ), ctlpt( E2, 0.85, 1.0 ) ), list( KV_OPEN ) ); Axis = circle( vector( 0, 0, 0 ), 1 ); Frame = circle( vector( 0, 0, 0 ), 1 ) * rotx( 90 ) * trans( vector( 1.5, 0.0, 0.0 ) ); Srf1 = SWPSCLSRF( Cross, Axis, scaleCrv, off, 0 ); Srf2 = SWPSCLSRF( Cross, Axis, scaleCrv, off, 2 ); Srf3 = SWPSCLSRF( Cross, Axis, 1.0, Frame, 0 );

constructs a rounded rectangle cross section and sweeps it along a circle, while scaling and orienting in several ways. The axis curve Axis is automatically refined in Srf2 to better approximate the requested scaling.

See also SWEEPSRF for sweep with no scale.

FIGURE: Three examples of the use of SWPSCLSRF (Srf1, Srf2, Srf3 from left to right in SWPSCLSRF documentation).

SWUNGASUM

SurfaceType SWUNGASUM( CurveType Crv1, CurveType Crv2 )

Given two curves, compute a swung surface that equals:

                      S(r, t) = (x1(r) x2(t), x1(r) y2(t), y1(r))

Example:

circ = circle( vector( 0.0, 0.0, 0.0 ), 1.5 ) * ry( 90 ); arc1 = arc( vector( 0.0, 1.0, 0.0 ), vector( 0.0, 0.0, 0.0 ), vector( 1.0, 0.0, 0.0 ) ); as1 = SWUNGASUM( circ * ry( -90 ), arc1 ); arc1 = cregion( circle( vector( 0.0, 0.0, 0.0 ), 1.5 ), 0, 2 ) * rz( 90 ); c2 = coerce( cbspline( 3, list( ctlpt( E2, 1.0, 0.0 ), ctlpt( E2, 0.2, 0.2 ), ctlpt( E2, 0.0, 1.0 ), ctlpt( E2, -0.2, 0.2 ), ctlpt( E2, -1.0, 0.0 ), ctlpt( E2, -0.2, -0.2 ), ctlpt( E2, 0.0, -1.0 ), ctlpt( E2, 0.2, -0.2 ) ), list( KV_PERIODIC ) ), KV_OPEN ); as2 = SWUNGASUM( arc1, c2 );

creates two algebraic sum surfaces, one in the shape of a cylinder as a sum of a line and a circle, and one circular sweep.

FIGURE: An algebraic swung sum of a circle and a line creating a portion of a sphere (left) and a general swung surface between a circle and a periodic curve (right), both using SWUNGASUM.

SYMBCPROD

CurveType SYMBCPROD( CurveType Crv1, CurveType Crv2 ) or SurfaceType SYMBCPROD( SurfaceType Srf1, SurfaceType Srf2 ) or MultivarType SYMBCPROD( MultivarType MV1, MultivarType MV2 )

compute the symbolic cross product of the two given curves/surfaces/multivariates as a curve, surface or multivariate.

Example:

NrmlSrf = SYMBCPROD( sderive( Srf, ROW ), sderive( Srf, COL ) )

computes a normal surface as the cross product of the two surface partial derivatives (see SNRMLSRF). See also SYMBIPROD, SYMBDPROD, SYMBPROD, SYMBSUM, SYMBDIFF.

SYMBDIFF

CurveType SYMBDIFF( CurveType Crv1, CurveType Crv2 ) or SurfaceType SYMBDIFF( SurfaceType Srf1, SurfaceType Srf2 ) or MultivarType SYMBDIFF( MultivarType MV1, MultivarType MV2 )

compute the symbolic difference of the two given curves/surfaces/multivariates as a curve, surface or multivariate. The difference is computed coordinate-wise.

Example:

DiffCrv = SYMBDIFF( Crv1, Crv2 ) DistSqrCrv = symbdprod( DiffCrv, DiffCrv )

See also SYMBCPROD, SYMBDPROD, SYMBIPROD, SYMBPROD, SYMBSUM.

SYMBDPROD

CurveType SYMBDPROD( CurveType Crv1, CurveType Crv2 ) or CurveType SYMBDPROD( CurveType Crv1, VectorType Vec2 ) or SurfaceType SYMBDPROD( SurfaceType Srf1, SurfaceType Srf2 ) or SurfaceType SYMBDPROD( SurfaceType Srf1, VectorType Vec2 ) or MultivarType SYMBDPROD( MultivarType MV1, MultivarType MV2 ) or MultivarType SYMBDPROD( MultivarType MV1, VectorType Vec2 )

compute the symbolic dot (inner) product of the two given curves/surfaces/multivariates as a scalar curve/surface/multivariate. As an alternative, one parameter can also be a regular vector.

Example:

DiffCrv = symbdiff( Crv1, Crv2 ) DistSqrCrv = SYMBDPROD( DiffCrv, DiffCrv )

computes a scalar curve that at parameter t is equal to the distance square between Crv1 at t and Crv2. See also SYMBCPROD, SYMBIPROD, SYMBPROD, SYMBSUM, SYMBDIFF.

SYMBIPROD

NumericType SYMBIPROD( CurveType Crv, NumericType Order1, NumericType Order2 ) or NumericType SYMBIPROD( NumericType Dummy, NumericType Idx1, NumericType Idx2 )

compute the inner product of two B-spline basis functions. The first form defines the function space to be the same as the function space of Crv of order Order1 (first basis function) by Order2. The second basis function in the inner product is defined as,

   | Bi,o1(t) Bj,o2(t) dt.

The second form prescribes the indices of the two basis functions, i and j. The first form returns zero in case of an error. The second form returns the result of the inner product.

Example:

SYMBIPROD( Crv = pcircle( vector( 0, 0, 0 ), 1 ), 4, 4 ); for ( i = 0, 1, nth( ffmsize( Crv ), 1 ) - 1, for ( j = 0, 1, nth( ffmsize( Crv ), 1 ) - 2, printf( "%3.3f ", list( SYMBIPROD( 0, i, j ) ) ) ): printf( "\n", nil() ) );

prints all possible inner products of the B-spline function space of pcircle, of cubics vs. cubics. See also SYMBCPROD, SYMBDPROD, SYMBPROD, SYMBSUM, SYMBDIFF.

SYMBPROD

CurveType SYMBPROD( CurveType Crv1, CurveType Crv2 ) or SurfaceType SYMBPROD( SurfaceType Srf1, SurfaceType Srf2 ) or MultivarType SYMBPROD( MultivarType MV1, MultivarType MV2 )

compute the symbolic product of the two given curves/surfaces/multivariates as a curve, surface or multivariate. The product is computed coordinate-wise.

Example:

ProdSrf = SYMBPROD( Srf1, Srf2 )

See also SYMBCPROD, SYMBDPROD, SYMBIPROD, SYMBSUM, SYMBDIFF.

SYMBSUM

CurveType SYMBSUM( CurveType Crv1, CurveType Crv2 ) or SurfaceType SYMBSUM( SurfaceType Srf1, SurfaceType Srf2 ) or MultivarType SYMBSUM( MultivarType MV1, MultivarType MV2 )

compute the symbolic sum of the two given curves/surfaces/multivariates as a curve, surface or multivariate. The sum is computed coordinate-wise.

Example:

SumCrv = SYMBSUM( Crv1, Crv2 )

See also SYMBCPROD, SYMBDPROD, SYMBIPROD, SYMBPROD, SYMBDIFF.

TBEZIER

TrivarType TBEZIER( ListType CtlMesh )

creates a Bezier trivariate using the provided control mesh. CtlMesh is a list of planes, each of which is a list of rows, each of which is a list of control points. All control points must be of type (E1-E9, P1-P9), or regular PointType defining the trivariate's control mesh. The surface point type will be of a space which is the union of the spaces of all points.

Example:

TV = TBEZIER( list( list( list( ctlpt( E3, 0.1, 0.1, 0.0 ), ctlpt( E3, 0.2, 0.5, 1.1 ), ctlpt( E3, 0.3, 0.1, 2.2 ) ), list( ctlpt( E3, 0.4, 1.3, 0.5 ), ctlpt( E3, 0.5, 1.7, 1.7 ), ctlpt( E3, 0.6, 1.3, 2.9 ) ), list( ctlpt( E3, 0.7, 2.4, 0.5 ), ctlpt( E3, 0.8, 2.6, 1.4 ), ctlpt( E3, 0.9, 2.8, 2.3 ) ) ), list( list( ctlpt( E3, 1.1, 0.1, 0.5 ), ctlpt( E3, 1.3, 0.2, 1.7 ), ctlpt( E3, 1.5, 0.3, 2.9 ) ), list( ctlpt( E3, 1.7, 1.2, 0.0 ), ctlpt( E3, 1.9, 1.4, 1.2 ), ctlpt( E3, 1.2, 1.6, 2.4 ) ), list( ctlpt( E3, 1.4, 2.3, 0.9 ), ctlpt( E3, 1.6, 2.5, 1.7 ), ctlpt( E3, 1.8, 2.7, 2.5 ) ) ) ) );

creates a trivariate Bezier which is linear in the first direction, and quadratic in the second and third.

FIGURE: A trivariate Bezier of degree 2 by 3 by 3 (left) and a trilinear B-spline (right). Both share the same control mesh.

TBSPLINE

TrivarType TBSPLINE( NumericType UOrder, NumericType VOrder, NumericType WOrder, ListType CtlMesh, ListType KnotVectors )

creates a B-spline trivariate with the provided UOrder, VOrder and WOrder orders, the control mesh CtlMesh, and the three knot vectors in KnotVectors. CtlMesh is a list of planes, each of which is a list of rows, each of which is a list of control points. All control points must be of point type (E1-E9, P1-P9), or regular PointType defining the trivariate's control mesh. Trivariate point type will be of a space which is the union of the spaces of all points. KnotVectors is a list of three knot vectors. Each knot vector is a list of NumericType knots of length #CtlPtList plus the Order. If, however, the length of the knot vector is equal to #CtlPtList + Order + Order - 1}, the curve is assumed to be periodic. The knot vector may also be a list of a single constant, KV_OPEN, KV_FLOAT or KV_PERIODIC, in which a uniform knot vector with the appropriate length and with open, floating or periodic end conditions will be constructed automatically.

Example:

TV = TBSPLINE( 2, 2, 2, list( list( list( ctlpt( E3, 0.1, 0.1, 0.0 ), ctlpt( E3, 0.2, 0.5, 1.1 ), ctlpt( E3, 0.3, 0.1, 2.2 ) ), list( ctlpt( E3, 0.4, 1.3, 0.5 ), ctlpt( E3, 0.5, 1.7, 1.7 ), ctlpt( E3, 0.6, 1.3, 2.9 ) ), list( ctlpt( E3, 0.7, 2.4, 0.5 ), ctlpt( E3, 0.8, 2.6, 1.4 ), ctlpt( E3, 0.9, 2.8, 2.3 ) ) ), list( list( ctlpt( E3, 1.1, 0.1, 0.5 ), ctlpt( E3, 1.3, 0.2, 1.7 ), ctlpt( E3, 1.5, 0.3, 2.9 ) ), list( ctlpt( E3, 1.7, 1.2, 0.0 ), ctlpt( E3, 1.9, 1.4, 1.2 ), ctlpt( E3, 1.2, 1.6, 2.4 ) ), list( ctlpt( E3, 1.4, 2.3, 0.9 ), ctlpt( E3, 1.6, 2.5, 1.7 ), ctlpt( E3, 1.8, 2.7, 2.5 ) ) ) ), list( list( KV_OPEN ), list( KV_OPEN ), list( KV_OPEN ) ) );

constructs a trilinear B-spline trivariate with open end conditions. TCRVTR

TCRVTR

AnyType TCRVTR( TrivarType TV, PointType Pos, NumericType ComputeWhat )

computes differential curvature properties of an isosurface of the given trivariate TV at the given (parameteric) location Pos. Following the value of ComputeWhat, the result equals,

-1	Initialization (a must prelude)
0	Conclusion (a must postlude)
1	Returns a vector hold of the gradient
2	Returns a list of three vectors
	equal to the Hessian of this location
3	Returns a list of two scalar values
	(Principle curvatures) and two vectors
	(Principal directions).

Every evaluation must start with an invocation of ComputeWhat equal to -1 and terminate with ComputeWhat 0. In both cases, 1 is returned in case of success.

Example:

TCRVTR( TV, point( 0, 0, 0 ), -1 ); # Prelude Grad1 = TCRVTR( TV, point( 0, 0, 0 ), 1 ); Grad2 = TCRVTR( TV, point( 0, 0, 1 ), 1 ); Grad3 = TCRVTR( TV, point( 0, 1, 0 ), 1 ); Grad4 = TCRVTR( TV, point( 1, 0, 0 ), 1 ); TCRVTR( TV, point( 0, 0, 0 ), 0 ); #Postlude

TDERIVE

TrivarType TDERIVE( TrivarType TV, NumericType Dir )

returns a vector field trivariate representing the differentiated trivariate in the given direction (ROW, COL, or DEPTH). Evaluation of the returned trivariate at a given parameter value will return a vector representing the partial derivative of TV in Dir at that parameter value.

TV = tbezier( list( list( list( ctlpt( E1, 0.1 ), ctlpt( E1, 0.2 ) ), list( ctlpt( E1, 0.3 ), ctlpt( E1, 0.4 ) ) ), list( list( ctlpt( E1, 2.4 ), ctlpt( E1, 2.2 ) ), list( ctlpt( E1, 2.3 ), ctlpt( E1, 2.1 ) ) ) ) ); DuTV = TDERIVE( TV, ROW ); DvTV = TDERIVE( TV, COL ); DwTV = TDERIVE( TV, DEPTH );

computes the gradiate of a scalar trivariate field, by computing its partials with respect to u, v, and w. See also CDERIVE, SDERIVE, and MDERIVE.

TDIVIDE

TrivarType TDIVIDE( TrivarType TV, ConstantType Direction, NumericType Param )

subdivides a trivariate into two at the specified parameter value Param in the specified Direction (ROW, COL, or DEPTH). TV can be either a B-spline trivariate in which Param must be contained in the parametric domain of the trivariate, or a Bezier trivariate in which Param must be in the range of zero to one.

It returns a list of the two sub-trivariates. The individual trivariates may be extracted from the list using the NTH command.

Example:

TvDiv = TDIVIDE( Tv2, depth, 0.3 ); Tv2a = nth( TvDiv, 1 ) * tx( -2.2 ); Tv2b = nth( TvDiv, 2 ) * tx( 2.0 );

subdivides Tv2 at the parameter value of 0.3 in the DEPTH direction,

FIGURE: A trivariate can be subdivided into two distinct regions using TDIVIDE.
See also CDIVIDE, SDIVIDE, and MDIVIDE

TEDITPT

TrivarType TEDITPT( TrivarType TV, CtlPtType CPt, NumericType UIndex, NumericType VIndex ) NumericType WIndex )

provides a simple mechanism to manually modify a single control point number UIndex, VIndex and WIndex (base count is 0) in the control mesh of Srf by substituting CtlPt instead. CtlPt must have the same point type as the control points of Srf. Original surface Srf is not modified.

Example:

CPt = ctlpt( E3, 1, 2, 3 ); NewTV = TEDITPT( TV, CPt, 0, 0, 0 );

constructs a NewTV with the first control point of TV being CPt.

TEVAL

CtlPtType TEVAL( TrivarType TV, NumericType UParam, NumericType VParam, NumericType WParam )

evaluates the provided trivariate TV at the given UParam, VParam and WParam values. UParam, VParam, WParam must be contained in the surface parametric domain if TV is a B-spline trivariate, or between zero and one if TV is a Bezier trivariate. The returned control point has the same type as the control points of TV.

Example:

CPt = TEVAL( TV1, 0.25, 0.22, 0.7 );

evaluates TV at the parameter values of (0.25, 0.22, 0.7). See also CEVAL, SEVAL, MEVAL.

TEXTGEOM

AnyType TEXTGEOM( StringType Str, VectorType Spacing, NumericType Scaling )

creates a displayable geometry that represents the text in Str, with Spacing space between individual characters. Each character is scaled by Scaling where scaling of one generates a close to unit size character.

Example:

a = TEXTGEOM("Text", vector( 0.12, 0, 0 ), 0.1 ); b = TEXTGEOM("IRIT", vector( 0, -0.12, 0 ), 0.1 );

creates a horizontal Text and a vertical top to bottom IRIT, both as geometrical objects. See TEXTWARP and IRITSTATE's "LoadFont" state variable.

TEXTWARP

AnyType TEXTWARP( Surface Srf, StringType Text, NumericType HSpace, NumericType VBase, NumericType VTop, NumericType Ligature )

warps the given text, Text, using surface Srf as warping function with HSpace setting the horizontal spacing between characters, VBase and VTop controls the vertical spacing of the characters in Srf, and Ligature, if not zero, sets the amount to contract the distance between two adjacent characters.

FIGURE: Font and text warping using the TEXTWARP function.
Example:

c = cbezier( list( ctlpt( e2, -1.5, -0.5 ), ctlpt( e2, -2, 0 ), ctlpt( e2, -1, 1 ), ctlpt( e2, 0, -2 ), ctlpt( e2, 1, 0 ) ) ); s = sreparam( ruledSrf( c, offset( c, -0.4, 0.02, off ) ), col, 0, 6 ); Txt = TEXTWARP( s, "Text Warping Toolkit", 0.08, 0.25, 0.75, 0 );

See also TEXTGEOM and IRITSTATE's "LoadFont" state variable.

TFROMSRFS

TrivarType TFROMSRFS( ListType SrfList, NumericType OtherOrder, NumericType OtherEndCond )

constructs a trivariate by substituting the surfaces in SrfList as planes in a control mesh of a trivariate. Surfaces in SrfList are made compatible by promoting Bezier surfaces to B-splines if necessary, and raising degree and refining as required before substituting the control meshes of the surfaces as planes in the mesh of the trivariate. The other, third, direction order is controlled by OtherOrder and OtherEndCond. OtherOrder cannot be larger than the number of surfaces, and OtherEndCond prescribes the desired end conditions as one of KV_OPEN, KV_FLOAT or KV_PERIODIC.

The trivariate interpolates the first and last surfaces only.

Example:

s1 = sbezier( list( list( ctlpt( E3, -0.5, -0.5, 0 ), ctlpt( E3, -0.5, 0.5, 0 ) ), list( ctlpt( E3, 0.5, -0.5, 0 ), ctlpt( E3, 0.5, 0.5, 0 ) ) ) ) * sc( 0.3 ); Srfs = list( s1 * sc( 2.0 ), s1 * sx( 1.4 ) * ry( 45 ) * tz( 1.0 ), s1 * ry( 90 ) * trans( vector( 1.0, 0.0, 1.1 ) ), s1 * sx( 1.4 ) * ry( 135 ) * trans( vector( 2.0, 0.0, 1.0 ) ), s1 * sc( 2.0 ) * ry( 180 ) * trans( vector( 2.0, 0.0, 0.0 ) ) ); color( Srfs, red ); ts = TFROMSRFS( Srfs, 3, kv_open ); color( ts, green ); view( list( Srfs, ts ), on );

constructs a trivariate from five planar surfaces and displays both the trivariate and the five planar surfaces, in different colors.

FIGURE: A trivariate (thin lines) is constructed via five planar surfaces (thick lines) using the TFROMSRFS constructor...

See also EXTRUDE, RULEDTV, SFROMCRVS.

TINTERP

TrivarType TINTERP( TrivarType TV, NumericType ULength, NumericType VLength, NumericType WLength, NumericType UOrder, NumericType VOrder, NumericType WOrder ); or TrivarType TINTERP( ListType PtList, NumericType ULength, NumericType VLength, NumericType WLength, NumericType UOrder, NumericType VOrder, NumericType WOrder );

Given a trivariate data structure or a list of points in R3, the above computes a fitted trivariate in the prescribed function space (i.e. U/V/WLength and U/V/WOrder) that interpolates/least squares approximates the given trivariate, TV, at the node parameter values. PtList is a list of points in Rn, n > 3. The first three coordinates of each points in PtList prescribes the (u, v, w) parametric value and the rest, the interpolation values. To construct a mapping from R3 to R3, the points of PtList should be in R6. To construct a scalar trivariate function, R4 points are expected. The (u, v, w) points are assumed to be containted in a unit curve paramteric space - zero to one in all three dimensions. If U/V/WOrder are zero and the first parameter is a trivariate, the respective order is taken for TV. If U/V/WLength are zero and the first parameter is a trivariate, the respective length is taken for TV.

Example:

tv = tbspline( 3, 3, 2, list( list( list( ctlpt( E3, 0.1, 0.1, 0.0 ), ctlpt( E3, 0.2, 0.5, 1.1 ), ctlpt( E3, 0.3, 0.1, 2.2 ) ), list( ctlpt( E3, 0.4, 1.3, 0.5 ), ctlpt( E3, 0.5, 1.7, 1.7 ), ctlpt( E3, 0.6, 1.3, 2.9 ) ), list( ctlpt( E3, 0.7, 2.4, 0.5 ), ctlpt( E3, 0.8, 2.6, 1.4 ), ctlpt( E3, 0.9, 2.8, 2.3 ) ) ), list( list( ctlpt( E3, 1.1, 0.1, 0.5 ), ctlpt( E3, 1.3, 0.2, 1.7 ), ctlpt( E3, 1.5, 0.3, 2.9 ) ), list( ctlpt( E3, 1.7, 1.2, 0.0 ), ctlpt( E3, 1.9, 1.4, 1.2 ), ctlpt( E3, 1.2, 1.6, 2.4 ) ), list( ctlpt( E3, 1.4, 2.3, 0.9 ), ctlpt( E3, 1.6, 2.5, 1.7 ), ctlpt( E3, 1.8, 2.7, 2.5 ) ) ), list( list( ctlpt( E3, 2.8, 0.1, 0.4 ), ctlpt( E3, 2.6, 0.7, 1.3 ), ctlpt( E3, 2.4, 0.2, 2.2 ) ), list( ctlpt( E3, 2.2, 1.1, 0.4 ), ctlpt( E3, 2.9, 1.2, 1.5 ), ctlpt( E3, 2.7, 1.3, 2.6 ) ), list( ctlpt( E3, 2.5, 2.9, 0.7 ), ctlpt( E3, 2.3, 2.8, 1.7 ), ctlpt( E3, 2.1, 2.7, 2.7 ) ) ) ), list( list( KV_OPEN ), list( KV_OPEN ), list( KV_OPEN ) ) ); tvi = TINTERP( tv, 0, 0, 0, 0, 0, 0 );

creates a quadratic by quaratic by linear trivariate tvi that interpolates the control points of tv at the node parameter values.

TMORPH

TrivarType TMORPH( TrivarType TV1, SurfaceType TV2, NumericType Blend )

creates a new trivariate which is a convex blend of the two given trivariates. The two given trivariates must be compatible (see FFCOMPAT) before this blend is invoked. This isv ery useful if a sequence that "morphs" one trivariate to another is to be created and in combination with MRCHCUBE.

Example:

Size = 0.05; for ( i = 0, step, 1.0, Tv = TMORPH( Tv1, Tv2, i ): view( mrchcube( list( Tv, 1, off ), point( Size, Size, Size ), 1, IsoVal ), on ) );

creates a sequence of 1/step trivariates, morphed from Tv1 to Tv2 and displays an extracted iso surface at level IsoVal. See also MRCHCUBE, PMORPH, CMORPH and SMORPH.

TNSCRCR

ListType TNSCRCR( PointType Cntr1, NumericType Rad1, PointType Cntr2, NumericType Rad2, NumericType OuterTans )

computes the two outer, if OuterTans TRUE, or the two inner if OuterTans FALSE, bi-tangents between the prescribed two circles. Note the bi-tangents might no exist of one circle is containt in the other.

Example:

T1 = TnsCrCr( point( -2, 0.3, 0 ), 0.7, point( 1, 0, 0 ), 1, 0 ); T2 = TnsCrCr( point( -2, 0.3, 0 ), 0.7, point( 1, 0, 0 ), 1, 1 );

See also CRC2CRVTAN.

TOFFSET

ListType TOFFSET( CurveType Crv, CurveType OffCrv, ListType Params ) or ListType TOFFSET( SurfaceType Srf, SurfaceType OffSrf, ListType Params )

Trims local and global self intersections in curve OffCrv (surface OffSrf) that is an offset approximation to curve Crv (surface Srf) with parameters Params as follows: For curves, Params contains the 4 paramers (Method, Tol, TrimAmount, NumerTol) stating with the Method of trimming which can be 1 of distance map trmming or 2 for self intersection via uv-elimination. 2nd paramter is the tolerance of the subdivision search, 3rd is the trimming amount which should be a tad below the offset distance and the last parameter is a numerical tolerance to improve trimmed locations. For surfaces Params hold 5 parameters (TrimAmount, Validate, Euclidean, SubdivTol, NumerTol). The TrimAmount is again a tad below the offset distance, Validate is a boolean to activate the filering of self intersecting regions, Eculidean sets the output form to be in Euclidean or parametric space and finally SubdivTol and NumerTol is used by the multivariate solver.

Example:

c0 = cbspline( 3, list( ctlpt( E2, -1, 3 ), ctlpt( E2, -0.3, 0 ), ctlpt( E2, 0.3, 0 ), ctlpt( E2, 1, 3 ) ), list( kv_open ) ); for ( i = -5, 1, 5, if ( i != 0, ofst = 0.15 * i: co = offset( c0, ofst, 0.0001, off ): none = TOFFSET( c0, co, list( 1, 15, abs( ofst * 0.999 ), 0.001 ) ): color( none, i + 6 ): viewobj( none ) ) );

approximates several offset curves at offset amounts of 0.15 * i to curve c0 and trim the self intersections detected in them.

FIGURE: Properly trimmed offsets could be created using the TOFFSET function.

TORUS

PolygonType TORUS( VectorType Center, VectorType Normal, NumericType MRadius, NumericType mRadius )

creates a TORUS geometric object, defined by Center as the center of the TORUS, Normal as the normal to the main plane of the TORUS, MRadius and mRadius as the major and minor radii of the TORUS. See RESOLUTION for the accuracy of the TORUS approximation as a polygonal model. See IRITSTATE's "PrimRatSrfs" and "PrimRatSrfs" state variables.

Example:

T = TORUS( vector( 0.0, 0.0, 0.0), vector( 0.0, 0.0, 1.0), 0.5, 0.2 );

constructs a torus with its major plane as the XY plane, major radius of 0.5, and minor radius of 0.2.

FIGURE: A torus primitive can be constructed using a TORUS constructor...

TRAISE

TrivarType TRAISE( TrivarType TV, ConstantType Direction, NumericType NewOrder )

raises TV to the specified NewOrder in the specified Direction.

Example:

tv1r = TRAISE( traise( traise( tv1, row, 4 ), col, 4 ), depth, 4 );

ensures that the trivariate is a tricubic. See also MRAISE, SRAISE, and CRAISE.

TREFINE

TrivarType TREFINE( TrivarType TV, ConstantType Direction, NumericType Replace, ListType KnotList )

provides the ability to Replace a knot vector of TV or refine it in the specified direction Direction (ROW, COL, or DEPTH). KnotList is a list of knots at which to refine TV. All knots should be contained in the parametric domain of TV in Direction. If the knot vector is replaced, the length of KnotList should be identical to the length of the original knot vector of TV in the Direction. If TV is a Bezier trivariate, it is automatically promoted to be a B-spline trivariate.

Example:

TV = TREFINE( TREFINE( TREFINE( TV, ROW, FALSE, list( 0.333, 0.667 ) ), COL, FALSE, list( 0.333, 0.667 ) ), DEPTH, FALSE, list( 0.333, 0.667 ) );

refines TV in all directions by adding two more knots at 0.333 and 0.667. See also CREFINE, SREFINE, and MREFINE.

TREGION

TrivarType TREGION( TrivarType TV, ConstantType Direction, NumericType MinParam, NumericType MaxParam )

extracts a region of TV between MinParam and MaxParam in the specified Direction. Both MinParam and MaxParam should be contained in the parametric domain of TV in the Direction.

Example:

Tv1 = tbezier( list( list( list( ctlpt( E3, 0.1, 0.0, 0.8 ), ctlpt( E3, 0.2, 0.1, 2.4 ) ), list( ctlpt( E3, 0.3, 2.2, 0.2 ), ctlpt( E3, 0.4, 2.3, 2.0 ) ) ), list( list( ctlpt( E3, 2.4, 0.8, 0.1 ), ctlpt( E3, 2.2, 0.7, 2.3 ) ), list( ctlpt( E3, 2.3, 2.6, 0.5 ), ctlpt( E3, 2.1, 2.5, 2.7) ) ) ) ); Tv1r1 = TREGION( Tv1, row, 0.1, 0.2 ); Tv1r2 = TREGION( Tv1, row, 0.4, 0.6 ); Tv1r3 = TREGION( Tv1, row, 0.99, 1.0 );

extracts three regions of Tv1 along the ROW direction.

FIGURE: A region can be extracted from a freeform trivariate using TREGION.
See also CREGION, SREGION, and MREGION.

TREPARAM

TrivarType TREPARAM( TrivarType TV, ConstantType Direction, NumericType MinParam, NumericType MaxParam )

reparametrizes TV over a new domain from MinParam to MaxParam, in the prescribed Direction. This operation does not affect the geometry of the trivariate and only affine transforms its knot vectors. A Bezier trivariate will automatically be promoted into a B-spline surface by this function.

Example:

Tv = TREPARAM( TREPARAM( TREPARAM( tv, row, 0, 1 ), col, 0, 1 ), depth, 0, 1 );

ensures that the trivariate is defined over the unit size parametric cube. See also CREPARAM, SREPARAM, and MREPARAM.

TRIANGL

PolygonType TRIANGL( PolygonType Model, NumericType Regular )

converts Model into a new model with exactly the same shape that holds only triangles. If the Regular is not zero, the object is regularized as well. Example:

final2 = triangl( final, false );

See also MAXEDGELEN

TRIMSRF

TrimSrfType TRIMSRF( SurfaceType Srf, CurveType TrimCrv, NumericType HasUpperLevel ) or TrimSrfType TRIMSRF( SurfaceType Srf, ListType TrimCrvs, NumericType HasUpperLevel )

create a trimmed surface from the provided surface Srf and the trimming curve TrimCrv or curves TrimCrvs. If HasUpperLevel is FALSE, an additional trimming curve is automatically added that contains the entire parametric domain of Srf. No validity test is performed on the trimming curves which are assumed to be two-dimensional curves contained in the parametric domain of Srf.

Example:

spts = list( list( ctlpt( E3, 0.1, 0.0, 1.0 ), ctlpt( E3, 0.3, 1.0, 0.0 ), ctlpt( E3, 0.0, 2.0, 1.0 ) ), list( ctlpt( E3, 1.1, 0.0, 0.0 ), ctlpt( E3, 1.3, 1.5, 2.0 ), ctlpt( E3, 1.0, 2.1, 0.0 ) ), list( ctlpt( E3, 2.1, 0.0, 2.0 ), ctlpt( E3, 2.3, 1.0, 0.0 ), ctlpt( E3, 2.0, 2.0, 2.0 ) ), list( ctlpt( E3, 3.1, 0.0, 0.0 ), ctlpt( E3, 3.3, 1.5, 2.0 ), ctlpt( E3, 3.0, 2.1, 0.0 ) ), list( ctlpt( E3, 4.1, 0.0, 1.0 ), ctlpt( E3, 4.3, 1.0, 0.0 ), ctlpt( E3, 4.0, 2.0, 1.0 ) ) ); sb = sbspline( 3, 3, spts, list( list( KV_OPEN ), list( KV_OPEN ) ) ); TCrv1 = cbspline( 2, list( ctlpt( E2, 0.3, 0.3 ), ctlpt( E2, 0.7, 0.3 ), ctlpt( E2, 0.7, 0.7 ), ctlpt( E2, 0.3, 0.7 ), ctlpt( E2, 0.3, 0.3 ) ), list( KV_OPEN ) ); TCrv2 = circle( vector( 0.5, 0.5, 0.0 ), 0.25 ); TCrv3 = cbspline( 3, list( ctlpt( E2, 0.3, 0.3 ), ctlpt( E2, 0.7, 0.3 ), ctlpt( E2, 0.7, 0.7 ), ctlpt( E2, 0.3, 0.7 ) ), list( KV_PERIODIC ) ); TSrf1 = TRIMSRF( sb, TCrv1, false ); TSrf2 = TRIMSRF( sb, TCrv1, true ); TSrf3 = TRIMSRF( sb, list( TCrv1, TcRv2 * ty( 1 ), TCrv3 * ty( 2 ) ), false );

constructs three trimmed surfaces. Tsrf1 contains the outer boundary and excludes what is inside TCrv1, TSrf2 contains only the domain inside TCrv1. TCrv3 has three holes corresponding to the three trimming curves. See also TRMSRFS.

FIGURE: Three trimmed surfaces created from the same B-spline surface. The original surface is outline by thin lines and the trimmed surfaces are outlined by thick lines.

TRMSRFS

TrimSrfType TRMSRFS( SurfaceType Srf, CurveType Cntrs ) or TrimSrfType TRMSRFS( SurfaceType Srf, PolyType Cntrs ) or TrimSrfType TRMSRFS( SurfaceType Srf, ListType Cntrs )

create a set of trimmed surfaces from the provided surface Srf and the set of contours Cntrs in Srf's parametric domain.

The contours in Cntrs can be polylines, curves, or a list of such entities. The contours in Cntrs must be either closed or start and end on the boundary of the parametric domain of Srf. Further, these contours must be (self) intersection free.

The returned result is a (list of) trimmed surfaces, each defining one sub-region that results from Cntrs's trimming.

Example:

tsrfs = TRMSRFS( srf, list( poly( list( point( 0.0, 0.2, 0.0 ), point( 1.0, 0.5, 0.0 ) ), true ), cbezier( list( ctlpt( E2, 0.0, 2.5 ), ctlpt( E2, 0.5, 2.5 ), ctlpt( E2, 0.5, 3.0 ) ) ) ) ); interact( list( nth( tsrfs, 1 ) * tz( -0.2 ), nth( tsrfs, 2 ) * tz( 0.0 ), nth( tsrfs, 3 ) * tz( 0.2 ) ) );

constructs trimmed surfaces using two contours. One contour is a polyline with two points, and the other is a quadratic Bezier curve. See also TRIMSRF.

FIGURE: Three trimmed surfaces created from the same B-spline surface using the TRMSRFS and two prescribed contour in the surface's parametric domain.

TSBEZIER

SurfaceType TSBEZIER( NumericType Order, ListType CtlMesh )

creates a triangular Bezier surface of order Order using the provided control mesh. CtlMesh is a list of control points of size (Order + 1) * Order / 2. All control points must be of type (E1-E9, P1-P9), or regular PointType defining the surface's control polygon. The surface point type will be of a space which is the union of the spaces of all points.

Example:

b = TSBEZIER( 3, list( ctlpt( E3, 0.0, 0.0, 0.4 ), ctlpt( E3, 0.3, 0.0, 0.3 ), ctlpt( E3, 0.7, 0.0, 0.8 ), ctlpt( E3, 0.2, 0.4, 1.0 ), ctlpt( E3, 0.4, 0.5, 1.0 ), ctlpt( E3, 0.5, 1.0, 0.7 ) ) );

FIGURE: A triangular Bezier surface of degree 2 or order 3.
See also TSGREGORY and TSBSPLINE.

TSBSPLINE

TriSrfType TSBSPLINE( NumericType Order, NumericType Length, ListType CtlMesh, ListType KnotVector )

creates a B-spline surface from the provided Order and Length, the control mesh CtlMesh, and the knot vector KnotVector. CtlMesh is a list of control points of size (Length + 1) * Length / 2. All control points must be of point type (E1-E9, P1-P9), or regular PointType defining the surface's control mesh. The surface point type will be of a space which is the union of the spaces of all points. KnotVector is a list of NumericType knots of length Length plus the Order. The knot vector may also be a list of a single constant KV_OPEN or KV_FLOAT, in which a uniform knot vector with the appropriate length and with an open or floating end condition will be constructed automatically.

Not fully supported at this time. See also TSBEZIER and TSGREGORY.

TSDERIVE

TriSrfType TSDERIVE( TriSrfType Srf, NumericType Dir )

returns a vector field surface representing the differentiated triangular surface in the given direction (ROW, COL, or DEPTH). Evaluation of the returned surface at a given parameter value will return a vector tangent to Srf in Dir at that parameter value.

DuSrf = TSDERIVE( Srf, ROW ); DvSrf = TSDERIVE( Srf, COL ); Normal = coerce( tseval( DuSrf, 0.5, 0.25, 0.25 ), VECTOR_TYPE ) ^ coerce( tseval( DvSrf, 0.5, 0.25, 0.25 ), VECTOR_TYPE );

computes two partial derivatives of the surface Srf and computes its normal as their cross product, at the parametric location (0.5, 0.25, 0.25).

See also TSNORMAL

TSEVAL

CtlPtType TSEVAL( TriSrfType Srf, NumericType UParam, NumericType VParam, NumericType WParam )

evaluates the provided triangular surface Srf at the given UParam, VParam, WParam parameters. UParam, VParam, and WParam must all be non negative and must sum to one for a Bezier triangular surface or to the maximum domain, if a B-spline surface.

Example:

CPt = TSEVAL( Srf, u, v, 1.0 - u - v );

evaluates Srf at the parameter values prescribed by u and v.

TSGREGORY

SurfaceType TSGREGORY( NumericType Order, ListType CtlMesh )

cCreates a triangular Gregory surface of order Order using the provided control mesh. CtlMesh is a list of control points of size (Order + 1) * Order / 2 + 3. All control points must be of type (E1-E9, P1-P9), or regular PointType defining the surface's control polygon. The surface point type will be of a space which is the union of the spaces of all points.

Example:

Srf = tsgregory( 5, list( ctlpt( E3, 2, -1, 0 ), ctlpt( E3, 2.3, -1, 0.25 ), ctlpt( E3, 2.6, -1, 0.25 ), ctlpt( E3, 2.8, -1, 0.13 ), ctlpt( E3, 3, -1, 0 ), ctlpt( E3, 2.25, -0.7, 0.25 ), ctlpt( E3, 2.5, -0.7, -0.25 ), ctlpt( E3, 2.6, -0.7, -0.15 ), ctlpt( E3, 2.75, -0.7, 0.25 ), ctlpt( E3, 2.4, -0.4, 0.25 ), ctlpt( E3, 2.5, -0.4, 0 ), ctlpt( E3, 2.6, -0.4, -0.25 ), ctlpt( E3, 2.45, -0.2, 0.12 ), ctlpt( E3, 2.55, -0.2, -0.12 ), ctlpt( E3, 2.5, 0, 0 ), ctlpt( E3, 2.5, -0.7, -0.25 ), ctlpt( E3, 2.6, -0.7, -0.15 ), ctlpt( E3, 2.5, -0.4, 0 ) ) );

Not fully supported at this time. See also TSBEZIER and TSBSPLINE.

TSNORMAL

VectorType TSNORMAL( TriSrfType Srf, NumericType UParam, NumericType VParam, NumericType WParam)

computes the normal vector to a triangular surface Srf at the parameter values UParam, VParam, WParam. The returned vector has a unit length.

UParam, VParam, and WParam must all be non negative and must sum to one for a Bezier triangular surface or to the maximum domain, if a B-spline surface.

Example:

Normal = TSNORMAL( Srf, 0.5, 0.5, 0.0 );

computes the normal to Srf at the parameter values (0.5, 0.5, 0.0).

TVLOAD

TrivarType TVLOAD( StringType FileName, NumericType DataType, VectorType VolSize, VectorType Orders )

loads a volumetric data set from file FileName in as a trivariate of orders Orders. DataType can be one of:

1	Regular ASCII (separated by white spaces).
2	Two bytes short integer.
3	Four bytes long integer.
4	One byte (char) integer.
5	Four bytes float.
6	Eight bytes double.

Beware of the little vs big Endian problem! We assume here you have read the volume in the same machine type in which this file was written.

VolSize provides the dimensions of the volume, with width first and depth last. Uniform open end condition knot vectors are constructed to all three axes.

Example:

Tv = TVLOAD( "3dhead", 1, vector( 32, 32, 13 ), vector( 3, 3, 3 ) );

loads the data set "3dhead" of size (32, 32, 13) as a triquadratic function. THe sata set is assumed to contain ASCII numeric values.

See also MRCHCUBE.

TVZRJACOB

PolyType TVZRJACOB( TrivarType TV, NumericType Euclidean, NumericType SkipRate, NumericType Fineness )

computes the zero set of the Jacobian of the given trivariate, TV. This zero set is the implicit boundary of the trivariate and, for example, equals the envelop of the sweep of a bivariate surface in space (see example below). The zero set is returned as a polygonal data set approximation with Fineness tolerance. If Euclidean, the resulting polygons are in Euclidean space. Otherwise, the polygons are returned in the trivariate's parametric domain. Finally, SkipRate provides a mechanism to skip to every SkipRate row, column and plane while a SkipRate skips nothing.

Example:

Tv = tfromsrfs( list( Srf, Srf * tx( 3 ) * ty( 3 ), Srf * tx( 6 ) ), 3 ); Tv1ZeroJacobian = TVZRJACOB( Tv, 1, 1, 0 );

A trivariate TV is constructed as a sweep of surface Srf along a quadratic Bezier curve with (0, 0), (3, 3), (6, 0) as control points, and then the zero set of the Jacobian is derived to yield the envelope of this motion of Srf.

FIGURE: The envelope of the motion of the wine glass surface in space can be derived with the aid of the TvZrJacob function.

UVPOLY

PolyType UVPOLY( PolyType Obj, ListType Scales, ListType Translates );

Sets UV coordinates to polygonal object Obj. The UV coordinates are set using the XY Euclidean coordinates if Scales is a list that holds two scaling factors (XScale, YScale), or the UV coordinates are set via the two largest span in XYZ for each polygon, if Scales is a list of three scaling factors (XScale, YScale, ZScale). Translates offers a way to shift the UV coordinates in the texture 2D domain, Translates of (0, 0) does nothing. Needless to say, the ?Scale factors scales the Euclidean coordinates before being sets as UV texture coordinates.

Example:

UVCube = UVPOLY( Cube, list( 1, 1, 1 ), list( 0, 0 ) );

sets UV coordinates to the six faces of the cube, each face with UV values between zero and one.

ZCOLLIDE

NumericType ZCOLLIDE( GeometricTreeType Obj1, GeometricTreeType Obj2, NumericType Fineness, NumericType NumOfIters );

Given two objects, Obj1 and Obj2, where Obj1 is assumed to be above (in the Z direction) Obj2, this function computes the amount that Obj1 could be moved down, the -Z direction, until it collides with Obj2. The collision detection is considered using a polygonal approximation that has a Fineness resolution (see RESOLUTION variable). The computation cost is linear in NumOfIters with quadratic accuracy convergence. Values of ten for both Fineness and NumOfIters are reasonable selections. While Obj1 is considered in its exact form, in Obj2, only the bbox of the shape is considered.

Example:

view( chair, 1 ); for ( x = 0, 1, 5, b = box( vector( x / 10, 0, 2 ), 0.1, 0.1, 0.1 ): view( b * tz( ZCOLLIDE( chair, b, 10, 10 ) ), 0 ) );

places and draws six different cubes on top of the object called chair.

Object transformation functions

All the routines in this section construct a 4 by 4 homogeneous transformation matrix representing the required transform. These matrices may be concatenated to achieve more complex transforms using the matrix multiplication operator *. For example, the expression

m = trans( vector( -1, 0, 0 ) ) * rotx( 45 ) * trans( vector( 1, 0, 0 ) );

constructs a transform to rotate an object around the X = 1 line, 45 degrees. A matrix representing the inverse transformation can be computed as:

InvM = m ^ -1

See also overloading of the - operator.

HOMOMAT

MatrixType HOMOMAT( ListType MatData )

creates an arbitrary homogeneous transformation matrix by manually providing its 16 coefficients.

Example:

step = 10; for ( a = 1, 1, 720 / step, view_mat = save_mat * HOMOMAT( list( list( 1, 0, 0, 0 ), list( 0, 1, 0, 0 ), list( 0, 0, 1, -a * step / 500 ), list( 0, 0, 0, 1 ) ) ): view( list( view_mat, axes ), on ) );

looping and viewing through a sequence of perspective transforms, created using the HOMOMAT constructor. See also RFLCTMAT and PROJMAP.

MAP3PT2EQL

MatrixType MAP3PT2EQL( PointType Pt1, PointType Pt2, PointType Pt3 )

computes the transofrmation matrix in the XY plane that takes the given three planar points into an equilateral triangle around the origin.

Example:

Mat = MAP3PT2EQL( Pt1, Pt2, Pt3 );

See also ELLIPSE3PT, CONICSEC.

MATPOSDIR

MatrixType MATPOSDIR( PointType Pos, VectorType Dir, VectorType UpDir )

creates a viewing transformation matrix of a viewer at Pos, looking at direction Dir and upper view of UpDir.

Example:

step = 10; for ( a = 1, 1, 720 / step, view_mat = MATPOSDIR( point( 0.5, 0.1, 0.5 ), vector( 0.0, 1.0, 0.0 ), vector( cos( a * step * Pi / 360 ), 0, sin( a * step * Pi / 360 ) ) ): view( list( view_mat, axes ), on ) );

looping and viewing through a sequence of transforms, created using the MATPOSDIR constructor.

PROJMAT

MatrixType PROJMAT( PlaneType ProjPlane, VectorType EyePos, NumericType EyeInf )

constructs a projection matrix to project the universe onto the given projection plane ProjPlane, with the eye position at EyePos (divided by EyeInf). Note that if EyeInf is zero, the eye is at infinity.

Example:

PMat = PROJMAT( plane( 0, 0, 1, -0.1 ), vector( 1, 1, 1 ), 0 );

contstructs a projection matrix PMat onto the Z = -0.1 plane with a view direction of ( 1, 1, 1 ). See also RFLCTMAP, HOMOMAT.

RFLCTMAT

MatrixType RFLCTMAT( PlaneType RflctPlane )

constructs a reflection matrix to reflect the universe along the given reflection plane RflctPlane.

Example:

PMat = RFLCTMAT( plane( 0, 0, 1, 0 ) );

constructs a reflection matrix PMat around the Z = 0 plane. See also PROJMAP, HOMOMAT.

ROTV2V

MatrixType ROTV2V( VectorType Vec1, VectorType Vec2 )

creates a rotation that takes vector Vec1 to vector Vec2. See also ROTVEC, ROTZ2V, ROTZ2V2.

ROTVEC

MatrixType ROTVEC( VectorType Vec, NumericType Angle )

creates a rotation around the vector Vec matrix with Angle degrees. See also ROTV2V, ROTZ2V, ROTZ2V2.

ROTX

MatrixType ROTX( NumericType Angle )

creates a rotation around the X transformation matrix with Angle degrees.

ROTY

MatrixType ROTY( NumericType Angle )

creates a rotation around the Y transformation matrix with Angle degrees.

ROTZ

MatrixType ROTZ( NumericType Angle )

creates a rotation around the Z transformation matrix with Angle degrees.

ROTZ2V

MatrixType ROTZ2V( VectorType Dir )

creates a rotation matrix that takes Z axis into Dir. Length of Dir is ignored. See also ROTV2V, ROTVEC, ROTZ2V2.

ROTZ2V2

MatrixType ROTZ2V2( VectorType Dir, VectorType Dir2 )

creates a rotation matrix that takes the Z axis into Dir, while the X axis is aligned with Dir2. The lengths of Dir and Dir2 are ignored. See also ROTV2V, ROTVEC, ROTZ2V, ROTVEC.

SCALE

MatrixType SCALE( VectorType ScaleFactors )

creates a scaling by the ScaleFactors transformation matrix.

TRANS

MatrixType TRANS( VectorType TransFactors )

creates a translation by the TransFactors transformation matrix.

General purpose functions

ADWIDTH

ADWIDTH( GeometricType Object, NumericType DWidth )

sets the width of the object. This display width is used in pixels in display devices for width of line drawing, if supported by the display device. See also ATTRIB, COLOR, and AWIDTH.

This function is equivalent to using,

ATTRIB( Object, "dwidth", DWidth );

ATTRIB

ATTRIB( AnyType Object, StringType Name, AnyType Value )

provides a mechanism to add an attribute of any type to an Object, with name Name and value Value. This ATTRIB function is tuned and optimized toward numeric values or strings as Value although any other object type can be saved as attribute.

These attributes may be used to pass information to other programs about this object, and are saved with the objects in data files. Attributes placed on a list object or even a whole hierarchy of objects will be propagated into all items in the list or hierarchy. There are a few exception to this propagation. The "animation" attribute is not propagated and is kept in the internal nodes, forming a hierachy of animation commands for all the objects contained in the list/hierarchy. The "invisible" attribute is saved at all levels of the hierarchy, used to denote a complete sub tree that is invisible (yet can serve as a source at which instances can point).

For example,

ATTRIB(Glass, "rgb", "255,0,0"); ATTRIB(Glass, "refract", "1.4"); . . . RmAttr(Glass, "rgb"); # Removes "rgb" attribute.

sets the RGB color and refraction index of the Glass object and later removes the RGB attribute.

Attribute names are case insensitive. Spaces are allowed in the Value string, as well as the double quote itself, although the latter must be escaped:

ATTRIB(Glass, "text", "Say "this is me"");

See also RMATTR for removal of attributes, CPATTR for copying them, GETATTR to get an attribute, ATTRPROP for setting attributes on all subtrees of parts, as well as AWIDTH, ADWIDTH, COLOR and PATTRIB.

ATTRPROP

ATTRPROP( AnyType Object, StringType Name, AnyType Value )

Same as ATTRIB but propagates the attributes to all sub-parts of the object.

Example:

Glass1 = list( Base, Handle, Wine ); Glass2 = list( Base, Handle, Wine ); attrib( Glass1, "ptexture", "marble1.gif" ); ATTRPROP( Glass2, "ptexture", "marble1.gif" );

In Glass1, only Glass1 will be set with "texture" while in Glass2, the "texture" attribute will propagate to the sub-parts of Glass2, namely to the Base, Handle, Wine.

AWIDTH

AWIDTH( GeometricType Object, NumericType Width )

sets the width of the object to one of those specified below. This width is used in real object side dimensions in tools such as scan converters and rendering tools for rendering lines and curves, as well as postscript. See also ATTRIB, COLOR, and ADWIDTH.

This function is equivament to using,

ATTRIB( Object, "width", Width );

CHDIR

CHDIR( StringType NewDir )

sets the current working directory to be NewDir.

CLNTCLOSE

CLNTCLOSE( NumericType Handler, NumericType Kill )

closes a communication channel to a client. Handler contains the index of the communication channel opened via CLNTEXEC. If Kill, the client is sent an exit request for it to die. Otherwise, the communication is closed and the client runs standing alone. See also VIEWOBJ, VIEWSET, CLNTREAD, CLNTWRITE, and CLNTEXEC.

Example:

h2 = clntexec( "nuldrvs -s-" ); . . . CLNTCLOSE( h2,TRUE );

closes the connection to the nuldrvs client, opened via CLNTEXEC.

CLNTWRITE

CLNTWRITE( NumericType Handler, AnyType Object )

writes one object Object to a communication channel of a client. Handler contains the index of the communication channel opened via CLNTEXEC. If the Handler equals -1, the regular display device (forked via, for example, VIEWOBJ command) is used. If Handler equals CLIENTS_ALL, a broadcast of Object to all clients is performed. See also VIEWOBJ, VIEWSET, CLNTREAD, CLNTCLOSE, and CLNTEXEC.

Example:

h2 = clntexec( "nuldrvs -s-" ); . . CLNTWRITE( h2, Model ); . . clntclose( h2,TRUE );

writes the object named Model to client through communication channel h2.

COLOR

COLOR( GeometricType Object, NumericType Color )

sets the color of the object to one of those specified below. Note that an object has a default color (see irit.cfg file) according to its origin - loaded with the LOAD command, PRIMITIVE, or a BOOLEAN operation result. The system internally supports colors (although you may have a B&W system) and the colors recognized are: BLACK, BLUE, GREEN, CYAN, RED, MAGENTA, YELLOW, and WHITE.

See the ATTRIB command for more fine control of colors using the RGB attribute. See also AWIDTH and AWIDTH.

This function is equivament to using,

ATTRIB( Object, "color", Color );

COMMENT

COMMENT

Two types of comments are allowed:

1. One-line comment: starts anywhere in a line at the '#' character, up to the end of the line.

2. Block comment: starts at the COMMENT keyword followed by a unique character (anything but white space), up to the second occurrence of that character. This is a fast way to comment out large blocks.

Example:

COMMENT This is a comment

CPATTR

CPATTR( AnyType DestObj, AnyType SrcObj )

copies all attribute from object SrcObj into object DestObj. All attributes, if any, in DestObj are purged. Needless to say, both objects must exist at the time of attribute copy.

See also ATTRIB, ATTRPROP, GETATTR, RMATTR.

ERROR

ERROR( StringType Message);

breaks the execution and returns to the IRIT main loop, after printing a Message to the screen. This may be useful in user defined functions to break execution in cases of fatal errors.

EXEC

EXEC( StringType Command );

executes a string Command in the IRIT interepreter, indirectly.

Example:

Univariate2Bezier = function( Polynom, Deg ): x: f: return = nil(): f = 1: for ( x = 0, 0.05 / Deg, 1, EXEC( "f = " + Polynom ): snoc( ctlpt( E1, f ), return ) ): return = coerce( cinterp( return, Deg + 1, Deg + 1, PARAM_UNIFORM, FALSE ), bezier_type );

defines a function that converts univariate expressions into explicit, E1, Bezier curves. For example "Univariate2Bezier( "3 * x ^ 2 - 2 * x + 5", 3 );" would return a cubic Bezier curve representing "3 * x ^ 2 - 2 * x + 5".

EXIT

EXIT()

exits from the solid modeler. NO warning is given!

FOR

FOR( NumericType Start, NumericType Increment, NumericType End, AnyType Body )

executes the Body (see below), while the FOR loop conditions hold. Start, Increment, End are evaluated first, and the loop is executed while <= End if Increment > 0, or while >= End if Increment < 0. If Start is of the form "Variable = Expression", then that variable is updated on each iteration, and can be used within the body. The body may consist of any number of regular commands, separated by COLONs, including nesting FOR loops to an arbitrary level.

Example:

step = 10; rotstepx = rotx(step); FOR ( a = 1, 1, 360 / step, view_mat = rotstepx * view_mat: view( list( view_mat, axes ), ON ) );

displays axes with a view direction that is rotated 10 degrees at a time around the X axis.

HELP

HELP( StringType Subject )

provides help on the specified Subject.

Example:

HELP("");

will list all IRIT help subjects.

FNFREE

FNFREE( StringType UserFuncName )

frees a user defined function named UserFuncName. See also FREE.

FREE

FREE( GeometricType Object )

Because of the usually huge size of geometric objects, this procedure may be used to free them. Reassigning a value (even of different type) to a variable automatically releases the old variable's allocated space as well. See also FNFREE.

FUNCTION

FuncName = FUNCTION(Prm1, Prm2, ... , PrmN):LclVal1:LclVar2: ... :LclVarM: FuncBody;

defines a function named FuncName with N parameters and M local variables (N, M >= 0). Here is a (simple) example of a function with no local variables and a single parameter that computes the square of a number:

sqr = FUNCTION(x): return = x * x;

Functions can be defined with optional parameters and optional local variables. A function's body may contain an arbitrary set of expressions including for/while loops, (user) function calls, or even recursive function calls, all separated by colons. The returned value of the function is the value of an automatically defined local variable named return. The return variable is a regular local variable within the scope of the function and can be used as any other variable.

If a variable's name is found in neither the local variable list nor the parameter list, it is searched for in the global variable list (outside the scope of the function). Binding of names of variables is static as in the C programming language.

Because binding of variables is performed in execution time, there is a somewhat less restrictive type checking of parameters of functions that are invoked within a user's defined function.

A function can invoke itself, i.e., it can be recursive. However, since a function should be defined when it is called, a dummy function should be defined before the recursive one is defined:

factorial = function(x):return = x; # Dummy function. factorial = function(x): if (x <= 1, return = 1, return = x * factorial(x - 1));

Overloading is valid inside a function as it is outside. For example, for

add = FUNCTION(x, y): return = x + y;

the following function calls are all valid:

add(1, 2); add(vector(1,2,3), point(1,2,3)); add(box(vector(-3, -2, -1), 6, 4, 2), box(vector(-4, -3, -2), 2, 2, 4));

Finally, here is a more interesting example that computes an approximation of the length of a curve, using the sqr function defined above:

distptpt = FUNCTION(pt1, pt2): return = sqrt(sqr(coord(pt1, 1) - coord(pt2, 1)) + sqr(coord(pt1, 2) - coord(pt2, 2)) + sqr(coord(pt1, 3) - coord(pt2, 3))); crvlength = FUNCTION(crv, n):pd:t:t1:t2:dt:pt1:pt2:i: return = 0.0: pd = pdomain(crv): t1 = nth(pd, 1): t2 = nth(pd, 2): dt = (t2 - t1) / n: pt1 = coerce(ceval(crv, t1), e3): for (i = 1, 1, n, pt2 = coerce(ceval(crv, t1 + dt * i), e3): return = return + distptpt(pt1, pt2): pt1 = pt2);

Try, for example:

crvlength(circle(vector(0.0, 0.0, 0.0), 1.0), 30) / 2; crvlength(circle(vector(0.0, 0.0, 0.0), 1.0), 100) / 2; crvlength(circle(vector(0.0, 0.0, 0.0), 1.0), 300) / 2;

See PROCEDURE and IRITSTATE's "DebugFunc" for more.

IF

IF( NumericType Cond, AnyType TrueBody { , AnyType FalseBody } )

executes TrueBody (a group of regular commands, separated by COLONs - see FOR loop) if the Cond holds, i.e., it is a numeric value other than zero, or optionally, if it exists, executes FalseBody. If the Cond does not hold, i.e., it evaluates to a numeric value equal to zero.

Examples:

IF ( machine == IBMOS2, resolution = 5, resolution = 10 ); IF ( a > b, max = a, max = b );

sets the resolution to 10, unless running on an IBMOS2 system, in which case the RESOLUTION variable will be set to 5 in the first statement, and set to max to the maximum of a and b in the second statement.

INCLUDE

INCLUDE( StringType FileName )

executes the script file FileName. Nesting of an include file is allowed up to 10 levels deep. If an error occurs, all open files in all nested files are closed and data are waited for at the top level (standard input). Files are searched for inclusion in the current directory. If not found, and the inclusion is from a different file at some directory, that directory is searched as well. Finally, if all the above fails, the directories specified via the IRIT_INCLUDE environment variable are also searched.

A script file can contain any command the solid modeler supports.

Example:

INCLUDE( "/tmp/general.irt" );

includes the file "/tmp/general.irt". Any inclusion inside general.irt will search for the included file in the current directory, then in /tmp, and then in the directories specified via IRIT_INCLUDE.

INSERTPOLY

INSERTPOLY( PolyType Poly, PolyType Polys )

inserts, in place, Poly as a new polygon of object Polys. After the completion of this function Poly is unmodified but Polys has a new polygon in it.

Example:

X = poly( list( point( 0, 0, 0 ), point( 0, 1, 0 ), point( 1, 1, 0 ), point( 1, 0, 0 ) ), false ); Y = X * tz( 1 ); INSERTPOLY( Y, X );

At the end of the execution of this sequence of command, X contains two polygons, one at Z = 0 and one at Z = 1. See also MERGEPOLY, SPLITLST.

INTERACT

INTERACT( GeometryTreeType Object )

This is a user-defined function (see iritinit.irt) that does the following, in order outlined:

Clear the display device.

Display the given Object.

Pause for a keystroke.

This user-defined function in version 4.0 of IRIT is an emulation of the INTERACT function that used to exist in previous versions.

Example:

INTERACT( list( view_mat, Axes, Obj ) );

displays and interacts with the object Obj and the predefined object Axes. VIEW_MAT will be used to set the starting transformation.

See VIEW and VIEWOBJ for more.

IQUERY

IQUERY( NumericType QueryType )

A low level query tool for checking the current state of the IRIT internal tables. According to the values of QueryType the following is printed to stdout:

QueryType	Printed content
1	All the known functions/user defined functions/constants
	and parameters/returned values (if any).
2	All the knwon keywords

LIST

ListType LIST( AnyType Elem1, AnyType Elem2, ... )

constructs an object as a list of several other objects. Only a reference is made to the Elements, so modifying Elem1 after being included in the list will affect Elem1 in that list next time list is used!

Each inclusion of an object in a list increases its internal used reference. The object is freed iff theused reference is zero. As a result, attempt to delete a variable (using FREE) which is referenced in a list removes the variable, but the object itself is freed only when the list is freed.

LOAD

AnyType LOAD( StringType FileName )

loads an object from the given FileName. The object may be any object defined in the system, including lists, in which the structure is recovered and reconstructed as well (internal objects are inserted into the global system object list if they have names). If no file type is provided, ".itd" is assumed.

This command can also be used to load binary files. ASCII regular data files usually take longer to load than binary files due to the required parsing. Binary data files can be loaded directly, like ASCII files in IRIT, but can only be inspected through IRIT tools such as dat2irit. A binary data file must have a ".ibd" (IRIT Binary Data) type in its name.

Compressed files can be loaded if the given file name has a postfix of ".Z" or .".gz". The gnu utility "gzip" will be invoked via a pipe for that purpose.

See also IRITSTATE's option "FlatLoad" for optioanl flattening of the object hierarechy during a load.

LOGFILE

LOGFILE( NumericType Set ) or LOGFILE( StringType FileName )

If Set is non zero (see TRUE/FALSE and ON/OFF), then everything printed in the input window will go to the log file specified in the irit.cfg configuration file. This file will be created the first time logfile is turned ON. If a string FileName is provided, it will be used as a log file name from now on. It also closes the current log file. A "LOGFILE( on );" must be issued after a log file name change.

Example:

LOGFILE( "Data1" ); LOGFILE( on ); printf( "Resolution = %lf\n", list( resolution ) ); LOGFILE( off );

to print the current resolution level into file Data1.

MSLEEP

MSLEEP( NumericType MilliSeconds )

causes the solid modeller to sleep for the prescribed time in milliseconds.

Example:

for ( i = 1, 1, sizeof( crvs ), c = nth( crvs, i ): color( c, yellow ): msleep(20): viewobj( c ) );

displays an animation sequence and sleeps for 20 milliseconds between iterations.

NREF

AnyType NREF( ListType ListObject, NumericType Index )

returns a reference to the Index (base count 1) element of the list ListObject. The reference points to the original object and hence can be used to modify (add attributes for example) to objects in lists. Assignment of this reference to a new object would result in a copy of the object. In contrast, a FREE of a reference to an object would have an undefined result.

Example:

Lst = list( a, b, c ); attrib( NREF( Lst, 2 ), "NewAttr", on );

adds a new attribute to the second element of Lst. See also NTH.

NRMLCONE

ListType NRMLCONE( SurfaceType Srf )

computes a cone that bounds all normals of surface Srf. A list of two objects, the axis vector of the cone and the opening radius, in radians, is returned.

Example:

NCone = NRMLCONE( Srf ); Cn = Cone( vector( 0, 0, 0 ), normalize( nth( NCone, 1 ) ), nth( NCone, 2 ), 0 ) * tz( 1.0 ) * sc( 0.75 );

computes a normals' cone for surface Srf and builds a real cone following these limits.

NTH

AnyType NTH( ListType ListObject, NumericType Index )

returns the Index (base count 1) element of the list ListObject.

Example:

Lst = list( a, list( b, c ), d ); Lst2 = NTH( Lst, 2 );

and now Lst2 is equal to 'list( b, c )'. See also NREF.

PAUSE

PAUSE( NumericType Flush )

waits for a keystroke. This is nice to have if a temporary stop in a middle of an included file (see INCLUDE) is required. If Flush is TRUE, then the input is first flushed to guarantee that the actual stop will occur.

PRINTF

PRINTF( StringType CtrlStr, ListType Data )

This results in a formatted printing routine, following the concepts of the C programming language's printf routine. CtrlStr is a string object for which the following special '%' commands are supported:

%d, %i, %u	Prints the numeric object as an integer or unsigned integer.
%o, %x, %X	Prints the numeric object as an octal or hexadecimal integer.
%e, %f, %g,	Prints the numeric object in several formats of
%E, %F	floating point numbers.
%s	Prints the string object as a string.
%pe, %pf, %pg	Prints the three coordinates of the point object.
%ve, %vf, %vg	Prints the three coordinates of the vector object.
%Pe, %Pf, %Pg,	Prints the four coordinates of the plane object.
%De, %Df, %Dg,	Prints the given object in IRIT's data file format.

All the '%' commands can include any modifier that is valid in the C programming language PRINTF routine, including l (long), prefix character(s), size, etc. The point, vector, plane, and object commands can also be modified in a similar way, to set the format of the numeric data printed.

Also supported are the newline and tab using the backslash escape character:

PRINTF("\tThis is the char "\%"\n", nil());

Backslashes should be escaped themselves as can be seen in the above example. Here are few more examples:

PRINTF("this is a string "%s" and this is an integer %8d.\n", list("STRING", 1987)); PRINTF("this is a vector [%8.5lvf]\n", list(vector(1,2,3))); IritState("DumpLevel", 9); PRINTF("this is a object %8.6lDf...\n", list(axes)); PRINTF("this is a object %10.8lDg...\n", list(axes));

This implementation of PRINTF is somewhat different than the C programming language's version, because the backslash always escapes the next character during the processing stage of IRIT's parser. That is, the string

'\tThis is the char "\%"\n'

is actually parsed by the IRIT's parser into

'tThis is the char "%"n'

because this is the way the IRIT parser processes strings. The latter string is the one that PRINTF actually sees.

See also PRINTFILE for ways to redirect PRINTF to a file..

PRINTFILE

PRINTFILE( StringType FileName );

Sets the file PRINTF prints to to FileName. Any newer call to PRINTFILE will close the current file used so far. If FileName is an empty string, PRINTF will print to stdout.

PROCEDURE

ProcName = PROCEDURE(Prm1, Prm2, ... , PrmN):LclVal1:LclVar2: ... :LclVarM: ProcBody;

A procedure is a function that does not return a value, and therefore the returned variable (see FUNCTION) should not be used. A procedure is identical to a function in every other way. See FUNCTION for more.

RESET

RESET()

clears all variables and initializes the environment to the starting state. User defined functions, however, are kept intact.

RMATTR

RMATTR( AnyType Object, StringType Name )

removes attribute named Name from object Object. This function will have no affect on the Object if the Object has no attribute named Name.

See also ATTRIB, ATTRPROP, GETATTR, CPATTR.

SAVE

SAVE( StringType FileName, AnyType Object )

saves the provided Object in the specified file name FileName. No extension type is needed (ignored if specified), and ".itd" is supplied by default. The Object can be any object type, including list, in which the structure is saved recursively. See also LOAD. If a display device is actively running at the time SAVE is invoked, its transformation matrix will be saved with the same name but with extension type of ".imd" instead of ".itd".

This command can also be used to save binary files. ASCII regular data files usually take longer to load than binary files due to the required parsing. Binary data files can be loaded directly like ASCII files in IRIT, but must be inspected through IRIT tools such as dat2irit. A binary data file must have a ".ibd" (IRIT Binary Data) type in its name.

This command can also save geometry in one of the following formats:

IGES file, If the file type is either "igs" or "iges".

STL file, if the file type is "stl". If Object has the int attribute "RegularTriang" as TRUE, the geometry will be regularized first (no T junctions). If Object has the int attribute "MultiObjSplit", the data will be saved in one large STL object in one file if 0, one STL object per IRIT object in one file if 1, or in one file per IRIT obejct if 2.

VRML file. if the file type is "wrl".

CNC Gcode tool path file, if the file type is either "nc" or "gcode". For this format, only univariate data sets (polylines and curves) will be processed and saved as 3-axis G code commands. The following attributes are supported in this mode, if found in Object:

"NCCommentChar"	Holds a string of one character to define the
	comment character. If exists a header comment is