Geometry


Functions

void TecUtilGeomDelete (Geom_ID GID)
  Deletes the specified geometry object.
Boolean_t TecUtilGeomIsValid (Geom_ID GID)
  Validate a geometry ID.
Clipping_e TecUtilGeomGetClipping (Geom_ID GID)
  Function will get the clipping properties of a geometry.
void TecUtilGeomGetAnchorPos (Geom_ID GID, double *XOrThetaPos, double *YOrRPos, double *ZPos)
  Gets the anchor postion of the specified geometry.
void TecUtilGeomImageSetUseRatio (Geom_ID GID, Boolean_t MaintainAspectRatio)
  Sets the state of the "preserve aspect ratio" toggle for an image geometry.
void TecUtilGeomGetXYZAnchorPos (Geom_ID GID, double *XPos, double *YPos, double *ZPos)
 
EntIndex_t TecUtilGeomGetZoneOrMap (Geom_ID GID)
  Get the zone or Line-mapping to which the geometry is attached.
Boolean_t TecUtilGeomIsAttached (Geom_ID GID)
  Determine whether or not a geometry is attached to a zone or Line-mapping.
ColorIndex_t TecUtilGeomGetColor (Geom_ID GID)
  Get the geometry line color.
ColorIndex_t TecUtilGeomGetFillColor (Geom_ID GID)
  Get the geometry fill color.
Boolean_t TecUtilGeomGetIsFilled (Geom_ID GID)
  Determine if a geometry if filled.
GeomForm_e TecUtilGeomGetType (Geom_ID GID)
  Get the geometry type.
LinePattern_e TecUtilGeomGetLinePattern (Geom_ID GID)
  Get the line pattern of a geometry.
double TecUtilGeomGetPatternLength (Geom_ID GID)
  Get the geometry line pattern length.
double TecUtilGeomGetLineThickness (Geom_ID GID)
  Get the geometry line thickness.
SmInteger_t TecUtilGeomEllipseGetNumPoints (Geom_ID GID)
  Get the number of points used to draw a circle or ellipse geometry.
ArrowheadStyle_e TecUtilGeomArrowheadGetStyle (Geom_ID GID)
  Get the geometry arrowhead style.
ArrowheadAttachment_e TecUtilGeomArrowheadGetAttach (Geom_ID GID)
  Get the geometry arrowhead attachment.
double TecUtilGeomArrowheadGetSize (Geom_ID GID)
  Get the geometry arrowhead size.
double TecUtilGeomArrowheadGetAngle (Geom_ID GID)
  Get the geometry arrowhead angle.
Scope_e TecUtilGeomGetScope (Geom_ID GID)
  Get the geometry scope.
CoordSys_e TecUtilGeomGetPositionCoordSys (Geom_ID GID)
  Get the geometry position coordinate system.
ImageResizeFilter_e TecUtilGeomImageGetResizeFilter (Geom_ID GID)
  Get the resize filter of an image geometry.
void TecUtilGeomImageSetResizeFilter (Geom_ID GID, ImageResizeFilter_e ResizeFilter)
  Sets the resize filter of an image geometry.
void TecUtilGeomImageGetFileName (Geom_ID GID, char **FileName)
  Get the name of the file associated with an image geometry.
void TecUtilGeomImageSetWidth (Geom_ID GID, double Width)
  Sets the width of an image geometry.
void TecUtilGeomImageSetHeight (Geom_ID GID, double Height)
  Sets the Height of an image geometry.
void TecUtilGeomImageGetSize (Geom_ID GID, double *Width, double *Height)
  Get the width and height of an image geometry.
void TecUtilGeomImageResetAspectRatio (Geom_ID GID)
  Resets the aspect ratio after any changes have been made in the position of an image geometry.
Boolean_t TecUtilGeomGetMacroFunctionCmd (Geom_ID GID, char **MacroFunctionCmd)
  Get the geometry macro function command.
Geom_ID TecUtilGeomImageCreate (const char *FName, double CornerX, double CornerY, double Size)
  Create an image geometry.
Geom_ID TecUtilGeomGetNext (Geom_ID GID)
  Get the next geometry in the list of geometries attached to the current frame.
Geom_ID TecUtilGeomGetPrev (Geom_ID GID)
  Get the previous geometry in the list of geometries attached to the current frame.
void TecUtilGeomSetClipping (Geom_ID GID, Clipping_e Clipping)
  Set the clipping properties of a geometry.
void TecUtilGeomSetAnchorPos (Geom_ID GID, double XPos, double YPos, double ZPos)
  Set the anchor position for a geometry.
void TecUtilGeomSetXYZAnchorPos (Geom_ID GID, double XPos, double YPos, double ZPos)
 
void TecUtilGeomSetZoneOrMap (Geom_ID GID, EntIndex_t ZoneOrMap)
  Set the zone or Line-mapping attachment for a geometry.
void TecUtilGeomSetAttached (Geom_ID GID, Boolean_t Attached)
  Set whether or not a geometry is attached to a zone or Line-mapping.
void TecUtilGeomSetColor (Geom_ID GID, ColorIndex_t Color)
  Set the line color of a geometry.
void TecUtilGeomSetFillColor (Geom_ID GID, ColorIndex_t FillColor)
  Set the fill color of a geometry.
void TecUtilGeomSetIsFilled (Geom_ID GID, Boolean_t IsFilled)
  Set whether or not a geometry is filled with a color.
void TecUtilGeomSetLinePattern (Geom_ID GID, LinePattern_e LinePattern)
  Set the line pattern for a geometry.
void TecUtilGeomSetPatternLength (Geom_ID GID, double PatternLength)
  Set the line pattern length for a geometry.
void TecUtilGeomSetLineThickness (Geom_ID GID, double LineThickness)
  Set the line thickness for a geometry.
void TecUtilGeomEllipseSetNumPoints (Geom_ID GID, SmInteger_t NumEllipsePts)
  Set the number of points used to draw a circle or an ellipse geometry.
void TecUtilGeomArrowheadSetStyle (Geom_ID GID, ArrowheadStyle_e ArrowheadStyle)
  Set the arrowhead style for a geometry.
void TecUtilGeomArrowheadSetAttach (Geom_ID GID, ArrowheadAttachment_e ArrowheadAttachment)
  Set the arrowhead attachment for a geometry.
void TecUtilGeomArrowheadSetSize (Geom_ID GID, double ArrowheadSize)
  Set the arrowhead size for a geometry.
void TecUtilGeomArrowheadSetAngle (Geom_ID GID, double ArrowheadAngle)
  Set the arrowhead angle for a geometry.
void TecUtilGeomSetDrawOrder (Geom_ID GID, DrawOrder_e DrawOrder)
  Sets the draw order of a geometry.
Boolean_t TecUtilGeomImageGetUseRatio (Geom_ID GID)
  Queries the state of the "preserve aspect ratio" toggle for an image geometry.
DrawOrder_e TecUtilGeomGetDrawOrder (Geom_ID GID)
  Gets the draw order of a geometry.
void TecUtilGeomSetScope (Geom_ID GID, Scope_e Scope)
  Set the scope for a geometry.
void TecUtilGeomSetPositionCoordSys (Geom_ID GID, CoordSys_e CoordSys)
  Set the position coordinate system for a geometry.
Boolean_t TecUtilGeomSetMacroFunctionCmd (Geom_ID GID, const char *Command)
  Set the macro function command for a geometry.
Geom_ID TecUtilGeomSquareCreate (CoordSys_e PositionCoordSys, double CornerX, double CornerY, double Size)
  Create a square geometry.
Geom_ID TecUtilGeomCircleCreate (CoordSys_e PositionCoordSys, double CenterX, double CenterY, double Radius)
  Create a circle geometry.
Geom_ID TecUtilGeomRectangleCreate (CoordSys_e PositionCoordSys, double CornerX, double CornerY, double Width, double Height)
  Create a rectangle geometry.
Geom_ID TecUtilGeomEllipseCreate (CoordSys_e PositionCoordSys, double CenterX, double CenterY, double HAxis, double VAxis)
  Create an ellipse geometry.
Geom_ID TecUtilGeom2DPolylineCreate (CoordSys_e PositionCoordSys, double *PtsX_Array, double *PtsY_Array, LgIndex_t NumPts)
  Create a 2-D polyline geometry.
Geom_ID TecUtilGeom3DPolylineCreate (double *PtsX_Array, double *PtsY_Array, double *PtsZ_Array, LgIndex_t NumPts)
  Create a 3-D polyline geometry.
Geom_ID TecUtilGeom2DMPolyCreate (CoordSys_e PositionCoordSys, LgIndex_t NumPolys, LgIndex_t *NumPointsInPolylines_Array)
  Create a 2-D multi-polyline geometry.
Geom_ID TecUtilGeom3DMPolyCreate (LgIndex_t NumPolys, LgIndex_t *NumPointsInPolylines_Array)
  Create a 3-D multi-polyline geometry.
Geom_ID TecUtilGeomArcCreate (CoordSys_e PositionCoordSys, double CenterX, double CenterY, double Radius, double StartAngle, double EndAngle)
  Create a 2-D arc.
Geom_ID TecUtilGeom2DLineSegmentCreate (CoordSys_e PositionCoordSys, double X1, double Y1, double X2, double Y2)
  Create a 2-D line geometry.
Geom_ID TecUtilGeom3DLineSegmentCreate (double X1, double Y1, double Z1, double X2, double Y2, double Z2)
  Create a 3-D line.
LgIndex_t TecUtilGeomMPolyGetPolylineCnt (Geom_ID GID)
  Get the number of polylines in a multi-polyline geometry.
LgIndex_t TecUtilGeomPolyGetPointCount (Geom_ID GID)
  Get the number of points in a polyline geometry.
LgIndex_t TecUtilGeomMPolyGetPointCount (Geom_ID GID, LgIndex_t PolyNum)
  Get information about the number of points in a polyline of a multi-polyline geometry.
void TecUtilGeom2DMPolyGetPoint (Geom_ID GID, LgIndex_t PolyNum, LgIndex_t PointIndex, double *X, double *Y)
  Gets the 2-D (X,Y) value of point in a 2-D multi-polyline geometry.
void TecUtilGeom2DPolylineGetPoint (Geom_ID GID, LgIndex_t PointIndex, double *X, double *Y)
  Get a point (X,Y) of a 2-D polyline.
void TecUtilGeom2DMPolySetPoint (Geom_ID GID, LgIndex_t PolyNum, LgIndex_t PointIndex, double X, double Y)
  Set the 2-D (X,Y) value of point in a 2-D multi-polyline geometry.
void TecUtilGeom2DPolylineSetPoint (Geom_ID GID, LgIndex_t PointIndex, double X, double Y)
  Set a point (X,Y) of a 2-D polyline.
void TecUtilGeom2DMPolySetPolyline (Geom_ID GID, LgIndex_t PolyNum, double *X_Array, double *Y_Array)
  Set the points for a polyline in a 2-D multi-polyline geometry.
void TecUtilGeom3DMPolyGetPoint (Geom_ID GID, LgIndex_t PolyNum, LgIndex_t PointIndex, double *X, double *Y, double *Z)
  Get the 3-D (X, Y, Z) value of point in a 3-D multi-polyline geometry.
void TecUtilGeom3DPolylineGetPoint (Geom_ID GID, LgIndex_t PointIndex, double *X, double *Y, double *Z)
  Get a point (X, Y, Z) of a 3-D polyline
void TecUtilGeom3DMPolySetPoint (Geom_ID GID, LgIndex_t PolyNum, LgIndex_t PointIndex, double X, double Y, double Z)
  Set the 3-D (X, Y, Z) value of point in a 3-D multi-polyline geometry.
void TecUtilGeom3DPolylineSetPoint (Geom_ID GID, LgIndex_t PointIndex, double X, double Y, double Z)
  Set a point (X, Y, Z) of a 3-D polyline.
void TecUtilGeom3DMPolySetPolyline (Geom_ID GID, LgIndex_t PolyNum, double *X_Array, double *Y_Array, double *Z_Array)
  Set the points for a polyline in a 3-D multi-polyline geometry.
double TecUtilGeomCircleGetRadius (Geom_ID GID)
  Return the radius of a circle geometry.
void TecUtilGeomCircleSetRadius (Geom_ID GID, double Radius)
  Set the radius of a circle geometry.
double TecUtilGeomSquareGetSize (Geom_ID GID)
  Get the size of a square geometry.
void TecUtilGeomSquareSetSize (Geom_ID GID, double Size)
  Set the size of a square geometry.
void TecUtilGeomRectangleGetSize (Geom_ID GID, double *Width, double *Height)
  Get the width and height of a rectangle geometry.
void TecUtilGeomRectangleSetSize (Geom_ID GID, double Width, double Height)
  Set the width and height of a rectangle geometry.
void TecUtilGeomEllipseGetSize (Geom_ID GID, double *HAxis, double *VAxis)
  Get length of the axes of an ellipse.
void TecUtilGeomEllipseSetSize (Geom_ID GID, double HAxis, double VAxis)
  Set the length of the axes of an ellipse.
Geom_ID TecUtilGeomGetBase (void)
  Get the base geometry attached to the current frame.

Function Documentation

Geom_ID TecUtilGeom2DLineSegmentCreate ( CoordSys_e  PositionCoordSys,
double  X1,
double  Y1,
double  X2,
double  Y2 
)

Create a 2-D line geometry.

Use the ID obtained from this function to set geometry attributes such as line style and color using the TecUtilGeomSetXxx functions.

Parameters:
PositionCoordSys Coordinate system used to position the geometry. The possible values are: CoordSys_Grid or CoordSys_Frame.
X1 X-Coordinate for the starting position of the line.
Y1 Y-Coordinate for the starting position of the line.
X2 X-Coordinate for the ending position of the line.
Y2 Y-Coordinate for the ending position of the line.
Returns:
If successfully created then the return value is a valid ID that you may use to further set attributes for this geometry. Otherwise, TECUTILBADID is returned.
Fortran Syntax:
    SUBROUTINE TecUtilGeom2DLineSegmentCreate(
   &           PositionCoordSys,
   &           X1,
   &           Y1,
   &           X2,
   &           Y2,
   &           ResultPtr)
    INTEGER*4      PositionCoordSys
    REAL*8         X1
    REAL*8         Y1
    REAL*8         X2
    REAL*8         Y2
    POINTER        (ResultPtr, Result)

Python Syntax:

  Results = TecUtil.Geom2DLineSegmentCreate(PositionCoordSys, X1, Y1, X2, Y2)

  Input:
                  PositionCoordSys     CoordSys_e  (defined in TecVals.py)
                  X1                   double
                  Y1                   double
                  X2                   double
                  Y2                   double
  Output:
    Results[0]    ReturnVal            long

Create a 2-D line geometry from (0.1, 0.2) to (0.5, 0.6):

   Geom_ID G;
   G = TecUtilGeom2DLineSegmentCreate(CoordSys_Grid,
                                      .1,.2,.5,.6);

Geom_ID TecUtilGeom2DMPolyCreate ( CoordSys_e  PositionCoordSys,
LgIndex_t  NumPolys,
LgIndex_t *  NumPointsInPolylines_Array 
)

Create a 2-D multi-polyline geometry.

After creating the 2-D multi-polyline geometry, you must assign values to the points in it with TecUtilGeom2DPolylineSetPoint() or TecUtilGeom2DMPolySetPolyline(). Use the ID obtained from this function to set geometry attributes such as line style and color using the TecUtilGeomSetXxx functions.

Parameters:
PositionCoordSys Coordinate System. The possible values are: CoordSys_Grid or CoordSys_Frame.
NumPolys Number of polylines in the multi-polyline. Must be greater than zero
NumPointsInPolylines_Array Array of points in each polyline. Each polyline must have at least two points
Returns:
The geometry ID of the 2-D multi polyline.
Precondition:
VALID_REF(NumPointsInPolylines) Pointer must be a valid address and non-NULL.
Fortran Syntax:
    SUBROUTINE  TecUtilGeom2DMPolyCreate(
   &            PositionCoordSys,
   &            NumPolys,
   &            NumPointsInPolylines_Array,
   &            ResultPtr)
    INTEGER*4       PositionCoordSys
    INTEGER*4       NumPolys
    INTEGER*4       NumPointsInPolylines_Array
    POINTER         (ResultPtr, Result)

Python Syntax:

  Results = TecUtil.Geom2DMPolyCreate(PositionCoordSys, NumPolys, NumPointsInPolylines_Array)

  Input:
                  PositionCoordSys     CoordSys_e  (defined in TecVals.py)
                  NumPolys             int
                  NumPointsInPolylines_Array list of ints
  Output:
    Results[0]    ReturnVal            long

Create a 2-D multi-polyline with two polylines. The first polyline has three points, the second has two:

   LgIndex_t pts_per_line[2] = { 3, Z }; // two polylines
   double x_polyline_1 = { 0.0, 1.0, 2.0 }; // three points
   double y_polyline_1 = { 0.0, 1.0, 0.0 };
   double x_polyline_2 = { 1.0, 2.0 }; // two points
   double y_polyline_2 = { 1.0, 0.0 };
   Geom_ID g;

   g = TecUtilGeom2DMPolyCreate(CoordSys_Grid, Z, pts_per_line);
   TecUtilGeom2DMPolySetPolyline(g, 1, x_polyline_1, y_polyline_1);
   TecUtilGeom2DMPolySetPolyline(g, 2, x_polyline_2, y_polyline_2);

void TecUtilGeom2DMPolyGetPoint ( Geom_ID  GID,
LgIndex_t  PolyNum,
LgIndex_t  PointIndex,
double *  X,
double *  Y 
)

Gets the 2-D (X,Y) value of point in a 2-D multi-polyline geometry.

Parameters:
GID Geometry ID. This must be a 2-D multi-polyline geometry
PolyNum Polyline number. Must be greater than or equal to one, and less than or equal to the number of polylines in the geometry
PointIndex Index of the point in the polyline. Must be greater than or equal to one, and less than or equal to the number of points in the polyline
X Receives the X-value of the point. Must not be NULL
Y Receives the Y-value of the point. Must not be NULL
Precondition:
VALID_REF(XOrTheta) Pointer must be a valid address and non-NULL.

VALID_REF(YOrR) Pointer must be a valid address and non-NULL.

GID must be a valid geometry ID.

Fortran Syntax:
    SUBROUTINE TecUtilGeom2DMPolyGetPoint(
   &           GIDPtr,
   &           PolyNum,
   &           PointIndex,
   &           X,
   &           Y)
    POINTER         (GIDPtr, GID)
    INTEGER*4       PolyNum
    INTEGER*4       PointIndex
    REAL*8          X
    REAL*8          Y

Python Syntax:

  Results = TecUtil.Geom2DMPolyGetPoint(GID, PolyNum, PointIndex)

  Input:
                  GID                  long
                  PolyNum              int
                  PointIndex           int
  Output:
    Results[0]    X                    double
    Results[1]    Y                    double

Get the value of the tenth point in the second polyline of a 2-D multi-polyline geometry:

   double X,Y;
   extern Geom_ID g; // assume this was allocated somewhere
   TecUtilGeom2DMPolyGetPoint(g,2,10,&X,&Y);

void TecUtilGeom2DMPolySetPoint ( Geom_ID  GID,
LgIndex_t  PolyNum,
LgIndex_t  PointIndex,
double  X,
double  Y 
)

Set the 2-D (X,Y) value of point in a 2-D multi-polyline geometry.

Parameters:
GID Geometry ID. This must be a 2-D multi-polyline geometry
PolyNum Polyline number. Must be greater than or equal to one, and less than or equal to the number of polylines in the geometry
PointIndex Index of the point in the polyline. Must be greater than or equal to one, and less than or equal to the number of points in the polyline
X New X-value of the point
Y New Y-value of the point
Precondition:
GID must be a valid geometry ID.
Fortran Syntax:
    SUBROUTINE TecUtilGeom2DMPolySetPoint(
   &           GIDPtr,
   &           PolyNum,
   &           PointIndex,
   &           X,
   &           Y)
    POINTER         (GIDPtr, GID)
    INTEGER*4       PolyNum
    INTEGER*4       PointIndex
    REAL*8          X
    REAL*8          Y

Python Syntax:

  Results = TecUtil.Geom2DMPolySetPoint(GID, PolyNum, PointIndex, X, Y)

  Input:
                  GID                  long
                  PolyNum              int
                  PointIndex           int
                  X                    double
                  Y                    double
  Output:
    Results[0]    ReturnVal            NONE

Set the value of the tenth point in the second polyline of a 2-D multi-polyline geometry:

   extern Geom_ID g; // assume this was allocated somewhere
   TecUtilGeom2DMPolySetPoint(g,2,10,1.5,2.2);//set to (1.5,2.2)

void TecUtilGeom2DMPolySetPolyline ( Geom_ID  GID,
LgIndex_t  PolyNum,
double *  X_Array,
double *  Y_Array 
)

Set the points for a polyline in a 2-D multi-polyline geometry.

Parameters:
GID Geometry ID. This must be a 2-D multi-polyline geometry
PolyNum Polyline number. Must be greater than or equal to one, and less than or equal to the number of polylines in the geometry
X_Array Array of X-values. The number of X-values must be equal to the number of points in the polyline specified by PolyNum. Must not be NULL
Y_Array Array of Y-values. The number of Y-values must be equal to the number of points in the polyline specified by PolyNum. Must not be NULL
Precondition:
VALID_REF(XOrThetaArray) Pointer must be a valid address and non-NULL.

VALID_REF(YOrRArray) Pointer must be a valid address and non-NULL.

GID must be a valid geometry ID.

Fortran Syntax:
    SUBROUTINE TecUtilGeom2DMPolySetPolyline(
   &           GIDPtr,
   &           PolyNum,
   &           X_Array,
   &           Y_Array)
    POINTER         (GIDPtr, GID)
    INTEGER*4       PolyNum
    REAL*8          X_Array
    REAL*8          Y_Array

Python Syntax:

  Results = TecUtil.Geom2DMPolySetPolyline(GID, PolyNum, X_Array, Y_Array)

  Input:
                  GID                  long
                  PolyNum              int
                  X_Array              list of doubles
                  Y_Array              list of doubles
  Output:
    Results[0]    ReturnVal            NONE

Geom_ID TecUtilGeom2DPolylineCreate ( CoordSys_e  PositionCoordSys,
double *  PtsX_Array,
double *  PtsY_Array,
LgIndex_t  NumPts 
)

Create a 2-D polyline geometry.

Use the ID obtained from this function to set geometry attributes such as line style and color using the TecUtilGeomSetXxx functions. By default, the anchor position is set to (0,0). All points are drawn relative to the anchor position. The anchor position can be changed using TecUtilGeomSetXYZAnchorPos().

Parameters:
PositionCoordSys Coordinate system used to position the geometry. The possible values are: CoordSys_Grid or CoordSys_Frame.
PtsX_Array Array of X-coordinates of the polyline
PtsY_Array Array of Y-coordinates of the polyline
NumPts Number of points in the array (that is, number of points in the polyline). Must be at least two points.
Returns:
If successfully created, then the return value is a valid ID that you may use to further set attributes for this geometry. Otherwise, TECUTILBADID is returned.
Precondition:
VALID_REF(PtsX) Pointer must be a valid address and non-NULL.

VALID_REF(PtsY) Pointer must be a valid address and non-NULL.

Fortran Syntax:
    SUBROUTINE TecUtilGeom2DPolylineCreate(
   &           PositionCoordSys,
   &           PtsX_Array,
   &           PtsY_Array,
   &           NumPts,
   &           ResultPtr)
    INTEGER*4      PositionCoordSys
    REAL*8         PtsX_Array
    REAL*8         PtsY_Array
    INTEGER*4      NumPts
    POINTER        (ResultPtr, Result)

Python Syntax:

  Results = TecUtil.Geom2DPolylineCreate(PositionCoordSys, PtsX_Array, PtsY_Array, NumPts)

  Input:
                  PositionCoordSys     CoordSys_e  (defined in TecVals.py)
                  PtsX_Array           list of doubles
                  PtsY_Array           list of doubles
                  NumPts               int
  Output:
    Results[0]    ReturnVal            long

Create a 2-D polyline with four points: 

   double X[4] = {.2,.5,.6,.4}; //x coords of the polyline
   double Y[4] = {.2,.5,.1,.7}; //y coords of the polyline
   Geom_ID G;
   G = TecUtilGeom2DPolylineCreate(CoordSys_Grid,X,Y,4);

void TecUtilGeom2DPolylineGetPoint ( Geom_ID  GID,
LgIndex_t  PointIndex,
double *  X,
double *  Y 
)

Get a point (X,Y) of a 2-D polyline.

Parameters:
GID Geometry ID. This must be a 2-D multi-polyline geometry
PointIndex Index of the point in the polyline. Must be greater than or equal to one, and less than or equal to the number of points in the polyline
X Receives the X-value of the point. Must not be NULL
Y Receives the Y-value of the point. Must not be NULL
Precondition:
VALID_REF(XOrTheta) Pointer must be a valid address and non-NULL.

VALID_REF(YOrR) Pointer must be a valid address and non-NULL.

GID must be a valid geometry ID.

Fortran Syntax:
    SUBROUTINE TecUtilGeom2DPolylineGetPoint(
   &           GIDPtr,
   &           PointIndex,
   &           X,
   &           Y)
    POINTER         (GIDPtr, GID)
    INTEGER*4       PointIndex
    REAL*8          X
    REAL*8          Y

Python Syntax:

  Results = TecUtil.Geom2DPolylineGetPoint(GID, PointIndex)

  Input:
                  GID                  long
                  PointIndex           int
  Output:
    Results[0]    X                    double
    Results[1]    Y                    double

Get the second point of a 2-D polyline geometry:

   double X,Y;
   extern Geom_ID g; // allocated somewhere else
   TecUtilGeom2DPolylineGetPoint(g,2,&X,&Y);

void TecUtilGeom2DPolylineSetPoint ( Geom_ID  GID,
LgIndex_t  PointIndex,
double  X,
double  Y 
)

Set a point (X,Y) of a 2-D polyline.

Parameters:
GID Geometry ID. This must be a 2-D multi-polyline geometry
PointIndex Index of the point to set. Must be greater than or equal to one, and less than or equal to the number of points in the polyline
X The new X-value of the point
Y The new Y-value of the point
Precondition:
GID must be a valid geometry ID.
Fortran Syntax:
    SUBROUTINE TecUtilGeom2DPolylineSetPoint(
   &           GIDPtr,
   &           PointIndex,
   &           X,
   &           Y)
    POINTER         (GIDPtr, GID)
    INTEGER*4       PointIndex
    REAL*8          X
    REAL*8          Y

Python Syntax:

  Results = TecUtil.Geom2DPolylineSetPoint(GID, PointIndex, X, Y)

  Input:
                  GID                  long
                  PointIndex           int
                  X                    double
                  Y                    double
  Output:
    Results[0]    ReturnVal            NONE

Set the second point of a 2-D polyline geometry:

   extern Geom_ID g; // allocated somewhere else

   // set to (1.1,2.5)
   TecUtilGeom2DPolylineSetPoint(g,2,1.1,2.5);

Geom_ID TecUtilGeom3DLineSegmentCreate ( double  X1,
double  Y1,
double  Z1,
double  X2,
double  Y2,
double  Z2 
)

Create a 3-D line.

Use the ID obtained from this function to set geometry attributes such as line style and color using the TecUtilGeomSetXxx functions. All coordinates are in grid coordinates.

Parameters:
X1 X-Coordinate for Starting position of the line.
Y1 Y-Coordinate for Starting position of the line.
Z1 Z-Coordinate for Starting position of the line.
X2 X-Coordinate for ending position of the line.
Y2 Y-Coordinate for ending position of the line.
Z2 Z-Coordinate for ending position of the line.
Returns:
If successfully created then the return value is a valid ID that you may use to further set attributes for this geometry. Otherwise, TECUTILBADID is returned.
Fortran Syntax:
    SUBROUTINE TecUtilGeom3DLineSegmentCreate(
   &           X1,
   &           Y1,
   &           Z1,
   &           X2,
   &           Y2,
   &           Z2,
   &           ResultPtr)
    REAL*8         X1
    REAL*8         Y1
    REAL*8         Z1
    REAL*8         X2
    REAL*8         Y2
    REAL*8         Z2
    POINTER        (ResultPtr, Result)

Python Syntax:

  Results = TecUtil.Geom3DLineSegmentCreate(X1, Y1, Z1, X2, Y2, Z2)

  Input:
                  X1                   double
                  Y1                   double
                  Z1                   double
                  X2                   double
                  Y2                   double
                  Z2                   double
  Output:
    Results[0]    ReturnVal            long

Create a 3-D line geometry from (0.1, 0.2, 0.2) to (0.5, 0.6, 0.1):

   Geom_ID G;
   G = TecUtilGeom3DLineSegmentCreate(.1,.2,.2,.5,.6,.1);

Geom_ID TecUtilGeom3DMPolyCreate ( LgIndex_t  NumPolys,
LgIndex_t *  NumPointsInPolylines_Array 
)

Create a 3-D multi-polyline geometry.

After creating the 3-D multi-polyline, you must assign values to the points in it with either TecUtilGeom3DMPolySetPoint() or TecUtilGeom3DMPolySetPolyline(). Use the ID obtained from this function to set geometry attributes such as line style and color using the TecUtilGeomSetXxx functions.

Parameters:
NumPolys Number of polylines in the 3-D multi-polyline. Must be greater than zero.
NumPointsInPolylines_Array Array of points in each polyline. Each polyline must have at least two points.
Returns:
The geometry ID of the 3-D multi-polyline.
Fortran Syntax:
    SUBROUTINE TecUtilGeom3DMPolyCreate(
   &           NumPolys,
   &           NumPointsInPolylines_Array,
   &           ResultPtr)
    INTEGER*4      NumPolys
    INTEGER*4      NumPointsInPolylines_Array
    POINTER        (ResultPtr, Result)

Python Syntax:

  Results = TecUtil.Geom3DMPolyCreate(NumPolys, NumPointsInPolylines_Array)

  Input:
                  NumPolys             int
                  NumPointsInPolylines_Array list of ints
  Output:
    Results[0]    ReturnVal            long

Create a 3-D multi-polyline with 2 polylines. The first polyline has three points, the second has two:

   LgIndex_t pts_per_line[2] = { 3, 2 }; // two polylines
   double x_polyline_1[] = { 0.0, 1.0, 2.0 }; // three points
   double y_polyline_1[] = { 0.0, 1.0, 0.0 };
   double z_polyline_1[] = { 0.0, 0.5, 0.0 };
   double x_polyline_2[] = { 1.0, 2.0 }; // two points
   double y_polyline_2[] = { 1.0, 0.0 };
   double z_polyline_2[] = { 0.5, 0.5 };
   Geom_ID g;

   g = TecUtilGeom3DMPolyCreate(2, pts_per_line);
   TecUtilGeom3DMPolySetPolyline(g, 1, x_polyline_1,
                                 y_polyline_1, z_polyline_1);
   TecUtilGeom3DMPolySetPolyline(g, 2, x_polyline_2,
                                 y_polyline_2, z_polyline_2);

void TecUtilGeom3DMPolyGetPoint ( Geom_ID  GID,
LgIndex_t  PolyNum,
LgIndex_t  PointIndex,
double *  X,
double *  Y,
double *  Z 
)

Get the 3-D (X, Y, Z) value of point in a 3-D multi-polyline geometry.

Parameters:
GID Geometry ID. This must be a 3-D multi-polyline geometry
PolyNum Polyline number. Must be greater than or equal to one and less than or equal to the number of polylines in the geometry
PointIndex Index of the point in the polyline. Must be greater than or equal to one and less than or equal to the number of points in the polyline
X Receives the X-value of the point. Must not be NULL.
Y Receives the Y-value of the point. Must not be NULL
Z Receives the Z-value of the point. Must not be NULL
Precondition:
X Pointer must be a valid address and non-NULL.

Y Pointer must be a valid address and non-NULL.

Z Pointer must be a valid address and non-NULL.

GID must be a valid geometry ID.

Fortran Syntax:
    SUBROUTINE TecUtilGeom3DMPolyGetPoint(
   &           GIDPtr,
   &           PolyNum,
   &           PointIndex,
   &           X,
   &           Y,
   &           Z)
    POINTER         (GIDPtr, GID)
    INTEGER*4       PolyNum
    INTEGER*4       PointIndex
    REAL*8          X
    REAL*8          Y
    REAL*8          Z

Python Syntax:

  Results = TecUtil.Geom3DMPolyGetPoint(GID, PolyNum, PointIndex)

  Input:
                  GID                  long
                  PolyNum              int
                  PointIndex           int
  Output:
    Results[0]    X                    double
    Results[1]    Y                    double
    Results[2]    Z                    double

Get the value of the tenth point in the second 3-D polyline of a multi-polyline geometry:

   double X,Y,Z;
   extern Geom_ID g; // assume this was allocated somewhere
   TecUtilGeom3DMPolyGetPoint(g,2,10,&X,&Y,&Z);

void TecUtilGeom3DMPolySetPoint ( Geom_ID  GID,
LgIndex_t  PolyNum,
LgIndex_t  PointIndex,
double  X,
double  Y,
double  Z 
)

Set the 3-D (X, Y, Z) value of point in a 3-D multi-polyline geometry.

Parameters:
GID Geometry ID. This must be a 3-D multi-polyline geometry
PolyNum Polyline number. Must be greater than or equal to one and less than or equal to the number of polylines in the geometry
PointIndex Index of the point in the polyline. Must be greater than or equal to one and less than or equal to the number of points in the polyline
X New X-value of the point
Y New Y-value of the point
Z New Z-value of the point
Precondition:
GID must be a valid geometry ID.
Fortran Syntax:
    SUBROUTINE TecUtilGeom3DMPolySetPoint(
   &           GIDPtr,
   &           PolyNum,
   &           PointIndex,
   &           X,
   &           Y,
   &           Z)
    POINTER         (GIDPtr, GID)
    INTEGER*4       PolyNum
    INTEGER*4       PointIndex
    REAL*8          X
    REAL*8          Y
    REAL*8          Z

Python Syntax:

  Results = TecUtil.Geom3DMPolySetPoint(GID, PolyNum, PointIndex, X, Y, Z)

  Input:
                  GID                  long
                  PolyNum              int
                  PointIndex           int
                  X                    double
                  Y                    double
                  Z                    double
  Output:
    Results[0]    ReturnVal            NONE

Set the value of the tenth point in the second polyline of a 3-D multi-polyline geometry:

   extern Geom_ID g; // assume this was allocated somewhere
   // set to (2.3,5.4,1.1)
   TecUtilGeom3DMPolySetPoint(g,2,10,2.3,5.4,1.1);

void TecUtilGeom3DMPolySetPolyline ( Geom_ID  GID,
LgIndex_t  PolyNum,
double *  X_Array,
double *  Y_Array,
double *  Z_Array 
)

Set the points for a polyline in a 3-D multi-polyline geometry.

Parameters:
GID Geometry ID. This must be a 3-D multi-polyline geometry
PolyNum Polyline number. Must be greater than or equal to one and less than or equal to the number of polylines in the geometry
X_Array Array of X-values. The number of X-values must be equal to the number of points in the polyline specified by PolyNum. Must not be NULL
Y_Array Array of Y-values. The number of Y-values must be equal to the number of points in the polyline specified by PolyNum. Must not be NULL
Z_Array Array of Z-values. The number of Z-values must be equal to the number of points in the polyline specified by PolyNum. Must not be NULL
Precondition:
VALID_REF(X) Pointer must be a valid address and non-NULL.

VALID_REF(Y) Pointer must be a valid address and non-NULL.

VALID_REF(Z) Pointer must be a valid address and non-NULL.

GID must be a valid geometry ID.

Fortran Syntax:
    SUBROUTINE TecUtilGeom3DMPolySetPolyline(
   &           GIDPtr,
   &           PolyNum,
   &           X_Array,
   &           Y_Array,
   &           Z_Array)
    POINTER         (GIDPtr, GID)
    INTEGER*4       PolyNum
    REAL*8          X_Array
    REAL*8          Y_Array
    REAL*8          Z_Array

Python Syntax:

  Results = TecUtil.Geom3DMPolySetPolyline(GID, PolyNum, X_Array, Y_Array, Z_Array)

  Input:
                  GID                  long
                  PolyNum              int
                  X_Array              list of doubles
                  Y_Array              list of doubles
                  Z_Array              list of doubles
  Output:
    Results[0]    ReturnVal            NONE

Geom_ID TecUtilGeom3DPolylineCreate ( double *  PtsX_Array,
double *  PtsY_Array,
double *  PtsZ_Array,
LgIndex_t  NumPts 
)

Create a 3-D polyline geometry.

Use the ID obtained from this function to set geometry attributes such as line style and color using the TecUtilGeomSetXxx function. By default, the anchor position is set to (0,0). All points are drawn relative to the anchor position. The anchor position can be changed using TecUtilGeomSetXYZAnchorPos(). All units are in grid coordinates.

Parameters:
PtsX_Array Array of X-coordinates of the polyline.
PtsY_Array Array of Y-coordinates of the polyline.
PtsZ_Array Array of Z-coordinates of the polyline.
NumPts Number of points in the array (that is, number of points in the polyline). Must be at least two points
Returns:
If successfully created then the return value is a valid ID that you may use to further set attributes for this geometry. Otherwise, TECUTILBADID is returned.
Precondition:
VALID_REF(PtsX) Pointer must be a valid address and non-NULL.

VALID_REF(PtsY) Pointer must be a valid address and non-NULL.

VALID_REF(PtsZ) Pointer must be a valid address and non-NULL.

Fortran Syntax:
    SUBROUTINE TecUtilGeom3DPolylineCreate(
   &           PtsX_Array,
   &           PtsY_Array,
   &           PtsZ_Array,
   &           NumPts,
   &           ResultPtr)
    REAL*8         PtsX_Array
    REAL*8         PtsY_Array
    REAL*8         PtsZ_Array
    INTEGER*4      NumPts
    POINTER        (ResultPtr, Result)

Python Syntax:

  Results = TecUtil.Geom3DPolylineCreate(PtsX_Array, PtsY_Array, PtsZ_Array, NumPts)

  Input:
                  PtsX_Array           list of doubles
                  PtsY_Array           list of doubles
                  PtsZ_Array           list of doubles
                  NumPts               int
  Output:
    Results[0]    ReturnVal            long

Create a 3-D polyline with four points:

   double X[4] = {.2,.5,.6,.4}; //x coords of the polyline
   double Y[4] = {.2,.5,.1,.7}; //y coords of the polyline
   double Z[4] = {.1,.2,.3,.4}; //z coords of the polyline
   Geom_ID G;
   G = TecUtilGeom3DPolylineCreate(X,Y,Z,4)

void TecUtilGeom3DPolylineGetPoint ( Geom_ID  GID,
LgIndex_t  PointIndex,
double *  X,
double *  Y,
double *  Z 
)

Get a point (X, Y, Z) of a 3-D polyline

Parameters:
GID Geometry ID. This must be a 3-D multi-polyline geometry
PointIndex Index of the point to get. Must be greater than or equal to one and less than or equal to the number of points in the polyline.
X Receives the X-value of the point. Must not be NULL
Y Receives the Y-value of the point. Must not be NULL
Z Receives the Z-value of the point. Must not be NULL
Precondition:
X Pointer must be a valid address and non-NULL.

Y Pointer must be a valid address and non-NULL.

Z Pointer must be a valid address and non-NULL.

GID must be a valid geometry ID.

Fortran Syntax:
    SUBROUTINE TecUtilGeom3DPolylineGetPoint(
   &           GIDPtr,
   &           PointIndex,
   &           X,
   &           Y,
   &           Z)
    POINTER         (GIDPtr, GID)
    INTEGER*4       PointIndex
    REAL*8          X
    REAL*8          Y
    REAL*8          Z

Python Syntax:

  Results = TecUtil.Geom3DPolylineGetPoint(GID, PointIndex)

  Input:
                  GID                  long
                  PointIndex           int
  Output:
    Results[0]    X                    double
    Results[1]    Y                    double
    Results[2]    Z                    double

Get the second point of a 3-D polyline geometry:

   double X,Y,Z;
   extern Geom_ID g; // allocated somewhere else
   TecUtilGeom3DPolylineGetPoint(g,2,&X,&Y,&Z);

void TecUtilGeom3DPolylineSetPoint ( Geom_ID  GID,
LgIndex_t  PointIndex,
double  X,
double  Y,
double  Z 
)

Set a point (X, Y, Z) of a 3-D polyline.

Parameters:
GID Geometry ID. This must be a 3-D multi-polyline geometry
PointIndex Index of the point to set. Must be greater than or equal to one and less than or equal to the number of points in the polyline.
X The new X-value of the point
Y The new Y-value of the point
Z The new Z-value of the point
Precondition:
GID must be a valid geometry ID.
Fortran Syntax:
    SUBROUTINE TecUtilGeom3DPolylineSetPoint(
   &           GIDPtr,
   &           PointIndex,
   &           X,
   &           Y,
   &           Z)
    POINTER         (GIDPtr, GID)
    INTEGER*4       PointIndex
    REAL*8          X
    REAL*8          Y
    REAL*8          Z

Python Syntax:

  Results = TecUtil.Geom3DPolylineSetPoint(GID, PointIndex, X, Y, Z)

  Input:
                  GID                  long
                  PointIndex           int
                  X                    double
                  Y                    double
                  Z                    double
  Output:
    Results[0]    ReturnVal            NONE

Set the second point of a 3-D polyline geometry:

   extern Geom_ID g; // allocated somewhere else
   TecUtilGeom3DPolylineSetPoint(g,2,1.1,2.5,1.0);
   // set to (1.1,2.5,1.0)

Geom_ID TecUtilGeomArcCreate ( CoordSys_e  PositionCoordSys,
double  CenterX,
double  CenterY,
double  Radius,
double  StartAngle,
double  EndAngle 
)

Create a 2-D arc.

The arc is currently implemented as a 2-D polyline geometry, thus, the type of object returned is a 2-D polyline geometry object. Use the ID obtained from this function to set geometry attributes such as line style and color using the TecUtilGeomSetXxx functions.

Parameters:
PositionCoordSys Coordinate system used to position the geometry. Valid values are CoordSys_Grid or CoordSys_Frame.
CenterX X-Coordinate for the Center of the arc.
CenterY Y-Coordinate for the Center of the arc.
Radius Radius of the arc. Must be greater than zero
StartAngle Starting angle of the arc in degrees. Must be between zero and 360. (The 2-D polyline that is created has on segment per degree of arc.)
EndAngle Ending angle of the arc in degrees.
Returns:
If successfully created then the return value is a valid ID that you may use to further set attributes for this geometry. Otherwise, TECUTILBADID is returned.
Fortran Syntax:
    SUBROUTINE TecUtilGeomArcCreate(
   &           PositionCoordSys,
   &           CenterX,
   &           CenterY,
   &           Radius,
   &           StartAngle,
   &           EndAngle,
   &           ResultPtr)
    INTEGER*4      PositionCoordSys
    REAL*8         CenterX
    REAL*8         CenterY
    REAL*8         Radius
    REAL*8         StartAngle
    REAL*8         EndAngle
    POINTER        (ResultPtr, Result)

Python Syntax:

  Results = TecUtil.GeomArcCreate(PositionCoordSys, CenterX, CenterY, Radius, StartAngle, EndAngle)

  Input:
                  PositionCoordSys     CoordSys_e  (defined in TecVals.py)
                  CenterX              double
                  CenterY              double
                  Radius               double
                  StartAngle           double
                  EndAngle             double
  Output:
    Results[0]    ReturnVal            long

Create an arc of a circle of radius 0.5 centered at (0, 0) with an arc angle from 35 to 90 degrees (a 2-D polyline with 56 points, one point at each degree between 35 and 90):

   Geom_ID G;
   G = TecUtilGeomArcCreate(CoordSys_Grid, .3,.3,.5,35,90);

double TecUtilGeomArrowheadGetAngle ( Geom_ID  GID  ) 

Get the geometry arrowhead angle.

Parameters:
GID ID of the geometry. This must be a polyline or a multi-polyline geometry
Returns:
The arrowhead angle in degrees.
Precondition:
GID must be a valid geometry ID.
Fortran Syntax:
    REAL*8 FUNCTION TecUtilGeomArrowheadGetAngle(GIDPtr)
    POINTER(GIDPtr, GID)

Python Syntax:

  Results = TecUtil.GeomArrowheadGetAngle(GID)

  Input:
                  GID                  long
  Output:
    Results[0]    ReturnVal            double

ArrowheadAttachment_e TecUtilGeomArrowheadGetAttach ( Geom_ID  GID  ) 

Get the geometry arrowhead attachment.

Parameters:
GID ID of the geometry. This must be a polyline or a multi-polyline geometry
Returns:
The arrowhead attachment. The possible values are: ArrowheadAttachment_None, ArrowheadAttachment_AtBeginning, ArrowheadAttachment_AtEnd, ArrowheadAttachment_AtBothEnds.
Precondition:
GID must be a valid geometry ID.
Fortran Syntax:
    INTEGER*4 FUNCTION TecUtilGeomArrowheadGetAttach(GIDPtr)
    POINTER(GIDPtr, GID)

Python Syntax:

  Results = TecUtil.GeomArrowheadGetAttach(GID)

  Input:
                  GID                  long
  Output:
    Results[0]    ReturnVal            ArrowheadAttachment_e  (defined in TecVals.py)

double TecUtilGeomArrowheadGetSize ( Geom_ID  GID  ) 

Get the geometry arrowhead size.

Parameters:
GID ID of the geometry. This must be a polyline or a multi-polyline geometry
Returns:
The arrowhead size in frame units.
Precondition:
GID must be a valid geometry ID.
Fortran Syntax:
    REAL*8 FUNCTION TecUtilGeomArrowheadGetSize(GIDPtr)
    POINTER(GIDPtr, GID)

Python Syntax:

  Results = TecUtil.GeomArrowheadGetSize(GID)

  Input:
                  GID                  long
  Output:
    Results[0]    ReturnVal            double

ArrowheadStyle_e TecUtilGeomArrowheadGetStyle ( Geom_ID  GID  ) 

Get the geometry arrowhead style.

Parameters:
GID ID of the geometry. This must be a polyline or a multi-polyline geometry
Returns:
The arrowhead style. The possible values are: ArrowheadStyle_Plain, ArrowheadStyle_Filled or ArrowheadStyle_Hollow.
Precondition:
GID must be a valid geometry ID.
Fortran Syntax:
    INTEGER*4 FUNCTION TecUtilGeomArrowheadGetStyle(GIDPtr)
    POINTER(GIDPtr, GID)

Python Syntax:

  Results = TecUtil.GeomArrowheadGetStyle(GID)

  Input:
                  GID                  long
  Output:
    Results[0]    ReturnVal            ArrowheadStyle_e  (defined in TecVals.py)

void TecUtilGeomArrowheadSetAngle ( Geom_ID  GID,
double  ArrowheadAngle 
)

Set the arrowhead angle for a geometry.

Parameters:
GID ID of the geometry. This must be a polyline or a multi-polyline geometry
ArrowheadAngle Angle for the arrowhead measured in degrees
Precondition:
GID must be a valid geometry ID.
Fortran Syntax:
    SUBROUTINE TecUtilGeomArrowheadSetAngle(
   &           GIDPtr,
   &           ArrowheadAngle)
    POINTER         (GIDPtr, GID)
    REAL*8          ArrowheadAngle

Python Syntax:

  Results = TecUtil.GeomArrowheadSetAngle(GID, ArrowheadAngle)

  Input:
                  GID                  long
                  ArrowheadAngle       double
  Output:
    Results[0]    ReturnVal            NONE

Create a line with a 15 degree arrowhead at the end:

   Geom_ID g;
   g = TecUtilGeom2DLineSegmentCreate(CoordSys_Frame, 5., 5., 95., 95.);
   TecUtilGeomArrowheadSetAttach(g, ArrowheadAttachment_AtEnd);
   TecUtilGeomArrowheadSetAngle(g, 15.);

void TecUtilGeomArrowheadSetAttach ( Geom_ID  GID,
ArrowheadAttachment_e  ArrowheadAttachment 
)

Set the arrowhead attachment for a geometry.

Parameters:
GID ID of the geometry. This must be a polyline or a multi-polyline geometry
ArrowheadAttachment The arrowhead attachment style. The possible values are: ArrowheadAttachment_None ArrowheadAttachment_AtBeginning ArrowheadAttachment_AtEnd ArrowheadAttachment_AtBothEnds
Precondition:
GID must be a valid geometry ID.
Fortran Syntax:
    SUBROUTINE TecUtilGeomArrowheadSetAttach(
   &           GIDPtr,
   &           ArrowheadAttachment)
    POINTER         (GIDPtr, GID)
    INTEGER*4       ArrowheadAttachment

Python Syntax:

  Results = TecUtil.GeomArrowheadSetAttach(GID, ArrowheadAttachment)

  Input:
                  GID                  long
                  ArrowheadAttachment  ArrowheadAttachment_e  (defined in TecVals.py)
  Output:
    Results[0]    ReturnVal            NONE

Create a line with arrowheads at both ends:

   Geom_ID g;
   g = TecUtilGeom2DLineSegmentCreate(CoordSys_Frame, 5., 5., 95., 95.);
   TecUtilGeomArrowheadSetAttach(g, ArrowheadAttachment_AtBothEnds);

void TecUtilGeomArrowheadSetSize ( Geom_ID  GID,
double  ArrowheadSize 
)

Set the arrowhead size for a geometry.

Parameters:
GID ID of the geometry. This must be a polyline or a multi-polyline geometry
ArrowheadSize The arrowhead size in frame units
Precondition:
GID must be a valid geometry ID.
Fortran Syntax:
    SUBROUTINE TecUtilGeomArrowheadSetSize(
   &           GIDPtr,
   &           ArrowheadSize)
    POINTER         (GIDPtr, GID)
    REAL*8          ArrowheadSize

Python Syntax:

  Results = TecUtil.GeomArrowheadSetSize(GID, ArrowheadSize)

  Input:
                  GID                  long
                  ArrowheadSize        double
  Output:
    Results[0]    ReturnVal            NONE

Create a line with a ten percent (frame units) arrowhead at the end:

   Geom_ID g;
   g = TecUtilGeom2DLineSegmentCreate(CoordSys_Frame, 5., 5., 95., 95.);
   TecUtilGeomArrowheadSetAttach(g, ArrowheadAttachment_AtEnd);
   TecUtilGeomArrowheadSetSize(g, 10.);

void TecUtilGeomArrowheadSetStyle ( Geom_ID  GID,
ArrowheadStyle_e  ArrowheadStyle 
)

Set the arrowhead style for a geometry.

Parameters:
GID ID of the geometry. This must be a polyline or a multi-polyline geometry
ArrowheadStyle The arrowhead style. The possible values are: ArrowheadStyle_Plain, ArrowheadStyle_Filled or ArrowheadStyle_Hollow.
Precondition:
GID must be a valid geometry ID.
Fortran Syntax:
    SUBROUTINE TecUtilGeomArrowheadSetStyle(
   &           GIDPtr,
   &           ArrowheadStyle)
    POINTER         (GIDPtr, GID)
    INTEGER*4       ArrowheadStyle

Python Syntax:

  Results = TecUtil.GeomArrowheadSetStyle(GID, ArrowheadStyle)

  Input:
                  GID                  long
                  ArrowheadStyle       ArrowheadStyle_e  (defined in TecVals.py)
  Output:
    Results[0]    ReturnVal            NONE

Create a line with a filled arrowhead at the end:

   Geom_ID g;
   g = TecUtilGeom2DLineSegmentCreate(CoordSys_Frame, 5., 5., 95., 95.);
   TecUtilGeomArrowheadSetAttach(g, ArrowheadAttachment_AtEnd);
   TecUtilGeomArrowheadSetStyle(g, ArrowheadStyle_Filled);

Geom_ID TecUtilGeomCircleCreate ( CoordSys_e  PositionCoordSys,
double  CenterX,
double  CenterY,
double  Radius 
)

Create a circle geometry.

Use the ID obtained from this function to set geometry attributes such as line style and color using the TecUtilGeomSetXxx functions. To set the number of points used to draw the circle use TecUtilGeomEllipseSetNumPoints().

Parameters:
PositionCoordSys Coordinate system used to position the geometry. The possible values are: CoordSys_Grid or CoordSys_Frame
CenterX X-Coordinate for the center of the circle.
CenterY Y-Coordinate for the center of the circle.
Radius Radius of the circle. Must be non-zero
Returns:
If successfully created then the return value is a valid ID that you may use to further set attributes for this geometry. Otherwise, TECUTILBADID is returned.
Fortran Syntax:
    SUBROUTINE TecUtilGeomCircleCreate(
   &           PositionCoordSys,
   &           CenterX,
   &           CenterY,
   &           Radius,
   &           ResultPtr)
    INTEGER*4      PositionCoordSys
    REAL*8         CenterX
    REAL*8         CenterY
    REAL*8         Radius
    POINTER        (ResultPtr, Result)

Python Syntax:

  Results = TecUtil.GeomCircleCreate(PositionCoordSys, CenterX, CenterY, Radius)

  Input:
                  PositionCoordSys     CoordSys_e  (defined in TecVals.py)
                  CenterX              double
                  CenterY              double
                  Radius               double
  Output:
    Results[0]    ReturnVal            long

Create a circle at 0.5, 0.5, with a radius of 0.2:

   Geom_ID G;
   G = TecUtilGeomCircleCreate(CoordSys_Grid,0.5,0.5,0.2);

double TecUtilGeomCircleGetRadius ( Geom_ID  GID  ) 

Return the radius of a circle geometry.

Parameters:
GID Geometry ID. This must be a circle geometry
Returns:
The radius of the circle.
Precondition:
GID must be a valid geometry ID.
Fortran Syntax:
    REAL*8 FUNCTION TecUtilGeomCircleGetRadius(GIDPtr)
    POINTER         (GIDPtr, GID)

Python Syntax:

  Results = TecUtil.GeomCircleGetRadius(GID)

  Input:
                  GID                  long
  Output:
    Results[0]    ReturnVal            double

void TecUtilGeomCircleSetRadius ( Geom_ID  GID,
double  Radius 
)

Set the radius of a circle geometry.

Parameters:
GID Geometry ID. This must be a circle geometry
Radius New radius of the circle. This must be non-zero
Precondition:
GID must be a valid geometry ID.
Fortran Syntax:
    SUBROUTINE TecUtilGeomCircleSetRadius(
   &           GIDPtr,
   &           Radius)
    POINTER         (GIDPtr, GID)
    REAL*8          Radius

Python Syntax:

  Results = TecUtil.GeomCircleSetRadius(GID, Radius)

  Input:
                  GID                  long
                  Radius               double
  Output:
    Results[0]    ReturnVal            NONE

Set the radius of a circle to one:

   extern Geom_id g; // must be a circle
   TecUtilGeomCircleSetRadius(g,1.0);

void TecUtilGeomDelete ( Geom_ID  GID  ) 

Deletes the specified geometry object.

Parameters:
GID Handle to a geometry object
Precondition:
GID must be a valid geometry ID.
Fortran Syntax:
    SUBROUTINE TecUtilGeomDelete(GIDPtr)
    POINTER(GIDPtr, GID)

Python Syntax:

  Results = TecUtil.GeomDelete(GID)

  Input:
                  GID                  long
  Output:
    Results[0]    ReturnVal            NONE

Delete the first geometry object from the list of geometry objects maintained by the current frame.

   Geom_ID Geom;
   Geom = TecUtilGeomGetBase();
   if (Geom != TECUTILBADID)
     {
       TecUtilGeomDelete(Geom);
     }

Geom_ID TecUtilGeomEllipseCreate ( CoordSys_e  PositionCoordSys,
double  CenterX,
double  CenterY,
double  HAxis,
double  VAxis 
)

Create an ellipse geometry.

Use the ID obtained from this function to set geometry attributes such as line style and color using the TecUtilGeomSetXxx functions.

Parameters:
PositionCoordSys Coordinate system used to position the geometry. Valid values are CoordSys_Grid or CoordSys_Frame
CenterX X-Coordinate for the center of the ellipse
CenterY Y-Coordinate for the center of the ellipse
HAxis Length of the horizontal axis. Must be non-zero
VAxis Length of the vertical Axis. Must be non-zero
Returns:
If successfully created then the return value is a valid ID that you may use to further set attributes for this geometry. Otherwise, TECUTILBADID is returned.
Fortran Syntax:
    SUBROUTINE TecUtilGeomEllipseCreate(
   &           PositionCoordSys,
   &           CenterX,
   &           CenterY,
   &           HAxis,
   &           VAxis,
   &           ResultPtr)
    INTEGER*4      PositionCoordSys
    REAL*8         CenterX
    REAL*8         CenterY
    REAL*8         HAxis
    REAL*8         VAxis
    POINTER        (ResultPtr, Result)

Python Syntax:

  Results = TecUtil.GeomEllipseCreate(PositionCoordSys, CenterX, CenterY, HAxis, VAxis)

  Input:
                  PositionCoordSys     CoordSys_e  (defined in TecVals.py)
                  CenterX              double
                  CenterY              double
                  HAxis                double
                  VAxis                double
  Output:
    Results[0]    ReturnVal            long

Create an ellipse centered at 0.5, 0.5, with a horizontal axis of length 0.2 and a vertical axis of length 0.3:

   Geom_ID G;
   G = TecUtilGeomEllipseCreate(CoordSys_Grid, .5,.5,.2,.3);

SmInteger_t TecUtilGeomEllipseGetNumPoints ( Geom_ID  GID  ) 

Get the number of points used to draw a circle or ellipse geometry.

Parameters:
GID ID of a geometry. This must be a circle or ellipse geometry
Returns:
The number of points used to draw the circle or geometry.
Precondition:
GID must be a valid geometry ID.
Fortran Syntax:
    INTEGER*4 FUNCTION TecUtilGeomEllipseGetNumPoints(GIDPtr)
    POINTER(GIDPtr, GID)

Python Syntax:

  Results = TecUtil.GeomEllipseGetNumPoints(GID)

  Input:
                  GID                  long
  Output:
    Results[0]    ReturnVal            int

void TecUtilGeomEllipseGetSize ( Geom_ID  GID,
double *  HAxis,
double *  VAxis 
)

Get length of the axes of an ellipse.

Parameters:
GID ID of a geometry. This must be an ellipse geometry
HAxis Receives the length of the horizontal axis. Must not be NULL
VAxis Receives the length of the vertical axis. Must not be NULL
Precondition:
HAxis Pointer must be a valid address and non-NULL.

VAxis Pointer must be a valid address and non-NULL.

GID must be a valid geometry ID.

Fortran Syntax:
    SUBROUTINE TecUtilGeomEllipseGetSize(
   &           GIDPtr,
   &           HAxis,
   &           VAxis)
    POINTER         (GIDPtr, GID)
    REAL*8          HAxis
    REAL*8          VAxis

Python Syntax:

  Results = TecUtil.GeomEllipseGetSize(GID)

  Input:
                  GID                  long
  Output:
    Results[0]    HAxis                double
    Results[1]    VAxis                double

Get the length of the axes of an ellipse:

   extern Geom_ID g; // must be an ellipse
   double A,B;
   TecUtilGeomEllipseGetSize(g,&A,&B);

void TecUtilGeomEllipseSetNumPoints ( Geom_ID  GID,
SmInteger_t  NumEllipsePts 
)

Set the number of points used to draw a circle or an ellipse geometry.

Parameters:
GID GID of a geometry. This must be a circle or ellipse geometry
NumEllipsePts The number of points use to draw the circle or ellipse. This must be at least three points
Precondition:
GID must be a valid geometry ID.
Fortran Syntax:
    SUBROUTINE TecUtilGeomEllipseSetNumPoints(
   &           GIDPtr,
   &           NumEllipsePts)
    POINTER         (GIDPtr, GID)
    INTEGER*4       NumEllipsePts

Python Syntax:

  Results = TecUtil.GeomEllipseSetNumPoints(GID, NumEllipsePts)

  Input:
                  GID                  long
                  NumEllipsePts        int
  Output:
    Results[0]    ReturnVal            NONE

Create a circle approximated by only five points. (This will look like a pentagon.)

   Geom_ID g;
   g = TecUtilGeomCircleCreate(CoordSys_Frame, 50., 50., 25.);
   TecUtilGeomEllipseSetNumPoints(g, 5);

void TecUtilGeomEllipseSetSize ( Geom_ID  GID,
double  HAxis,
double  VAxis 
)

Set the length of the axes of an ellipse.

Parameters:
GID Geometry ID. The must be an ellipse geometry
HAxis The length for the horizontal axis. This must be non-zero
VAxis The length for the vertical axis. This must be non-zero
Precondition:
GID must be a valid geometry ID.
Fortran Syntax:
    SUBROUTINE TecUtilGeomEllipseSetSize(
   &           GIDPtr,
   &           HAxis,
   &           VAxis)
    POINTER         (GIDPtr, GID)
    REAL*8          HAxis
    REAL*8          VAxis

Python Syntax:

  Results = TecUtil.GeomEllipseSetSize(GID, HAxis, VAxis)

  Input:
                  GID                  long
                  HAxis                double
                  VAxis                double
  Output:
    Results[0]    ReturnVal            NONE

Set the major and minor axes of an ellipse:

   extern Geom_ID g; // must be an ellipse
   TecUtilGeomEllipseGetSize(g,2.0,1.0);

void TecUtilGeomGetAnchorPos ( Geom_ID  GID,
double *  XOrThetaPos,
double *  YOrRPos,
double *  ZPos 
)

Gets the anchor postion of the specified geometry.

Parameters:
GID Geometry ID. The must be an ellipse geometry
XOrThetaPos The X or Theta axis position of the geometry anchor
YOrRPos The Y or Radian axis position of the geometry anchor
ZPos The Z axis position of the geometry anchor
Precondition:
XOrThetaPos Pointer must be a valid address and non-NULL.

YOrRPos Pointer must be a valid address and non-NULL.

ZPos Pointer must be a valid address and non-NULL.

GID must be a valid geometry ID.

Fortran Syntax:
    SUBROUTINE TecUtilGeomGetAnchorPos(
   &           GIDPtr,
   &           XOrThetaPos,
   &           YOrRPos,
   &           ZPos)
    POINTER         (GIDPtr, GID)
    REAL*8          XOrThetaPos
    REAL*8          YOrRPos
    REAL*8          ZPos

Python Syntax:

  Results = TecUtil.GeomGetAnchorPos(GID)

  Input:
                  GID                  long
  Output:
    Results[0]    XOrThetaPos          double
    Results[1]    YOrRPos              double
    Results[2]    ZPos                 double

Get the achor position of a newly created circle:

   double XPos, YPos, ZPos;

   Geom_ID Geom;
   Geom = TecUtilGeomCircleCreate(CoordSys_Grid,
     4.0, 3.0, 5.0);

   TecUtilGeomGetAnchorPos(Geom, &XPos, &YPos, &ZPos);

Geom_ID TecUtilGeomGetBase ( void   ) 

Get the base geometry attached to the current frame.

Returns:
Returns TECUTILBADID if the current frame does not have any attached geometries, otherwise, a valid geometry ID. Use TecUtilGeomGetNext() to get successive geometries.
Precondition:
Must have one or more frames.
Fortran Syntax:
    SUBROUTINE TecUtilGeomGetBase(ResultPtr)
    POINTER        (ResultPtr, Result)

Python Syntax:

  Results = TecUtil.GeomGetBase()

  Output:
    Results[0]    ReturnVal            long

Clipping_e TecUtilGeomGetClipping ( Geom_ID  GID  ) 

Function will get the clipping properties of a geometry.

Parameters:
GID ID of a geometry.
Precondition:
GID must be a valid geometry ID.
Fortran Syntax:
    INTEGER*4 FUNCTION TecUtilGeomGetClipping(GIDPtr)
    POINTER(GIDPtr, GID)

Python Syntax:

  Results = TecUtil.GeomGetClipping(GID)

  Input:
                  GID                  long
  Output:
    Results[0]    ReturnVal            Clipping_e  (defined in TecVals.py)

Create a red circle and set the clipping to "ClipToFrame":

   Geom_ID g;
   Clipping_e clip;
   g = TecUtilGeomCircleCreate(CoordSys_Frame, 50., 50., 25.);
   clip = TecUtilGeomGetClipping(g);

ColorIndex_t TecUtilGeomGetColor ( Geom_ID  GID  ) 

Get the geometry line color.

Parameters:
GID ID of a geometry.
Returns:
The line color of the geometry. The possible values are: Black_C, Blue_C, Red_C, Green_C, Cyan_C, Purple_C, Yellow_C, White_C, or CustomXX_C where XX ranges from 1 to 64.
Precondition:
GID must be a valid geometry ID.
Fortran Syntax:
    INTEGER*4 FUNCTION TecUtilGeomGetColor(GIDPtr)
    POINTER(GIDPtr, GID)

Python Syntax:

  Results = TecUtil.GeomGetColor(GID)

  Input:
                  GID                  long
  Output:
    Results[0]    ReturnVal            TecVals color constant

DrawOrder_e TecUtilGeomGetDrawOrder ( Geom_ID  GID  ) 

Gets the draw order of a geometry.

Parameters:
GID ID of a geometry.
Returns:
The draw order of the geometry. Returns either DrawOrder_BeforeData or DrawOrder_AfterData.
Precondition:
Must have one or more frames.

GID must be a valid geometry ID.

Fortran Syntax:
    INTEGER*4 FUNCTION TecUtilGeomGetDrawOrder(GIDPtr)
    POINTER (GIDPtr, GID)

Python Syntax:

  Results = TecUtil.GeomGetDrawOrder(GID)

  Input:
                  GID                  long
  Output:
    Results[0]    ReturnVal            DrawOrder_e  (defined in TecVals.py)

Get the draw order of a geometry:

   DrawOrder_e DrawOrder = TecUtilGeomGetDrawOrder(GID);

ColorIndex_t TecUtilGeomGetFillColor ( Geom_ID  GID  ) 

Get the geometry fill color.

Use TecUtilGeomGetIsFilled() to determine whether or not the geometry is filled with a color.

Parameters:
GID ID of a geometry.
Returns:
The geometry fill color. The possible values are: Black_C, Blue_C, Red_C, Green_C, Cyan_C, Purple_C, Yellow_C, White_C, or CustomXX_C where XX ranges from 1 to 64.
Precondition:
GID must be a valid geometry ID.
Fortran Syntax:
    INTEGER*4 FUNCTION TecUtilGeomGetFillColor(GIDPtr)
    POINTER(GIDPtr, GID)

Python Syntax:

  Results = TecUtil.GeomGetFillColor(GID)

  Input:
                  GID                  long
  Output:
    Results[0]    ReturnVal            TecVals color constant

Boolean_t TecUtilGeomGetIsFilled ( Geom_ID  GID  ) 

Determine if a geometry if filled.

Parameters:
GID ID of a geometry.
Returns:
TRUE if the geometry is filled, otherwise FALSE.
Precondition:
GID must be a valid geometry ID.
Fortran Syntax:
    INTEGER*4 FUNCTION TecUtilGeomGetIsFilled(GIDPtr)
    POINTER(GIDPtr, GID)

Python Syntax:

  Results = TecUtil.GeomGetIsFilled(GID)

  Input:
                  GID                  long
  Output:
    Results[0]    ReturnVal            boolean

LinePattern_e TecUtilGeomGetLinePattern ( Geom_ID  GID  ) 

Get the line pattern of a geometry.

Parameters:
GID ID of a geometry. This must be a circle or ellipse geometry
Returns:
The geometry line pattern. The possible values are: LinePattern_Solid, LinePattern_Dashed, LinePattern_DashDot, LinePattern_Dotted, LinePattern_LongDash, LinePattern_DashDotDot.
Precondition:
GID must be a valid geometry ID.
Fortran Syntax:
    INTEGER*4 FUNCTION TecUtilGeomGetLinePattern(GIDPtr)
    POINTER(GIDPtr, GID)

Python Syntax:

  Results = TecUtil.GeomGetLinePattern(GID)

  Input:
                  GID                  long
  Output:
    Results[0]    ReturnVal            LinePattern_e  (defined in TecVals.py)

double TecUtilGeomGetLineThickness ( Geom_ID  GID  ) 

Get the geometry line thickness.

Parameters:
GID ID of a geometry.
Returns:
The geometry line thickness in frame units.
Precondition:
GID must be a valid geometry ID.
Fortran Syntax:
    REAL*8 FUNCTION TecUtilGeomGetLineThickness(GIDPtr)
    POINTER(GIDPtr, GID)

Python Syntax:

  Results = TecUtil.GeomGetLineThickness(GID)

  Input:
                  GID                  long
  Output:
    Results[0]    ReturnVal            double

Boolean_t TecUtilGeomGetMacroFunctionCmd ( Geom_ID  GID,
char **  MacroFunctionCmd 
)

Get the geometry macro function command.

Parameters:
GID ID of a geometry.
MacroFunctionCmd Character string containing the macro command. You must free this string using TecUtilStringDealloc() when you are done with it
Returns:
Returns TRUE if space can be allocated for the command string, otherwise FALSE.
Precondition:
MacroFunctionCmd Pointer must be a valid address and non-NULL.

GID must be a valid geometry ID.

Fortran Syntax:
    INTEGER*4 FUNCTION TecUtilGeomGetMacroFunctionCmd(
   &                   GIDPtr,
   &                   MacroFunctionCmd,
   &                   MacroFunctionCmdLength)
    POINTER         (GIDPtr, GID)
    CHARACTER*(*)   MacroFunctionCmd
    INTEGER*4       MacroFunctionCmdLength

Python Syntax:

  Results = TecUtil.GeomGetMacroFunctionCmd(GID)

  Input:
                  GID                  long
  Output:
    Results[0]    ReturnVal            boolean
    Results[1]    MacroFunctionCmd     string

Geom_ID TecUtilGeomGetNext ( Geom_ID  GID  ) 

Get the next geometry in the list of geometries attached to the current frame.

Parameters:
GID ID of a geometry.
Returns:
Returns the ID of the next geometry or TECUTILBADID if there are no more geometries.
Precondition:
GID must be a valid geometry ID.
Fortran Syntax:
    SUBROUTINE TecUtilGeomGetNext(
   &           GIDPtr,
   &           ResultPtr)
    POINTER        (GIDPtr, GID)
    POINTER        (ResultPtr, Result)

Python Syntax:

  Results = TecUtil.GeomGetNext(GID)

  Input:
                  GID                  long
  Output:
    Results[0]    ReturnVal            long

Change all geometries in the current frame to be red:

   Geom_ID g;
   g = TecUtilGeomGetBase();
   while ( g != TECUTILBADID )
     {
       TecUtilGeomSetColor(g, Red_C);
       g = TecUtilGeomGetNext(g);
     }

double TecUtilGeomGetPatternLength ( Geom_ID  GID  ) 

Get the geometry line pattern length.

Parameters:
GID ID of a geometry.
Returns:
The line pattern length in frame units.
Precondition:
GID must be a valid geometry ID.
Fortran Syntax:
    REAL*8 FUNCTION TecUtilGeomGetPatternLength(GIDPtr)
    POINTER(GIDPtr, GID)

Python Syntax:

  Results = TecUtil.GeomGetPatternLength(GID)

  Input:
                  GID                  long
  Output:
    Results[0]    ReturnVal            double

CoordSys_e TecUtilGeomGetPositionCoordSys ( Geom_ID  GID  ) 

Get the geometry position coordinate system.

Parameters:
GID ID of a geometry.
Returns:
The coordinate system. The possible values are: CoordSys_Grid3D or CoordSys_Frame.
Precondition:
GID must be a valid geometry ID.
Fortran Syntax:
    INTEGER*4 FUNCTION TecUtilGeomGetPositionCoordSys(GIDPtr)
    POINTER(GIDPtr, GID)

Python Syntax:

  Results = TecUtil.GeomGetPositionCoordSys(GID)

  Input:
                  GID                  long
  Output:
    Results[0]    ReturnVal            CoordSys_e  (defined in TecVals.py)

Geom_ID TecUtilGeomGetPrev ( Geom_ID  GID  ) 

Get the previous geometry in the list of geometries attached to the current frame.

Parameters:
GID ID of a geometry.
Returns:
Returns the ID of the previous geometry or TECUTILBADID if GID was the base geometry.
Precondition:
GID must be a valid geometry ID.
Fortran Syntax:
    SUBROUTINE TecUtilGeomGetPrev(
   &           GIDPtr,
   &           ResultPtr)
    POINTER        (GIDPtr, GID)
    POINTER        (ResultPtr, Result)

Python Syntax:

  Results = TecUtil.GeomGetPrev(GID)

  Input:
                  GID                  long
  Output:
    Results[0]    ReturnVal            long

Create a circle with color of the previous circle:

   Geom_ID new_geom, prev_geom;
   new_geom = TecUtilGeomCircleCreate(CoordSys_Frame, 50., 50., 25.);
   prev_geom = TecUtilGeomGetPrev(new_geom);
   while ( prev_geom != TECUTILBADID &&
           TecUtilGeomGetType(prev_geom) != Geom_Circle )
     prev_geom = TecUtilGeomGetPrev(prev_geom);
   if ( prev_geom != TECUTILBADID )
     TecUtilGeomSetColor(new_geom,TecUtilGeomGetColor(prev_geom));

Scope_e TecUtilGeomGetScope ( Geom_ID  GID  ) 

Get the geometry scope.

Parameters:
GID ID of a geometry.
Returns:
The geometry scope. The possible values are: Scope_Local (show in current frame only), Scope_Global (show in all frames with the same data set as the current frame).
Precondition:
GID must be a valid geometry ID.
Fortran Syntax:
    INTEGER*4 FUNCTION TecUtilGeomGetScope(GIDPtr)
    POINTER(GIDPtr, GID)

Python Syntax:

  Results = TecUtil.GeomGetScope(GID)

  Input:
                  GID                  long
  Output:
    Results[0]    ReturnVal            Scope_e  (defined in TecVals.py)

GeomForm_e TecUtilGeomGetType ( Geom_ID  GID  ) 

Get the geometry type.

Parameters:
GID ID of a geometry.
Returns:
The geometry type. This can be one of: GeomType_LineSegs (includes 2-D and 3-D line, polyline and multi-polyline geometries), GeomType_Rectangle, GeomType_Square, GeomType_Circle, GeomType_Ellipse.
Precondition:
GID must be a valid geometry ID.
Fortran Syntax:
    INTEGER*4 FUNCTION TecUtilGeomGetType(GIDPtr)
    POINTER(GIDPtr, GID)

Python Syntax:

  Results = TecUtil.GeomGetType(GID)

  Input:
                  GID                  long
  Output:
    Results[0]    ReturnVal            GeomForm_e  (defined in TecVals.py)

void TecUtilGeomGetXYZAnchorPos ( Geom_ID  GID,
double *  XPos,
double *  YPos,
double *  ZPos 
)

Deprecated:
Please use TecUtilGeomGetAnchorPos() instead.

Python Syntax:

  Results = TecUtil.GeomGetXYZAnchorPos(GID)

  Input:
                  GID                  long
  Output:
    Results[0]    XPos                 double
    Results[1]    YPos                 double
    Results[2]    ZPos                 double

EntIndex_t TecUtilGeomGetZoneOrMap ( Geom_ID  GID  ) 

Get the zone or Line-mapping to which the geometry is attached.

Use TecUtilGeomIsAttached() to determine whether or not the geometry is attached at all.

Parameters:
GID ID of a geometry.
Returns:
The zone number or the Line-mapping number.
Precondition:
GID must be a valid geometry ID.
Fortran Syntax:
    INTEGER*4 FUNCTION TecUtilGeomGetZoneOrMap(GIDPtr)
    POINTER(GIDPtr, GID)

Python Syntax:

  Results = TecUtil.GeomGetZoneOrMap(GID)

  Input:
                  GID                  long
  Output:
    Results[0]    ReturnVal            int

See TecUtilGeomIsAttached() for an example of using TecUtilGeomGetZoneOrMap().

Geom_ID TecUtilGeomImageCreate ( const char *  FName,
double  CornerX,
double  CornerY,
double  Size 
)

Create an image geometry.

Use the ID obtained from this function to set geometry attributes such as position and coordinates system.

Parameters:
FName Image file to attach. The format of this file must be Microsoft Windows Bitmap (*.bmp), JPEG (*.jpg or *.jpeg) or Portable Network Graphics (*.png)
CornerX X coordinate for the location to initially place the image (frame coordinates).
CornerY Y coordinate for the location to initially place the image (frame coordinates).
Size The default size of the image. You may change the size later using TecUtilImageSetWidth() and TecUtilImageSetHeight().
Returns:
If successfully created, then the return is a valid ID that you may use to further set attributes for this geometry. Otherwise, TECUTILBADID is returned. If the return value is TECUTILBADID, then the most likely cause is the file does not exist.
Precondition:
FName String must have a valid address and non-zero length.
Fortran Syntax:
    SUBROUTINE TecUtilGeomImageCreate(
   &           FName,
   &           CornerX,
   &           CornerY,
   &           Size,
   &           ResultPtr)
    CHARACTER*(*)  FName
    REAL*8         CornerX
    REAL*8         CornerY
    REAL*8         Size
    POINTER        (ResultPtr, Result)

Python Syntax:

  Results = TecUtil.GeomImageCreate(FName, CornerX, CornerY, Size)

  Input:
                  FName                string
                  CornerX              double
                  CornerY              double
                  Size                 double
  Output:
    Results[0]    ReturnVal            long

Create an image geometry anchored at (0.1,0.1) with a size of 0.5, using the file "myimage.png":

   Geom_ID G;
   G = TecUtilGeomImageCreate("c:\\myimage.png",0.1,0.1,0.5);

void TecUtilGeomImageGetFileName ( Geom_ID  GID,
char **  FileName 
)

Get the name of the file associated with an image geometry.

Parameters:
GID Geometry ID. Must be an image geometry
FileName Receives the file name associated with this geometry. This is always an absolute path. You must call TecUtilStringDealloc() to free this string when you are done with it
Precondition:
FileName Pointer must be a valid address and non-NULL.

GID must be a valid geometry ID.

Fortran Syntax:
    SUBROUTINE TecUtilGeomImageGetFileName(
   &           GIDPtr,
   &           FileName,
   &           FileNameLength)
    POINTER         (GIDPtr, GID)
    CHARACTER*(*)   FileName
    INTEGER*4       FileNameLength

Python Syntax:

  Results = TecUtil.GeomImageGetFileName(GID)

  Input:
                  GID                  long
  Output:
    Results[0]    FileName             string

Get the name of the file associated with a geometry.

   char *GeomFileName = NULL;
   GTecUtilGeomImageGetFileName(G, &GeomFileName);

ImageResizeFilter_e TecUtilGeomImageGetResizeFilter ( Geom_ID  GID  ) 

Get the resize filter of an image geometry.

The resize filter determines the algorithm used when an image is resized.

Parameters:
GID Geometry ID. Must be an image geometry
Returns:
The resize filter of the indicated geometry. See ImageResizeFilter_e.
Precondition:
GID must be a valid geometry ID.
Fortran Syntax:
    INTEGER*4 FUNCTION TecUtilGeomImageGetResizeFilter(GIDPtr)
    POINTER(GIDPtr, GID)

Python Syntax:

  Results = TecUtil.GeomImageGetResizeFilter(GID)

  Input:
                  GID                  long
  Output:
    Results[0]    ReturnVal            ImageResizeFilter_e  (defined in TecVals.py)

Get the resize filter of a geometry.

   ImageResizeFilter_e Filter =
                       TecUtilGeomImageSetResizeFilter(G);

void TecUtilGeomImageGetSize ( Geom_ID  GID,
double *  Width,
double *  Height 
)

Get the width and height of an image geometry.

Parameters:
GID Geometry ID. Must be an image geometry
Width Receives the width of the specified image geometry.
Height Receives the height of the specified image geometry.
Precondition:
Width Pointer must be a valid address or NULL.

Height Pointer must be a valid address or NULL.

GID must be a valid geometry ID.

Fortran Syntax:
    SUBROUTINE TecUtilGeomImageGetSize(
   &           GIDPtr,
   &           Width,
   &           Height)
    POINTER         (GIDPtr, GID)
    REAL*8          Width
    REAL*8          Height

Python Syntax:

  Results = TecUtil.GeomImageGetSize(GID)

  Input:
                  GID                  long
  Output:
    Results[0]    Width                double
    Results[1]    Height               double

Get the width and height of an image in an image geometry.

   double Width;
   double Height;
   TecUtilGeomImageGetFileName(GID, &Width, &Height);

Boolean_t TecUtilGeomImageGetUseRatio ( Geom_ID  GID  ) 

Queries the state of the "preserve aspect ratio" toggle for an image geometry.

Parameters:
GID Geometry ID. Must be an image geometry
Returns:
Returns TRUE if the "preserve aspect ratio" toggle for an image geometry, FALSE otherwise.
Precondition:
GID must be a valid geometry ID.
Fortran Syntax:
    INTEGER*4 FUNCTION TecUtilGeomImageGetUseRatio(GIDPtr)
    POINTER (GIDPtr, GID)

Python Syntax:

  Results = TecUtil.GeomImageGetUseRatio(GID)

  Input:
                  GID                  long
  Output:
    Results[0]    ReturnVal            boolean

Get the state of the preserve aspect ration toggle in an image geometry:

   Boolean_t UsePreserveAspect = TecUtilGeomImageSetUseRatio(GID);

void TecUtilGeomImageResetAspectRatio ( Geom_ID  GID  ) 

Resets the aspect ratio after any changes have been made in the position of an image geometry.

Parameters:
GID Geometry ID. Must be an image geometry
Precondition:
Must have one or more frames.

GID must be a valid geometry ID.

Fortran Syntax:
    SUBROUTINE TecUtilGeomImageResetAspectRati(GIDPtr)
    POINTER(GIDPtr, GID)

Python Syntax:

  Results = TecUtil.GeomImageResetAspectRatio(GID)

  Input:
                  GID                  long
  Output:
    Results[0]    ReturnVal            NONE

Note:
IMPORTANT! Note that the FORTRAN Name for this function is truncated to 31 characters!
Reset the aspect ratio of an image geometry:

   TecUtilGeomImageResetAspectRatio(GID);

void TecUtilGeomImageSetHeight ( Geom_ID  GID,
double  Height 
)

Sets the Height of an image geometry.

Note that the size of a geometry when it is displayed in a frame is not necessarily the size of the image in the file. The image will be resized to fit the dimension specified when calling this function.

Parameters:
GID Geometry ID. Must be an image geometryGeometry ID. Must be an image geometry
Height New height of the image, must be greater than 0.0
Precondition:
GID must be a valid geometry ID.
Fortran Syntax:
    SUBROUTINE TecUtilGeomImageSetHeight(
   &           GIDPtr,
   &           Height)
    POINTER         (GIDPtr, GID)
    REAL*8          Height

Python Syntax:

  Results = TecUtil.GeomImageSetHeight(GID, Height)

  Input:
                  GID                  long
                  Height               double
  Output:
    Results[0]    ReturnVal            NONE

Set the height of an image geometry to 5.0:

   TecUtilGeomImageSetHeight(GID, 5.0);

void TecUtilGeomImageSetResizeFilter ( Geom_ID  GID,
ImageResizeFilter_e  ResizeFilter 
)

Sets the resize filter of an image geometry.

The resize filter determines the algorithm used when an image is resized.

Parameters:
GID Geometry ID. Must be an image geometry
ResizeFilter Resize filter. See ImageResizeFilter_e.
Precondition:
GID must be a valid geometry ID.
Fortran Syntax:
    SUBROUTINE TecUtilGeomImageSetResizeFilter(
   &           GIDPtr,
   &           ResizeFilter)
    POINTER         (GIDPtr, GID)
    INTEGER*4       ResizeFilter

Python Syntax:

  Results = TecUtil.GeomImageSetResizeFilter(GID, ResizeFilter)

  Input:
                  GID                  long
                  ResizeFilter         ImageResizeFilter_e  (defined in TecVals.py)
  Output:
    Results[0]    ReturnVal            NONE

Set the resize filter for an image geometry to Box:

   TecUtilGeomImageSetResizeFilter(G, ImageResizeFilter_Box);

void TecUtilGeomImageSetUseRatio ( Geom_ID  GID,
Boolean_t  MaintainAspectRatio 
)

Sets the state of the "preserve aspect ratio" toggle for an image geometry.

Parameters:
GID Geometry ID. Must be an image geometry
MaintainAspectRatio TRUE to preserve the aspect ratio when drawing an image geometry
Returns:
TRUE if the "preserve aspect ratio" toggle is set, FALSE otherwise.
Precondition:
Must have one or more frames.

GID must be a valid geometry ID.

Fortran Syntax:
    SUBROUTINE TecUtilGeomImageSetUseRatio(
   &           GIDPtr,
   &           MaintainAspectRatio)
    POINTER         (GIDPtr, GID)
    INTEGER*4       MaintainAspectRatio

Python Syntax:

  Results = TecUtil.GeomImageSetUseRatio(GID, MaintainAspectRatio)

  Input:
                  GID                  long
                  MaintainAspectRatio  boolean
  Output:
    Results[0]    ReturnVal            NONE

Set the state of the preserve aspect ration toggle in an image to TRUE:

   TecUtilGeomImageSetUseRatio(GID, TRUE);

void TecUtilGeomImageSetWidth ( Geom_ID  GID,
double  Width 
)

Sets the width of an image geometry.

Note that the size of a geometry when it is displayed in a frame is not necessarily the size of the image in the file. The image will be resized to fit the dimensions specified when calling this function.

Parameters:
GID Geometry ID. Must be an image geometry
Width New width of the geometry. Must be greater than 0.0
Precondition:
GID must be a valid geometry ID.
Fortran Syntax:
    SUBROUTINE TecUtilGeomImageSetWidth(
   &           GIDPtr,
   &           Width)
    POINTER         (GIDPtr, GID)
    REAL*8          Width

Python Syntax:

  Results = TecUtil.GeomImageSetWidth(GID, Width)

  Input:
                  GID                  long
                  Width                double
  Output:
    Results[0]    ReturnVal            NONE

Set the width of an image geometry to 5.0:

   TecUtilGeomImageSetWidth(GID, 5.0);

Boolean_t TecUtilGeomIsAttached ( Geom_ID  GID  ) 

Determine whether or not a geometry is attached to a zone or Line-mapping.

Use TecUtilGeomGetZoneOrMap() to get the zone or Line-mapping number to which the geometry is attached.

Parameters:
GID Geometry ID. Must be an image geometry
Returns:
TRUE if the geometry is attached to a zone or Line-mapping, otherwise FALSE.
Precondition:
GID must be a valid geometry ID.
Fortran Syntax:
    INTEGER*4 FUNCTION TecUtilGeomIsAttached(GIDPtr)
    POINTER(GIDPtr, GID)

Python Syntax:

  Results = TecUtil.GeomIsAttached(GID)

  Input:
                  GID                  long
  Output:
    Results[0]    ReturnVal            boolean

Determine the zone or Line-mapping that a geometry is attached to:

   extern Geom_ID g; // created elsewhere
   EntIndex_t zone = 0;
   EntIndex_t LineMap = 0;
   if ( TecUtilFrameGetMode() == Frame_XY )
      LineMap = TecUtilGeomGetZoneOrMap(g);
   else if ( TecUtilFrameGetMode() != Frame_Sketch )
      zone = TecUtilGeomGetZoneOrMap(g);

Boolean_t TecUtilGeomIsValid ( Geom_ID  GID  ) 

Validate a geometry ID.

Parameters:
GID Geometry ID.
Returns:
TRUE if GID is a valid geometry ID. FALSE if not.
Precondition:
Must have one or more frames.
Fortran Syntax:
    INTEGER*4 FUNCTION TecUtilGeomIsValid(GIDPtr)
    POINTER(GIDPtr, GID)

Python Syntax:

  Results = TecUtil.GeomIsValid(GID)

  Input:
                  GID                  long
  Output:
    Results[0]    ReturnVal            boolean

Determine if a geometry ID is still valid, and if it is valid, change its color to red:

   extern Geom_ID g; // created elsewhere
   if ( TecUtilGeomIsValid(g) )
      TecUtilGeomSetColor(g, Red_C);

LgIndex_t TecUtilGeomMPolyGetPointCount ( Geom_ID  GID,
LgIndex_t  PolyNum 
)

Get information about the number of points in a polyline of a multi-polyline geometry.

Parameters:
GID Geometry ID. Must be a multi-polyline geometry
PolyNum Polyline of the multi-polyline geometry (starts at one)
Returns:
The number of points in the polyline.
Precondition:
GID must be a valid geometry ID.
Fortran Syntax:
    INTEGER*4 FUNCTION TecUtilGeomMPolyGetPointCount(
   &                   GIDPtr,
   &                   PolyNum)
    POINTER         (GIDPtr, GID)
    INTEGER*4       PolyNum

Python Syntax:

  Results = TecUtil.GeomMPolyGetPointCount(GID, PolyNum)

  Input:
                  GID                  long
                  PolyNum              int
  Output:
    Results[0]    ReturnVal            int

To determine the number of points in the second polyline of a multi-polyline geometry:

   extern Geom_ID g; //created elsewhere, must be a multi-polyline geometry
   LgIndex_t npts_2nd_polyline = TecUtilGeomMPolyGetPointCount(g, 2);

LgIndex_t TecUtilGeomMPolyGetPolylineCnt ( Geom_ID  GID  ) 

Get the number of polylines in a multi-polyline geometry.

Parameters:
GID Geometry ID. Must be a multi-polyline geometry
Returns:
The number of polylines in a multi-polyline geometry.
Precondition:
GID must be a valid geometry ID.
Fortran Syntax:
    INTEGER*4 FUNCTION TecUtilGeomMPolyGetPolylineCnt(GIDPtr)
    POINTER (GIDPtr, GID)

Python Syntax:

  Results = TecUtil.GeomMPolyGetPolylineCnt(GID)

  Input:
                  GID                  long
  Output:
    Results[0]    ReturnVal            int

To determine the number of polylines in a multi-polyline geometry:

   extern Geom_ID g; //created elsewhere, must be a multi-polyline geometry
   LgIndex_t npolylines = TecUtilGeomMPolyGetPolylineCnt(g);

LgIndex_t TecUtilGeomPolyGetPointCount ( Geom_ID  GID  ) 

Get the number of points in a polyline geometry.

Parameters:
GID Geometry ID. Must be a multi-polyline geometry
Returns:
The number of points in a polyline geometry.
Precondition:
GID must be a valid geometry ID.
Fortran Syntax:
    INTEGER*4 FUNCTION TecUtilGeomPolyGetPointCount(GIDPtr)
    POINTER (GIDPtr, GID)

Python Syntax:

  Results = TecUtil.GeomPolyGetPointCount(GID)

  Input:
                  GID                  long
  Output:
    Results[0]    ReturnVal            int

Geom_ID TecUtilGeomRectangleCreate ( CoordSys_e  PositionCoordSys,
double  CornerX,
double  CornerY,
double  Width,
double  Height 
)

Create a rectangle geometry.

Use the ID obtained from this function to set geometry attributes such as line style and color using the TecUtilGeomSetXxx functions.

Parameters:
PositionCoordSys Coordinate system used to position the geometry. The possible values are: CoordSys_Grid or CoordSys_Frame
CornerX X-Coordinate for rectangle anchor position (left side of the rectangle).
CornerY Y-Coordinate for rectangle anchor position (top of the rectangle).
Width Width the rectangle. Must be non-zero.
Height Height of the rectangle. Must be non-zero.
Returns:
If successfully created then the return value is a valid ID that you may use to further set attributes for this geometry. Otherwise, TECUTILBADID is returned.
Fortran Syntax:
    SUBROUTINE TecUtilGeomRectangleCreate(
   &           PositionCoordSys,
   &           CornerX,
   &           CornerY,
   &           Width,
   &           Height,
   &           ResultPtr)
    INTEGER*4      PositionCoordSys
    REAL*8         CornerX
    REAL*8         CornerY
    REAL*8         Width
    REAL*8         Height
    POINTER        (ResultPtr, Result)

Python Syntax:

  Results = TecUtil.GeomRectangleCreate(PositionCoordSys, CornerX, CornerY, Width, Height)

  Input:
                  PositionCoordSys     CoordSys_e  (defined in TecVals.py)
                  CornerX              double
                  CornerY              double
                  Width                double
                  Height               double
  Output:
    Results[0]    ReturnVal            long

Create a rectangle anchored at (0.1, 0.1), with a width of 0.2 and a height of 0.3:

   Geom_ID G;
   G = TecUtilGeomRectangleCreate(.1,.1,0.2,0.3);

void TecUtilGeomRectangleGetSize ( Geom_ID  GID,
double *  Width,
double *  Height 
)

Get the width and height of a rectangle geometry.

Parameters:
GID Geometry ID. Must be a rectangle geometry
Width Receives the width of the rectangle. Must not be NULL
Height Receives the height of the rectangle. Must not be NULL
Precondition:
Width Pointer must be a valid address or NULL.

Height Pointer must be a valid address or NULL.

GID must be a valid geometry ID.

Fortran Syntax:
    SUBROUTINE TecUtilGeomRectangleGetSize(
   &           GIDPtr,
   &           Width,
   &           Height)
    POINTER         (GIDPtr, GID)
    REAL*8          Width
    REAL*8          Height

Python Syntax:

  Results = TecUtil.GeomRectangleGetSize(GID)

  Input:
                  GID                  long
  Output:
    Results[0]    Width                double
    Results[1]    Height               double

Get the width and height of a rectangle:

   double W,H;
   extern Geom_ID g; // must be a rectangle
   TecUtilGeomRectangleGetSize(g,&W,&H);

void TecUtilGeomRectangleSetSize ( Geom_ID  GID,
double  Width,
double  Height 
)

Set the width and height of a rectangle geometry.

Parameters:
GID Geometry ID. Must be a rectangle geometry
Width New width of the rectangle. Must be non-zero
Height New height of the rectangle. Must be non-zero
Precondition:
GID must be a valid geometry ID.
Fortran Syntax:
    SUBROUTINE TecUtilGeomRectangleSetSize(
   &           GIDPtr,
   &           Width,
   &           Height)
    POINTER         (GIDPtr, GID)
    REAL*8          Width
    REAL*8          Height

Python Syntax:

  Results = TecUtil.GeomRectangleSetSize(GID, Width, Height)

  Input:
                  GID                  long
                  Width                double
                  Height               double
  Output:
    Results[0]    ReturnVal            NONE

Set the width and height of a rectangle:

   extern Geom_ID g; // must be a rectangle
   TecUtilGeomRectangleSetSize(g,4,1);

void TecUtilGeomSetAnchorPos ( Geom_ID  GID,
double  XPos,
double  YPos,
double  ZPos 
)

Set the anchor position for a geometry.

For circles and ellipses, this is the center. For squares and rectangles, this is the base corner. For lines, this is the offset added to all points of the geometry.

Parameters:
GID ID of a geometry
XPos X-anchor position of geometry
YPos Y-anchor position of geometry
ZPos Z-anchor position of geometry (3-D geometries only)
Precondition:
GID must be a valid geometry ID.
Fortran Syntax:
    SUBROUTINE TecUtilGeomSetAnchorPos(
   &           GIDPtr,
   &           XPos,
   &           YPos,
   &           ZPos)
    POINTER         (GIDPtr, GID)
    REAL*8          XPos
    REAL*8          YPos
    REAL*8          ZPos

Python Syntax:

  Results = TecUtil.GeomSetAnchorPos(GID, XPos, YPos, ZPos)

  Input:
                  GID                  long
                  XPos                 double
                  YPos                 double
                  ZPos                 double
  Output:
    Results[0]    ReturnVal            NONE

Create a circle and then move it:

   Geom_ID g;
   g = TecUtilGeomCircleCreate(CoordSys_Frame, 50., 50., 25.);
   TecUtilRedraw();
   TecUtilGeomSetAnchorPos(45., 45., 0.);
   TecUtilRedraw();

void TecUtilGeomSetAttached ( Geom_ID  GID,
Boolean_t  Attached 
)

Set whether or not a geometry is attached to a zone or Line-mapping.

Use TecUtilGeom() to set which zone or Line-mapping the geometry is attached to.

Parameters:
GID Id of the geometry.
Attached TRUE to attach the geometry to a zone or an Line-mapping.
Precondition:
GID must be a valid geometry ID.
Fortran Syntax:
    SUBROUTINE TecUtilGeomSetAttached(
   &           GIDPtr,
   &           Attached)
    POINTER         (GIDPtr, GID)
    INTEGER*4       Attached

Python Syntax:

  Results = TecUtil.GeomSetAttached(GID, Attached)

  Input:
                  GID                  long
                  Attached             boolean
  Output:
    Results[0]    ReturnVal            NONE

Attach a geometry to zone or mapping 5:

   extern Geom_ID g; // created elsewhere
   TecUtilGeomSetAttached(g, TRUE);
   TecUtilGeomSetZoneOrMap(g, 5);

void TecUtilGeomSetClipping ( Geom_ID  GID,
Clipping_e  Clipping 
)

Set the clipping properties of a geometry.

Parameters:
GID ID of the geometry
Clipping New clipping property for the geometry. The possible values are: Clipping_ClipToViewport and Clipping_ClipToFrame
Precondition:
GID must be a valid geometry ID.
Fortran Syntax:
    SUBROUTINE TecUtilGeomSetClipping(
   &           GIDPtr,
   &           Clipping)
    POINTER         (GIDPtr, GID)
    INTEGER*4       Clipping

Python Syntax:

  Results = TecUtil.GeomSetClipping(GID, Clipping)

  Input:
                  GID                  long
                  Clipping             Clipping_e  (defined in TecVals.py)
  Output:
    Results[0]    ReturnVal            NONE

Create a red circle and set the clipping to "ClipToFrame":

   Geom_ID g;
   g = TecUtilGeomCircleCreate(CoordSys_Frame, 50., 50., 25.);
   TecUtilGeomSetClipping(g, Clipping_ClipToFrame);

void TecUtilGeomSetColor ( Geom_ID  GID,
ColorIndex_t  Color 
)

Set the line color of a geometry.

Parameters:
GID ID of the geometry
Color New line color for the geometry. The possible values are: Black_C, Blue_C, Red_C, Green_C, Cyan_C, Purple_C, Yellow_C, White_C, or CustomXX_C where XX ranges from 1 to 64.
Precondition:
GID must be a valid geometry ID.
Fortran Syntax:
    SUBROUTINE TecUtilGeomSetColor(
   &           GIDPtr,
   &           Color)
    POINTER         (GIDPtr, GID)
    INTEGER*4       Color

Python Syntax:

  Results = TecUtil.GeomSetColor(GID, Color)

  Input:
                  GID                  long
                  Color                TecVals color constant
  Output:
    Results[0]    ReturnVal            NONE

Create a red circle:

   Geom_ID g;
   g = TecUtilGeomCircleCreate(CoordSys_Frame, 50., 50., 25.);
   TecUtilGeomSetColor(g, Red_C);

void TecUtilGeomSetDrawOrder ( Geom_ID  GID,
DrawOrder_e  DrawOrder 
)

Sets the draw order of a geometry.

Parameters:
GID ID of the geometry
DrawOrder Must be DrawOrder_BeforeData or DrawOrder_AfterData.
Precondition:
Must have one or more frames.

GID must be a valid geometry ID.

Fortran Syntax:
    SUBROUTINE TecUtilGeomSetDrawOrder(
   &           GIDPtr,
   &           DrawOrder)
    POINTER         (GIDPtr, GID)
    INTEGER*4       DrawOrder

Python Syntax:

  Results = TecUtil.GeomSetDrawOrder(GID, DrawOrder)

  Input:
                  GID                  long
                  DrawOrder            DrawOrder_e  (defined in TecVals.py)
  Output:
    Results[0]    ReturnVal            NONE

void TecUtilGeomSetFillColor ( Geom_ID  GID,
ColorIndex_t  FillColor 
)

Set the fill color of a geometry.

Use TecUtilGeomSetIsFilled() to specify whether or not a geometry is filled with color.

Parameters:
GID ID of the geometry
FillColor New fill color for the geometry. The possible values are: Black_C, Blue_C, Red_C, Green_C, Cyan_C, Purple_C, Yellow_C, White_C, or CustomXX_C where XX ranges from 1 to 64
Precondition:
GID must be a valid geometry ID.
Fortran Syntax:
    SUBROUTINE TecUtilGeomSetFillColor(
   &           GIDPtr,
   &           FillColor)
    POINTER         (GIDPtr, GID)
    INTEGER*4       FillColor

Python Syntax:

  Results = TecUtil.GeomSetFillColor(GID, FillColor)

  Input:
                  GID                  long
                  FillColor            TecVals color constant
  Output:
    Results[0]    ReturnVal            NONE

Create a red circle filled with yellow:

   Geom_ID g;
   g = TecUtilGeomCircleCreate(CoordSys_Frame, 50., 50., 25.);
   TecUtilGeomSetColor(g, Red_C);
   TecUtilGeomSetFillColor(g, Yellow_C);
   TecUtilGeomSetIsFilled(g, TRUE);

void TecUtilGeomSetIsFilled ( Geom_ID  GID,
Boolean_t  IsFilled 
)

Set whether or not a geometry is filled with a color.

Use TecUtilGeomSetFillColor() to specify the actual color to fill the geometry with.

Parameters:
GID ID of a geometry
IsFilled TRUE to fill the geometry, FALSE to not fill.
Precondition:
GID must be a valid geometry ID.
Fortran Syntax:
    SUBROUTINE TecUtilGeomSetIsFilled(
   &           GIDPtr,
   &           IsFilled)
    POINTER         (GIDPtr, GID)
    INTEGER*4       IsFilled

Python Syntax:

  Results = TecUtil.GeomSetIsFilled(GID, IsFilled)

  Input:
                  GID                  long
                  IsFilled             boolean
  Output:
    Results[0]    ReturnVal            NONE

void TecUtilGeomSetLinePattern ( Geom_ID  GID,
LinePattern_e  LinePattern 
)

Set the line pattern for a geometry.

Parameters:
GID ID of a geometry
LinePattern Line pattern for the geometry. The possible values are LinePattern_Solid, LinePattern_Dashed, LinePattern_DashDot, LinePattern_Dotted, LinePattern_LongDash or LinePattern_DashDotDot
Precondition:
GID must be a valid geometry ID.
Fortran Syntax:
    SUBROUTINE TecUtilGeomSetLinePattern(
   &           GIDPtr,
   &           LinePattern)
    POINTER         (GIDPtr, GID)
    INTEGER*4       LinePattern

Python Syntax:

  Results = TecUtil.GeomSetLinePattern(GID, LinePattern)

  Input:
                  GID                  long
                  LinePattern          LinePattern_e  (defined in TecVals.py)
  Output:
    Results[0]    ReturnVal            NONE

Create a dotted circle:

   Geom_ID g;
   g = TecUtilGeomCircleCreate(CoordSys_Frame, 50., 50., 25.);
   TecUtilGeomSetLinePattern(g, LinePattern_Dotted);

void TecUtilGeomSetLineThickness ( Geom_ID  GID,
double  LineThickness 
)

Set the line thickness for a geometry.

Parameters:
GID ID of a geometry
LineThickness Thickness of the lines in frame units
Precondition:
GID must be a valid geometry ID.
Fortran Syntax:
    SUBROUTINE TecUtilGeomSetLineThickness(
   &           GIDPtr,
   &           LineThickness)
    POINTER         (GIDPtr, GID)
    REAL*8          LineThickness

Python Syntax:

  Results = TecUtil.GeomSetLineThickness(GID, LineThickness)

  Input:
                  GID                  long
                  LineThickness        double
  Output:
    Results[0]    ReturnVal            NONE

Create a circle with five percent thick lines:

   Geom_ID g;
   g = TecUtilGeomCircleCreate(CoordSys_Frame, 50., 50., 25.);
   TecUtilGeomSetLineThickness(g, 5.);

Boolean_t TecUtilGeomSetMacroFunctionCmd ( Geom_ID  GID,
const char *  Command 
)

Set the macro function command for a geometry.

Parameters:
GID ID of a geometry
Command Macro function (and parameters) to be executed when the user holds down Ctrl and clicks the right mouse button on the geometry
Precondition:
Command Pointer must be a valid address or NULL.

GID must be a valid geometry ID.

Fortran Syntax:
    INTEGER*4 FUNCTION TecUtilGeomSetMacroFunctionCmd(
   &                   GIDPtr,
   &                   Command)
    POINTER         (GIDPtr, GID)
    CHARACTER*(*)   Command

Python Syntax:

  Results = TecUtil.GeomSetMacroFunctionCmd(GID, Command)

  Input:
                  GID                  long
                  Command              string
  Output:
    Results[0]    ReturnVal            boolean

Set a geometry so that macro function "PlotData" is called whenever the user holds down Ctrl and clicks the right mouse button on the geometry.

   extern Geom_ID g; // created elsewhere
   TecUtilGeomSetMacroFunctionCmd(g, "PlotData");

void TecUtilGeomSetPatternLength ( Geom_ID  GID,
double  PatternLength 
)

Set the line pattern length for a geometry.

Parameters:
GID ID of a geometry
PatternLength Length of the line pattern in frame units.
Precondition:
GID must be a valid geometry ID.
Fortran Syntax:
    SUBROUTINE TecUtilGeomSetPatternLength(
   &           GIDPtr,
   &           PatternLength)
    POINTER         (GIDPtr, GID)
    REAL*8          PatternLength

Python Syntax:

  Results = TecUtil.GeomSetPatternLength(GID, PatternLength)

  Input:
                  GID                  long
                  PatternLength        double
  Output:
    Results[0]    ReturnVal            NONE

Create two concentric dashed circles of different line pattern lengths (two and ten percent):

   Geom_ID g1, g2;
   g1 = TecUtilGeomCircleCreate(CoordSys_Frame, 50., 50., 20.);
   TecUtilGeomSetLinePattern(g1, Pattern_Dashed);
   TecUtilGeomSetPatternLength(g1, 2.);
   g2 = TecUtilGeomCircleCreate(CoordSys_Frame, 50., 50., 30.);
   TecUtilGeomSetLinePattern(g2, Pattern_Dashed);
   TecUtilGeomSetPatternLength(g2, 10.);

void TecUtilGeomSetPositionCoordSys ( Geom_ID  GID,
CoordSys_e  CoordSys 
)

Set the position coordinate system for a geometry.

This will convert all values in the geometry as well as the anchor position such that the geometry remains in the same position on the screen.

Parameters:
GID ID of a geometry. This must not be a 3-D polyline.
CoordSys Coordinate system for the position of the geometry. The possible values are: CoordSys_Frame or CoordSys_Grid
Precondition:
GID must be a valid geometry ID.
Fortran Syntax:
    SUBROUTINE TecUtilGeomSetPositionCoordSys(
   &           GIDPtr,
   &           CoordSys)
    POINTER         (GIDPtr, GID)
    INTEGER*4       CoordSys

Python Syntax:

  Results = TecUtil.GeomSetPositionCoordSys(GID, CoordSys)

  Input:
                  GID                  long
                  CoordSys             CoordSys_e  (defined in TecVals.py)
  Output:
    Results[0]    ReturnVal            NONE

Create a 2-D line segment in frame coordinates and then convert those coordinates to grid coordinates. The geometry will be in the same location on the screen as its initial frame coordinates would indicate until the next time the view for that frame is changed.

   Geom_ID  g;
   g = TecUtilGeom2DLineSegmentCreate(CoordSys_Frame, 5, 5, 95, 95);
   TecUtilGeomSetPositionCoordSys(CoordSys_Grid);

void TecUtilGeomSetScope ( Geom_ID  GID,
Scope_e  Scope 
)

Set the scope for a geometry.

Parameters:
GID ID of a geometry
Scope Scope of geometry. The possible values are:Scope_Local (Show in the current frame only).Scope_Global (Show in all frames with the same data set as the current frame).
Precondition:
GID must be a valid geometry ID.
Fortran Syntax:
    SUBROUTINE TecUtilGeomSetScope(
   &           GIDPtr,
   &           Scope)
    POINTER         (GIDPtr, GID)
    INTEGER*4       Scope

Python Syntax:

  Results = TecUtil.GeomSetScope(GID, Scope)

  Input:
                  GID                  long
                  Scope                Scope_e  (defined in TecVals.py)
  Output:
    Results[0]    ReturnVal            NONE

void TecUtilGeomSetXYZAnchorPos ( Geom_ID  GID,
double  XPos,
double  YPos,
double  ZPos 
)

Deprecated:
Please use TecUtilGeomGetAnchorPos() instead.

Python Syntax:

  Results = TecUtil.GeomSetXYZAnchorPos(GID, XPos, YPos, ZPos)

  Input:
                  GID                  long
                  XPos                 double
                  YPos                 double
                  ZPos                 double
  Output:
    Results[0]    ReturnVal            NONE

void TecUtilGeomSetZoneOrMap ( Geom_ID  GID,
EntIndex_t  ZoneOrMap 
)

Set the zone or Line-mapping attachment for a geometry.

Use TecUtilGeomSetAttached() to specify whether or not the geometry is attached to a zone or Line-mapping.

Parameters:
GID ID of a geometry
ZoneOrMap Zone number or mapping number to which the geometry should be attached
Precondition:
GID must be a valid geometry ID.
Fortran Syntax:
    SUBROUTINE TecUtilGeomSetZoneOrMap(
   &           GIDPtr,
   &           ZoneOrMap)
    POINTER         (GIDPtr, GID)
    INTEGER*4       ZoneOrMap

Python Syntax:

  Results = TecUtil.GeomSetZoneOrMap(GID, ZoneOrMap)

  Input:
                  GID                  long
                  ZoneOrMap            int
  Output:
    Results[0]    ReturnVal            NONE

Geom_ID TecUtilGeomSquareCreate ( CoordSys_e  PositionCoordSys,
double  CornerX,
double  CornerY,
double  Size 
)

Create a square geometry.

Use the ID obtained from this function to set geometry attributes such as line style and color using the TecUtilGeomSetXxx functions.

Parameters:
PositionCoordSys Coordinate system used to position the geometry. The possible values are: CoordSys_Grid or CoordSys_Frame
CornerX X-Coordinate for Lower left corner of the square
CornerY Y-Coordinate for Lower left corner of the square
Size Width/height of the square. Must be non-zero
Returns:
If successfully created then the return value is a valid ID that you may use to further set attributes for this geometry. Otherwise, TECUTILBADID is returned.
Fortran Syntax:
    SUBROUTINE TecUtilGeomSquareCreate(
   &           PositionCoordSys,
   &           CornerX,
   &           CornerY,
   &           Size,
   &           ResultPtr)
    INTEGER*4      PositionCoordSys
    REAL*8         CornerX
    REAL*8         CornerY
    REAL*8         Size
    POINTER        (ResultPtr, Result)

Python Syntax:

  Results = TecUtil.GeomSquareCreate(PositionCoordSys, CornerX, CornerY, Size)

  Input:
                  PositionCoordSys     CoordSys_e  (defined in TecVals.py)
                  CornerX              double
                  CornerY              double
                  Size                 double
  Output:
    Results[0]    ReturnVal            long

Create a square of width 0.5 and anchored at (0.1, 0.1):

   Geom_ID G;
   G = TecUtilGeomSquareCreate(CoordSys_Grid,0.1,0.1,0.5);

double TecUtilGeomSquareGetSize ( Geom_ID  GID  ) 

Get the size of a square geometry.

Parameters:
GID Geometry ID. Must be a square geometry.
Returns:
The size of the square.
Precondition:
GID must be a valid geometry ID.
Fortran Syntax:
    REAL*8 FUNCTION TecUtilGeomSquareGetSize(GIDPtr)
    POINTER (GIDPtr, GID)

Python Syntax:

  Results = TecUtil.GeomSquareGetSize(GID)

  Input:
                  GID                  long
  Output:
    Results[0]    ReturnVal            double

Get the size of a square geometry:

   extern Geom_ID g; // must be a square
   double size = TecUtilGeomSquareGetSize(g);

void TecUtilGeomSquareSetSize ( Geom_ID  GID,
double  Size 
)

Set the size of a square geometry.

Parameters:
GID Geometry ID. Must be a square geometry.
Size New size of the square. Must be non-zero.
Precondition:
GID must be a valid geometry ID.
Fortran Syntax:
    SUBROUTINE TecUtilGeomSquareSetSize(
   &           GIDPtr,
   &           Size)
    POINTER         (GIDPtr, GID)
    REAL*8          Size

Python Syntax:

  Results = TecUtil.GeomSquareSetSize(GID, Size)

  Input:
                  GID                  long
                  Size                 double
  Output:
    Results[0]    ReturnVal            NONE

Set the size of a square to one:

   extern Geom_id g; // must be a square
   TecUtilGeomSquareSetSize(g,1.0);

Generated on Tue Mar 12 02:24:42 2013 for Tecplot by  doxygen 1.5.5