Functions | |
| Boolean_t | TecUtilColorMapRedistControlPts (void) |
| Redistribute the control points for the currently active color map so they are evenly spaced across the color spectrum. | |
| Boolean_t | TecUtilColorMapCopyStandard (ContourColorMap_e ColorMap) |
| Preset either the user-defined color map or the raw user-defined color map to be a copy of one of the standard color maps. | |
| Boolean_t | TecUtilColorMapResetToFactory (void) |
| Redistribute the control points and reset the RGB values for the currently active color map. | |
| Boolean_t | TecUtilRedraw (Boolean_t DoFullDrawing) |
| Redraw the current frame. | |
| Boolean_t | TecUtilRedrawAll (Boolean_t DoFullDrawing) |
| Redraw all frames. | |
| Boolean_t | TecUtilDrawGraphics (Boolean_t DoDrawing) |
| Turn on or off all graphics drawing. | |
| Boolean_t | TecUtilPageCreateNew (void) |
| Creates a new page. | |
| void | TecUtilPageSetCurrentToNext (void) |
| Changes the current page to the next one in the internal linked list of pages. | |
| void | TecUtilPageSetCurrentToPrev (void) |
| Changes the current page to the previous one in the internal linked list of pages. | |
| Boolean_t | TecUtilPageSetCurrentByName (const char *PageName) |
| Sets the current page to one matching the passed name. | |
| Boolean_t | TecUtilPageSetCurrentByUniqueID (UniqueID_t UniqueID) |
| Sets the current page to one matching the passed unique ID. | |
| void | TecUtilPageDelete (void) |
| Deletes the current page. | |
| void | TecUtilPageClear (void) |
| Deletes all frames in the current page. | |
| Boolean_t | TecUtilFrameCreateNew (Boolean_t UseSuppliedFrameSize, double XPos, double YPos, double Width, double Height) |
| Creates a new frame. | |
| Boolean_t | TecUtilFramePopByName (const char *Name) |
| Pop a frame (specified by name) to the top. | |
| Boolean_t | TecUtilFramePushByName (const char *Name) |
| Push a frame (specified by name) to the bottom. | |
| Boolean_t | TecUtilFramePopByUniqueID (UniqueID_t UniqueID) |
| Pops a frame identified by a unique ID. | |
| Boolean_t | TecUtilFramePushByUniqueID (UniqueID_t UniqueID) |
| Pushes a frame identified by a unique ID. | |
| Boolean_t | TecUtilFramePushTop (void) |
| Push the top (active) frame to the bottom. | |
| Boolean_t | TecUtilFramePush (int FrameNum) |
| Push a frame to the bottom of the frame stack. | |
| Boolean_t | TecUtilFramePop (int FrameNum) |
| Pop a frame to the top (that is, make it the active frame). | |
| Boolean_t | TecUtilFramePopAtPosition (double X, double Y) |
| Pop the frame on top at a specified position on the paper. | |
| Boolean_t | TecUtilFrameDeleteTop (void) |
| Delete the top (active) frame. | |
| Boolean_t | TecUtilFrameFitAllToPaper (void) |
| Resize all frames so that they fit inside the hardclip limits of the paper. | |
| ColorIndex_t | TecUtilFrameGetBackgroundColor (void) |
| This function gets the current background color of the frame. | |
| Boolean_t | TecUtilFrameGetName (char **Name) |
| Get the name of the current frame. | |
| Boolean_t | TecUtilStyleSetBase (StyleBase_e StyleBase) |
| Set the frame style defaults used by Tecplot when creating new frames. | |
| Boolean_t | TecUtilNewLayout (void) |
| Delete all frames and data sets (clear the current layout). | |
| Boolean_t | TecUtilOpenLayout (const char *FName, StringList_pa AltInstructions, Boolean_t Append) |
| Open and read in a new layout file. | |
| Boolean_t | TecUtilSaveLayoutX (ArgList_pa ArgList) |
| Save the current layout to a file. | |
| Boolean_t | TecUtilReadStylesheet (const char *FName, Boolean_t IncludePlotStyle, Boolean_t IncludeText, Boolean_t IncludeGeom, Boolean_t IncludeStreamPositions, Boolean_t IncludeContourLevels, Boolean_t MergeStyle, Boolean_t IncludeFrameSizeAndPosition) |
| Read a stylesheet file into the current frame. | |
| Boolean_t | TecUtilWriteStylesheetX (ArgList_pa ArgList) |
| Write the style for the current frame to a file. | |
| Boolean_t | TecUtilReadColorMap (const char *FName) |
| Load a color map file. | |
| Boolean_t | TecUtilRawColorMap (int NumRawRGBValues, ColorIndex_t *RawRValues_Array, ColorIndex_t *RawGValues_Array, ColorIndex_t *RawBValues_Array) |
| Assign the RGB values that define the Raw User-Defined color map. | |
| Boolean_t | TecUtilWriteColorMap (const char *FName) |
| Write the current color map to a file. | |
| Boolean_t | TecUtilExport (Boolean_t Append) |
| Export an image file from Tecplot. | |
| Boolean_t | TecUtilWorkViewFitSelectFrames (void) |
| Change the view in the workspace so the currently selected frames (that is, the frames with picked handles) are fit just inside the edges of the workspace. | |
| Boolean_t | TecUtilWorkViewFitAllFrames (void) |
| Change the view in the workspace so all frames are fit just inside the edges of the workspace. | |
| Boolean_t | TecUtilWorkViewFitPaper (void) |
| Change the view in the workspace so the entire paper is fit just inside the edges of the workspace. | |
| Boolean_t | TecUtilWorkViewMaximize (void) |
| Temporarily expand the workspace as large as possible. | |
| Boolean_t | TecUtilWorkViewLastView (void) |
| Return to the previous workspace view. | |
| Boolean_t | TecUtilWorkViewZoom (double X1, double Y1, double X2, double Y2) |
| Change the view into the workspace. | |
| Boolean_t | TecUtilWorkViewTranslate (double X, double Y) |
| Shift the view of the workspace. | |
| Boolean_t | TecUtilViewPush (void) |
| Instruct Tecplot to push the current view onto the view stack associated with the frame mode for the current frame. | |
| Boolean_t | TecUtilViewPaste (void) |
| Retrieve the view from the view paste buffer and assign it to the current frame. | |
| Boolean_t | TecUtilViewCopy (void) |
| Copy the view from the current frame to the view paste buffer. | |
| Boolean_t | TecUtilViewLast (void) |
| Retrieve the previous view from the view stack. | |
| Boolean_t | TecUtilViewZoom (double X1, double Y1, double X2, double Y2) |
| Change the view by "zooming" into the image. | |
| Boolean_t | TecUtilViewTranslate (double X, double Y) |
| Shift the image in the X- and/or Y-direction. | |
| Boolean_t | TecUtilViewCenter (void) |
| Center the data within the axis grid area. | |
| Boolean_t | TecUtilViewScale (double Scale) |
| Boolean_t | TecUtilViewSetMagnification (double Magnification) |
| Scale (magnify) the view by a given value. | |
| Boolean_t | TecUtilViewAxisFit (char Axis, short AxisNum) |
| Reset the range on a specific axis so that it equals the minimum and maximum of the data being plotted. | |
| Boolean_t | TecUtilViewDataFit (void) |
| Fit the data being plotted within the axis grid area. | |
| Boolean_t | TecUtilViewFit (void) |
| Fit the data being plotted within the axis grid area. | |
| Boolean_t | TecUtilViewNiceFit (void) |
| Fit the data being plotted within the axis grid area leaving a determined border around the edge of the plot to make in more visually appealing. | |
| Boolean_t | TecUtilViewMakeCurViewNice (void) |
| Give a border to the current view. | |
| Boolean_t | TecUtilViewAxisNiceFit (char Axis, short AxisNum) |
| Reset the range on a specific axis so that it equals a little more than the minimum and maximum of the data being plotted allowing a small border to enhance visual appeal. | |
| Boolean_t | TecUtilViewAxisMakeCurValsNice (char Axis, short AxisNum) |
| Makes the curently viewed axis values visually appealing. | |
| Boolean_t | TecUtilReset3DAxes (void) |
| Reset the ranges on the 3-D axes. | |
| Boolean_t | TecUtilReset3DScaleFactors (void) |
| Recalculate the scale factors for the 3-D axes. | |
| Boolean_t | TecUtilPrint (void) |
| Print the current layout to a printer or send the print instructions to a file. | |
| Boolean_t | TecUtilXYMapCopy (EntIndex_t SourceMap, EntIndex_t DestMap) |
| Boolean_t | TecUtilLineMapCopy (EntIndex_t SourceMap, EntIndex_t DestMap) |
| Copy attributes from an existing Line-mapping to another. | |
| Boolean_t | TecUtilXYMapCreate (void) |
| Boolean_t | TecUtilLineMapCreate (void) |
| Create a new Line-mapping. | |
| Boolean_t | TecUtilXYMapDelete (Set_pa MapsToDelete) |
| Boolean_t | TecUtilLineMapDelete (Set_pa MapsToDelete) |
| Delete one or more Line-maps. | |
| Boolean_t | TecUtilXYMapShiftToTop (Set_pa MapsToShift) |
| Boolean_t | TecUtilLineMapShiftToTop (Set_pa MapsToShift) |
| Shift a list of Line-maps to the top of the Line-map list. | |
| Boolean_t | TecUtilXYMapShiftToBottom (Set_pa MapsToShift) |
| Boolean_t | TecUtilLineMapShiftToBottom (Set_pa MapsToShift) |
| Shift a list of Line-maps to the bottom of the Line-map list. | |
| Boolean_t | TecUtilViewRotate (RotateAxis_e RotateAxis, double RotateAmountInDegrees) |
| Boolean_t | TecUtilViewRotate3D (RotateAxis_e RotateAxis, double RotateAmountInDegrees, double VectorX, double VectorY, double VectorZ, RotateOriginLocation_e RotateOriginLocation) |
| Do a 3-D rotation about a given axis. | |
| Boolean_t | TecUtilReset3DOrigin (void) |
| Reposition the rotation origin in 3-D to be at the centroid of the data. | |
| Boolean_t | TecUtilSet3DEyeDistance (double EyeDistance) |
| Sets the distance the viewer is from the plane that is parallel to the screen and passes through the 3-D rotation origin. | |
| Boolean_t | TecUtilReset3DOriginX (ArgList_pa ArgList) |
| Reposition the rotation origin in 3-D to the specified location. | |
| Boolean_t | TecUtilResetVectorLength (void) |
| Reset the length of the vectors. | |
| Boolean_t | TecUtilScatterResetRelSize (void) |
| Reset the relative scatter sizing. | |
| Boolean_t | TecUtilContourLevelX (ArgList_pa ArgList) |
| Modify the contour levels. | |
| Boolean_t | TecUtilContourLevelAdd (int NumEntries, const double *RawData_Array, Boolean_t ShowTrace) |
| Boolean_t | TecUtilContourLevelNew (int NumEntries, const double *RawData_Array, Boolean_t ShowTrace) |
| Boolean_t | TecUtilContourLevelDeleteRange (double RangeMin, double RangeMax, Boolean_t ShowTrace) |
| Boolean_t | TecUtilContourLevelReset (int NumEntries) |
| Boolean_t | TecUtilContourLevelDelNearest (double Level, Boolean_t ShowTrace) |
| Boolean_t | TecUtilContourLabelX (ArgList_pa ArgList) |
| Manage contour line labels in your plot. | |
| Boolean_t | TecUtilContourLabelAdd (double X, double Y, double Z, Boolean_t IsAligned) |
| Boolean_t | TecUtilContourLabelDeleteAll (void) |
| Boolean_t | TecUtilStreamtraceAdd (int NumRakePoints, Streamtrace_e StreamType, StreamDir_e Direction, double StartXPos, double StartYPos, double StartZPos, double AltStartXPos, double AltStartYPos, double AltStartZPos) |
| Add a single streamtrace or a rake of streamtraces to the current frame. | |
| Boolean_t | TecUtilStreamtraceDeleteAll (void) |
| Delete all streamtraces in the current frame. | |
| Boolean_t | TecUtilStreamtraceDeleteRange (int Start, int End) |
| Delete a range of streamtraces. | |
| Boolean_t | TecUtilStreamtraceSetTermLine (int NumPoints, const double *XTermLinePts_Array, const double *YTermLinePts_Array) |
| Set the position of the termination line for streamtraces. | |
| Boolean_t | TecUtilStreamtraceResetDelta (void) |
| Resets the time interval between stream markers. | |
| int | TecUtilStreamtraceGetCount (void) |
| Get the number of active streamtraces. | |
| void | TecUtilStreamtraceGetPos (int StreamNumber, double *X, double *Y, double *Z) |
| Get the starting position for a given streamtrace. | |
| void | TecUtilCreateSliceZoneShowTrace (Boolean_t DoShow) |
| |
| Boolean_t | TecUtilRotate2D (Set_pa ZoneSet, double RotateAmountInDegrees, double XOrigin, double YOrigin) |
| Boolean_t | TecUtilAnimateZonesX (ArgList_pa ArgList) |
| Animate zones. | |
| Boolean_t | TecUtilAnimateXYMapsX (ArgList_pa ArgList) |
| Boolean_t | TecUtilAnimateLineMapsX (ArgList_pa ArgList) |
| Animate Line-mapping. | |
| Boolean_t | TecUtilAnimateContourLevelsX (ArgList_pa ArgList) |
| Animate contour levels. | |
| Boolean_t | TecUtilAnimateIsoSurfacesX (ArgList_pa ArgList) |
| Animate iso-surfaces. | |
| Boolean_t | TecUtilAnimateTimeX (ArgList_pa ArgList) |
| Animate Time. | |
| Boolean_t | TecUtilAnimateIJKPlanesX (ArgList_pa ArgList) |
| Animate I-, J-, or K-planes. | |
| Boolean_t | TecUtilAnimateIJKBlankingX (ArgList_pa ArgList) |
| Animate IJK-blanking. | |
| Boolean_t | TecUtilAnimateStreamX (ArgList_pa ArgList) |
| Animate streamtraces. | |
| Boolean_t | TecUtilAnimateSlicesX (ArgList_pa ArgList) |
| Animates slices. | |
| Boolean_t | TecUtilAnimateZones (EntIndex_t StartZone, EntIndex_t EndZone, EntIndex_t ZoneSkip, Boolean_t CreateMovieFile, const char *MovieFName) |
| Produce an animation showing one zone at a time. | |
| Boolean_t | TecUtilAnimateXYMaps (EntIndex_t StartMap, EntIndex_t EndMap, EntIndex_t MapSkip, Boolean_t CreateMovieFile, const char *MovieFName) |
| Boolean_t | TecUtilAnimateContourLevels (SmInteger_t StartLevel, SmInteger_t EndLevel, SmInteger_t LevelSkip, Boolean_t CreateMovieFile, const char *MovieFName) |
| Produce an animation of a contour line plot by showing a single level at a time. | |
| Boolean_t | TecUtilAnimateIJKPlanes (char IJOrK, LgIndex_t StartIndex, LgIndex_t EndIndex, LgIndex_t IndexSkip, Boolean_t CreateMovieFile, const char *MovieFName) |
| Produce an animation that cycles through I-, J-, or K-planes in an IJK-ordered data set. | |
| Boolean_t | TecUtilAnimateIJKBlanking (double StartIMinFract, double StartJMinFract, double StartKMinFract, double StartIMaxFract, double StartJMaxFract, double StartKMaxFract, double EndIMinFract, double EndJMinFract, double EndKMinFract, double EndIMaxFract, double EndJMaxFract, double EndKMaxFract, int NumSteps, Boolean_t CreateMovieFile, const char *MovieFName) |
| Produce an animation of different IJK-blankings in your plot. | |
| Boolean_t | TecUtilAnimateStream (int NumStepsPerCycle, int NumCycles, Boolean_t CreateMovieFile, const char *MovieFName) |
| Produce an animation of stream markers or dashes, moving along the currently defined streamtrace paths. | |
| Boolean_t | TecUtilAnimateSlices (SmInteger_t StartSlice, SmInteger_t EndSlice, SmInteger_t NumSlices, Boolean_t CreateMovieFile, const char *MovieFName) |
| Animates the currently defined 3-D slices. | |
| Boolean_t | TecUtilExportIsRecording (void) |
| Checks to see if Tecplot is currently recording an animation. | |
| Boolean_t | TecUtilExportFinish (void) |
| This function assembles all of the exported animation frames into the final animation file. | |
| Boolean_t | TecUtilExportStart (void) |
| This functions starts a new animation and exports the first frame. | |
| Boolean_t | TecUtilExportNextFrame (void) |
| Export the next frame of a movie animation. | |
| void | TecUtilExportCancel (void) |
| Cancel a movie export which is in progress. | |
| void | TecUtilThreeDViewGetViewerAngle (double *PsiAngle, double *ThetaAngle, double *AlphaAngle) |
| Queries the 3-D viewer angles. | |
| void | TecUtilThreeDViewGetViewerPos (double *XPos, double *YPos, double *ZPos) |
| Queries the 3-D viewer angles. | |
| void | TecUtilThreeDViewGetProjection (double *FieldOfView, double *ViewWidth, Boolean_t *IsInPerspective) |
| Queries the 3-D view attributes. | |
| void | TecUtilConvert3DPositionToGrid (double XPosition, double YPosition, double ZPosition, double *XGridPosition, double *YGridPosition, double *ZGridPosition) |
| Converts from 3-D world coordinates to Tecplot's 3-D grid coordinates. | |
| void | TecUtilConvertGridTo3DPosition (double XGridPosition, double YGridPosition, double ZGridPosition, double *XPosition, double *YPosition, double *ZPosition) |
| Converts from Tecplot's 3-D "Grid" or view coordinates to world coordinates. | |
| double | TecUtilThreeDViewGetNearZPlane (void) |
| Returns the Z-value below which you can no longer trust any values of TecUtilConvert3DPositionToGrid(). | |
| double | TecUtil3DViewGetNearZPlane (void) |
| void | TecUtilSetupTransformations (void) |
| Initializes transformation information so that coordinate conversion functions can be used. | |
| void | TecUtilFrameLightweightPopStart (void) |
| Initialize lightweight frame pop. | |
| Boolean_t | TecUtilFrameLightweightPopNext (void) |
| Pop the next frame. | |
| void | TecUtilFrameLightweightPopEnd (void) |
| Ends a sequence of lightweight frame pops. | |
| void | TecUtilDynamicLabelRegisterCallback (const char *DynamicLabelName, DynamicLabelCallback_pf DynamicLabelCallback, ArbParam_t ClientData) |
| Registers a dynamic axis label provider callback. | |
| void | TecUtilGeomDelete (Geom_ID GID) |
| Deletes the specified geometry object. | |
| void | TecUtilTextDelete (Text_ID TID) |
| Deletes the specified text object. | |
| Boolean_t | TecUtilGeomIsValid (Geom_ID GID) |
| Validate a geometry ID. | |
| Boolean_t | TecUtilTextIsValid (Text_ID TID) |
| Determine if the text object is valid in the current frame context. | |
| double | TecUtilConvertXPosition (CoordSys_e OldCoordSys, CoordSys_e NewCoordSys, double OldX) |
| Convert the specified X-coordinate value from one coordinate system to another. | |
| double | TecUtilConvertXDimension (CoordSys_e OldCoordSys, CoordSys_e NewCoordSys, double OldDimension) |
| Convert the specified horizontal dimension from one coordinate system to another. | |
| double | TecUtilConvertYPosition (CoordSys_e OldCoordSys, CoordSys_e NewCoordSys, double OldY) |
| Convert the specified Y-coordinate value from one coordinate system to another. | |
| double | TecUtilConvertYDimension (CoordSys_e OldCoordSys, CoordSys_e NewCoordSys, double OldDimension) |
| Convert the specified vertical dimension from one coordinate system to another. | |
| double | TecUtilConvertUnits (Units_e OldUnits, Units_e NewUnits, double OldSize) |
| Convert from one measurement system to another. | |
| Clipping_e | TecUtilTextGetClipping (Text_ID TID) |
| Get the clipping properties of a text object. | |
| void | TecUtilTextGetAnchorPos (Text_ID TID, double *XOrThetaPos, double *YOrRPos, double *ZPos) |
| Get the anchor coordinate position of the text object in the current coordinate system. | |
| void | TecUtilTextGetXYPos (Text_ID TID, double *XPos, double *YPos) |
| CoordSys_e | TecUtilTextGetPositionCoordSys (Text_ID TID) |
| Get the coordinate system to which the text is associated. | |
| EntIndex_t | TecUtilTextGetZoneOrMap (Text_ID TID) |
| Get the zone or map with which the text object is associated (if it is attached). | |
| Boolean_t | TecUtilTextIsAttached (Text_ID TID) |
| Determine if the text object is attached to a zone or map. | |
| ColorIndex_t | TecUtilTextGetColor (Text_ID TID) |
| Get the color of the text object. | |
| Font_e | TecUtilTextGetFont (Text_ID TID) |
| Get the font used for the text object. | |
| double | TecUtilTextGetHeight (Text_ID TID) |
| Get the text height in the currently defined text size units. | |
| Units_e | TecUtilTextGetSizeUnits (Text_ID TID) |
| Get the size units for the text object. | |
| TextBox_e | TecUtilTextBoxGetType (Text_ID TID) |
| Get the type of the box surrounding the text object. | |
| double | TecUtilTextBoxGetMargin (Text_ID TID) |
| Get the margin between the text and the box surrounding the text object. | |
| double | TecUtilTextBoxGetLineThickness (Text_ID TID) |
| Get the line thickness of the text box border. | |
| ColorIndex_t | TecUtilTextBoxGetColor (Text_ID TID) |
| Get the line color of the box surrounding the text object. | |
| ColorIndex_t | TecUtilTextBoxGetFillColor (Text_ID TID) |
| Get the fill color of the box surrounding the text object. | |
| double | TecUtilTextGetAngle (Text_ID TID) |
| Get the text angle. | |
| TextAnchor_e | TecUtilTextGetAnchor (Text_ID TID) |
| Get the text anchor style. | |
| double | TecUtilTextGetLineSpacing (Text_ID TID) |
| Get the spacing between lines of text. | |
| Scope_e | TecUtilTextGetScope (Text_ID TID) |
| Get the scope of the text object. | |
| Boolean_t | TecUtilTextGetMacroFunctionCmd (Text_ID TID, char **MacroFunctionCommand) |
| Get the macro function command string associated with the text object. | |
| Boolean_t | TecUtilTextGetString (Text_ID TID, char **TextString) |
| Get the string associated with the text object. | |
| Text_ID | TecUtilTextGetNext (Text_ID TID) |
| Get the next text object, relative to the specified text object, from the list of text objects maintained by the current frame. | |
| Text_ID | TecUtilTextGetPrev (Text_ID TID) |
| Get the previous text object, relative to the specified text object, from the list of text objects maintained by the current frame. | |
| 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) |
| Queries 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 | TecUtilTextSetClipping (Text_ID TID, Clipping_e Clipping) |
| Set the clipping properties of a text object. | |
| void | TecUtilTextSetAnchorPos (Text_ID TID, double XOrThetaPos, double YOrRPos, double ZPos) |
| Set the XY-position for the text object. | |
| void | TecUtilTextSetXYPos (Text_ID TID, double XPos, double YPos) |
| void | TecUtilTextSetCoordSysAndUnits (Text_ID TID, CoordSys_e PositionCoordSys, Units_e HeightUnits) |
| Set the coordinate system for the position and the units for the character height of a text object. | |
| void | TecUtilTextSetZoneOrMap (Text_ID TID, EntIndex_t ZoneOrMap) |
| Set the zone or map to which the text object is associated (if it is attached). | |
| void | TecUtilTextSetAttached (Text_ID TID, Boolean_t Attached) |
| Indicate if the text object should be attached to a zone or map. | |
| void | TecUtilTextSetColor (Text_ID TID, ColorIndex_t Color) |
| Set the color of a text object. | |
| void | TecUtilTextSetFont (Text_ID TID, Font_e Font) |
| Set the font for a text object. | |
| void | TecUtilTextSetHeight (Text_ID TID, double Height) |
| Set the character height for a text object. | |
| void | TecUtilTextBoxSetType (Text_ID TID, TextBox_e TextBoxType) |
| Set the type of the box surrounding the text object. | |
| void | TecUtilTextBoxSetMargin (Text_ID TID, double Margin) |
| Set the margin between the text and the box surrounding the text object. | |
| void | TecUtilTextBoxSetLineThickness (Text_ID TID, double LineThickness) |
| Set the line thickness of the box surrounding the text object. | |
| void | TecUtilTextBoxSetColor (Text_ID TID, ColorIndex_t BoxColor) |
| Set the line color for the box surrounding a text object. | |
| void | TecUtilTextBoxSetFillColor (Text_ID TID, ColorIndex_t BoxFillColor) |
| Set the fill color of the box surrounding a text object. | |
| void | TecUtilTextSetAngle (Text_ID TID, double Angle) |
| Set the angle in degrees for a text object. | |
| void | TecUtilTextSetAnchor (Text_ID TID, TextAnchor_e Anchor) |
| Set the anchor style for a text object. | |
| void | TecUtilTextSetLineSpacing (Text_ID TID, double LineSpacing) |
| Set the line spacing for a text object. | |
| void | TecUtilTextSetScope (Text_ID TID, Scope_e Scope) |
| Set the scope of the text object. | |
| Boolean_t | TecUtilTextSetMacroFunctionCmd (Text_ID TID, const char *Command) |
| Set the macro function command associated with a text object. | |
| Boolean_t | TecUtilTextSetString (Text_ID TID, const char *TextString) |
| Set the text string for a text object. | |
| 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. | |
| Text_ID | TecUtilTextCreate (CoordSys_e PositionCoordSys, double PosX, double PosY, Units_e HeightUnits, double Height, const char *Text) |
| Creates a text object. | |
| Text_ID | TecUtilText3DCreate (double PosX, double PosY, double PosZ, Units_e HeightUnits, double Height, const char *Text) |
| Create a 3D text label in Tecplot. | |
| 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. | |
| Boolean_t | TecUtilUndoCanUndo (void) |
| Determine if you can undo the last operation. | |
| Boolean_t | TecUtilUndoDoUndo (void) |
| Undo the last operation. | |
| ViewState_pa | TecUtilViewGet (void) |
| Saves a view for a plot type (2D, 3D, etc. | |
| Boolean_t | TecUtilViewSet (ViewState_pa ViewState) |
| Restores a saved view for a plot type (2D, 3D, etc. | |
| PlotType_e | TecUtilViewGetPlotType (ViewState_pa ViewState) |
| Queries the plot type of a saved view object. | |
| void | TecUtilViewDealloc (ViewState_pa *ViewState) |
| Deallocates a saved view returned by TecUtilViewGet and sets the pointer to NULL. | |
| Boolean_t | TecUtilFieldLayerIsActive (const char *LayerShowFlag) |
| Indicates if the field layer of interest is active or not. | |
| Boolean_t | TecUtilLinePlotLayerIsActive (const char *LayerShowFlag) |
| Indicates if the line plot layer of interest is active or not. | |
| ArbParam_t | TecUtilFrameGetLinking (const char *Attribute) |
| ArbParam_t | TecUtilLinkingGetValue (const char *Attribute, const char *SubAttribute) |
| Gets frame linking attributes. | |
| void | TecUtilWorkAreaGetDimensions (LgIndex_t *Width, LgIndex_t *Height) |
| Get the dimensions of the Tecplot workspace. | |
| void | TecUtilPaperGetDimensions (double *Width, double *Height) |
| Get the dimensions of the currently defined paper in the Tecplot workspace. | |
| Boolean_t | TecUtilViewGetMagnification (double *Magnification) |
| Get the current view magnification. | |
| Boolean_t | TecUtilBlankingCheckDataPoint (EntIndex_t Zone, LgIndex_t PointIndex) |
| Determine if the specified data point in the specified zone is visible or if it is not drawn due to value-blanking or IJK-blanking. | |
| Boolean_t | TecUtilBlankingCheckFECell (EntIndex_t Zone, LgIndex_t CellIndex) |
| Determine if the specified element in the specified finite-element zone is visible or if it is not drawn due to value-blanking. | |
| Boolean_t | TecUtilBlankingCheckIJKCell (EntIndex_t Zone, IJKPlanes_e ZonePlane, LgIndex_t CellIndex) |
| Determine if the specified cell in the specified IJK-ordered zone is visible or if it is not drawn due to value-blanking or IJK-blanking. | |
| LgIndex_t | TecUtilPageGetCount (void) |
| Returns the number of pages managed by Tecplot. | |
| Boolean_t | TecUtilPageGetName (char **PageName) |
| Get the name of the current page. | |
| UniqueID_t | TecUtilPageGetUniqueID (void) |
| Returns the unique ID of the current page. | |
| int | TecUtilFrameGetCount (void) |
| Get a count of the number of frames currently defined. | |
| FrameMode_e | TecUtilFrameGetMode (void) |
| PlotType_e | TecUtilFrameGetPlotType (void) |
| Get the plot type of the current frame. | |
| void | TecUtilAxisGetRange (char Axis, short AxisNum, double *AxisMin, double *AxisMax) |
| Get the current minimum and maximum values for the specified axis. | |
| GetValueReturnCode_e | TecUtilStyleGetLowLevelX (ArgList_pa ArgList) |
| Low level function used to get most frame and base attribute values in Tecplot. | |
| ArbParam_t | TecUtilFieldStyleGetArbValue (EntIndex_t Zone, const char *S1, const char *S2, const char *S3) |
| Queries a zone attribute. | |
| double | TecUtilFieldStyleGetDoubleValue (EntIndex_t Zone, const char *S1, const char *S2, const char *S3) |
| Queries a zone attribute. | |
| ArbParam_t | TecUtilXYMapStyleGetArbValue (EntIndex_t XYMap, const char *S1, const char *S2, const char *S3) |
| ArbParam_t | TecUtilLineMapStyleGetArbValue (EntIndex_t LineMap, const char *S1, const char *S2, const char *S3) |
| Queries an Line-map attribute. | |
| double | TecUtilXYMapStyleGetDoubleValue (EntIndex_t XYMap, const char *S1, const char *S2, const char *S3) |
| double | TecUtilLineMapStyleGetDoubleValue (EntIndex_t LineMap, const char *S1, const char *S2, const char *S3) |
| Queries an Line-map attribute. | |
| UniqueID_t | TecUtilFrameGetUniqueID (void) |
| Gets a unique ID for a frame. | |
| UniqueID_t | TecUtilLineMapGetUniqueID (EntIndex_t LineMap) |
| Gets a unique ID for a line map. | |
| EntIndex_t | TecUtilLineMapGetNumByUniqueID (UniqueID_t UniqueID) |
| Gets a line map number, given a unique ID. | |
| Boolean_t | TecUtilXYMapGetName (EntIndex_t Map, char **Name) |
| Boolean_t | TecUtilLineMapGetName (EntIndex_t Map, char **Name) |
| Get the name of an Line-map. | |
| void | TecUtilFrameGetPosAndSize (double *X, double *Y, double *Width, double *Height) |
| Get the position and size of a frame. | |
| Text_ID | TecUtilTextGetBase (void) |
| Get the first text object from the list of text objects maintained by the current frame. | |
| Geom_ID | TecUtilGeomGetBase (void) |
| Get the base geometry attached to the current frame. | |
| Boolean_t | TecUtilXYMapGetActive (Set_pa *ActiveXYMaps) |
| Boolean_t | TecUtilLineMapGetActive (Set_pa *ActiveLineMaps) |
| Obtain the set of active Line-maps. | |
| void | TecUtilXYMapGetAssignment (EntIndex_t XYMap, EntIndex_t *Zone, EntIndex_t *XAxisVar, EntIndex_t *YAxisVar, SmInteger_t *XAxis, SmInteger_t *YAxis, FunctionDependency_e *FunctionDependency) |
| void | TecUtilLineMapGetAssignment (EntIndex_t LineMap, EntIndex_t *Zone, EntIndex_t *XOrThetaVar, EntIndex_t *YOrRVar, SmInteger_t *XAxis, SmInteger_t *YAxis, FunctionDependency_e *FunctionDependency) |
| Get the assignment information for a given Line-map. | |
| void | TecUtilTextBoxGetPosition (Text_ID T, double *X1, double *Y1, double *X2, double *Y2, double *X3, double *Y3, double *X4, double *Y4) |
| Get the position of the four corners of the box surrounding the text object. | |
| EntIndex_t | TecUtilXYMapGetCount (void) |
| EntIndex_t | TecUtilLineMapGetCount (void) |
| Returns the number of Line-maps. | |
| EntIndex_t | TecUtilFieldMapGetCount (void) |
| Returns the number of Field-maps. | |
| Boolean_t | TecUtilFieldMapGetActive (Set_pa *ActiveFieldMaps) |
| Obtain the set of active Field-maps. | |
| Boolean_t | TecUtilFieldMapIsActive (EntIndex_t FieldMap) |
| Determine if an Field-map is active. | |
| FieldMapMode_e | TecUtilFieldMapGetMode (EntIndex_t FieldMap) |
| Returns the mode of a fieldmap. | |
| EntIndex_t | TecUtilFieldMapGetCandidateZone (EntIndex_t FieldMap) |
| Returns the number of the candidate zone for the fieldmap. | |
| Boolean_t | TecUtilFieldMapIsRelevant (EntIndex_t FieldMap) |
| Determines if the fieldmap is relevant for the current time step. | |
| Boolean_t | TecUtilFieldMapHasOrderedZones (EntIndex_t FieldMap) |
| Determines if the fieldmap contains any ordered zones. | |
| Boolean_t | TecUtilFieldMapHasIJKOrderedZones (EntIndex_t FieldMap) |
| Determines if the fieldmap contains any IJK ordered zones. | |
| Boolean_t | TecUtilFieldMapHasFEZones (EntIndex_t FieldMap) |
| Determines if the fieldmap contains any FE zones. | |
| Boolean_t | TecUtilFieldMapHasVolumeZones (EntIndex_t FieldMap) |
| Determines if the fieldmap contains any Volume zones. | |
| Boolean_t | TecUtilFieldMapHasSurfaceZones (EntIndex_t FieldMap) |
| Determines if the fieldmap contains any Surface zones. | |
| Boolean_t | TecUtilFieldMapHasLinearZones (EntIndex_t FieldMap) |
| Determines if the fieldmap contains any Linear zones. | |
| LgIndex_t | TecUtilLimitGetValue (const char *LimitString) |
| Convenience function to query Tecplot for a limit value. | |
| Boolean_t | TecUtilXYMapIsActive (EntIndex_t XYMap) |
| Boolean_t | TecUtilLineMapIsActive (EntIndex_t LineMap) |
| Determine if an Line-map is active. | |
| void | TecUtilColorMapGetBasicColorRGB (ColorIndex_t BasicColor, ColorIndex_t *Red, ColorIndex_t *Green, ColorIndex_t *Blue) |
| Get the RGB components of a basic color. | |
| LgIndex_t | TecUtilColorMapNumBasicColors (void) |
| Get the number of basic colors in Tecplot. | |
| Boolean_t | TecUtilAutoRedrawIsActive (void) |
| Queries the auto redraw state. | |
| Boolean_t | TecUtilContourGetLevels (SmInteger_t ContourGroup, LgIndex_t *NumLevels, double **LevelValues) |
| Gets the number of contour levels and contour level values currently defined for the specified contour group. | |
| double | TecUtilSolutionTimeGetCurrent (void) |
| Returns the current solution time for the current frame. | |
| SetValueReturnCode_e | TecUtilFrameSetPosAndSize (double X, double Y, double Width, double Height) |
| Sets the position and size of the current frame. | |
| SetValueReturnCode_e | TecUtilStyleSetLowLevelX (ArgList_pa ArgList) |
| Low level function used to set most frame and base attribute values in Tecplot. | |
| SetValueReturnCode_e | TecUtilStyleSetLowLevel (Widget TextFieldWidget, double DValue, ArbParam_t IValue, ArbParam_t SetOrOffset, AssignOp_e AssignModifier, const char *P1, const char *P2, const char *P3, const char *P4, const char *P5, const char *P6, Boolean_t OkToRecord) |
| Low level function used to set most frame and base attribute values in Tecplot. | |
| SetValueReturnCode_e | TecUtilFrameSetMode (FrameMode_e NewFrameMode) |
| SetValueReturnCode_e | TecUtilFrameSetPlotType (PlotType_e NewPlotType) |
| Set the current frame's plot type. | |
| SetValueReturnCode_e | TecUtilFrameSetName (const char *Name) |
| Set the name for the current frame. | |
| SetValueReturnCode_e | TecUtilPageSetName (const char *Name) |
| Set the name for the current page. | |
| SetValueReturnCode_e | TecUtilZoneSetSolutionTime (EntIndex_t Zone, double SolutionTime) |
| Assign a time value to the specified zone. | |
| SetValueReturnCode_e | TecUtilXYMapSetActive (Set_pa XYMapSet, AssignOp_e AssignModifier) |
| SetValueReturnCode_e | TecUtilLineMapSetActive (Set_pa LineMapSet, AssignOp_e AssignModifier) |
| Assigns which Line-maps are active. | |
| SetValueReturnCode_e | TecUtilFieldSetLayer (const char *LayerShowFlag, Boolean_t TurnOnFieldLayer) |
| SetValueReturnCode_e | TecUtilFieldLayerSetIsActive (const char *LayerShowFlag, Boolean_t TurnOnFieldLayer) |
| Instructs Tecplot to turn the specified layer on or off. | |
| SetValueReturnCode_e | TecUtilXYSetLayer (const char *LayerShowFlag, Boolean_t TurnOnXYLayer) |
| SetValueReturnCode_e | TecUtilLinePlotLayerSetIsActive (const char *LayerShowFlag, Boolean_t TurnOnLinePlotLayer) |
| Instructs Tecplot to turn on or off the specified line plot layer. | |
| SetValueReturnCode_e | TecUtilContourSetVariableX (ArgList_pa ArgList) |
| Assign which variable to use for contouring a specific contour group. | |
| SetValueReturnCode_e | TecUtilContourSetVariable (EntIndex_t NewVariable) |
| Assign which variable to use for contouring. | |
| SetValueReturnCode_e | TecUtilZoneSetVector (const char *Attribute, Set_pa ZoneSet, double DValue, ArbParam_t IValue) |
| Assign values to attributes for vector plots. | |
| SetValueReturnCode_e | TecUtilZoneSetVectorIJKSkip (const char *Attribute, Set_pa ZoneSet, LgIndex_t Skip) |
| Set the vector I-, J-, or K-skipping. | |
| SetValueReturnCode_e | TecUtilZoneSetShade (const char *Attribute, Set_pa ZoneSet, double DValue, ArbParam_t IValue) |
| Assign values to attributes for shade plots. | |
| SetValueReturnCode_e | TecUtilZoneSetVolumeMode (const char *Attribute, const char *SubAttribute, Set_pa ZoneSet, ArbParam_t IValue) |
| Assign the Volume Mode for field plots. | |
| SetValueReturnCode_e | TecUtilXYMapSetName (Set_pa XYMapSet, const char *NewName) |
| SetValueReturnCode_e | TecUtilLineMapSetName (Set_pa LineMapSet, const char *NewName) |
| Set the name of an Line-map. | |
| SetValueReturnCode_e | TecUtilXYMapSetAssignment (const char *Attribute, Set_pa XYMapSet, double DValue, ArbParam_t IValue) |
| SetValueReturnCode_e | TecUtilLineMapSetAssignment (const char *Attribute, Set_pa LineMapSet, double DValue, ArbParam_t IValue) |
| Define Line-map assignments. | |
| SetValueReturnCode_e | TecUtilXYMapSetLine (const char *Attribute, Set_pa XYMapSet, double DValue, ArbParam_t IValue) |
| SetValueReturnCode_e | TecUtilLineMapSetLine (const char *Attribute, Set_pa LineMapSet, double DValue, ArbParam_t IValue) |
| Assign values to attributes for lines in Line-plots. | |
| SetValueReturnCode_e | TecUtilXYMapSetCurve (const char *Attribute, Set_pa XYMapSet, double DValue, ArbParam_t IValue) |
| SetValueReturnCode_e | TecUtilLineMapSetCurve (const char *Attribute, Set_pa LineMapSet, double DValue, ArbParam_t IValue) |
| Assign values to attributes for curves in Line-plots. | |
| SetValueReturnCode_e | TecUtilXYMapSetSymbol (const char *Attribute, Set_pa XYMapSet, double DValue, ArbParam_t IValue) |
| SetValueReturnCode_e | TecUtilLineMapSetSymbol (const char *Attribute, Set_pa LineMapSet, double DValue, ArbParam_t IValue) |
| Assign values to attributes for symbols in Line-plots. | |
| SetValueReturnCode_e | TecUtilXYMapSetSymbolShape (const char *Attribute, Set_pa XYMapSet, ArbParam_t IValue) |
| SetValueReturnCode_e | TecUtilLineMapSetSymbolShape (const char *Attribute, Set_pa LineMapSet, ArbParam_t IValue) |
| Assign values for the symbol shape in Line-plots. | |
| SetValueReturnCode_e | TecUtilXYMapSetBarChart (const char *Attribute, Set_pa XYMapSet, double DValue, ArbParam_t IValue) |
| SetValueReturnCode_e | TecUtilLineMapSetBarChart (const char *Attribute, Set_pa LineMapSet, double DValue, ArbParam_t IValue) |
| Assign values to attributes for bar charts in Line-plots. | |
| SetValueReturnCode_e | TecUtilXYMapSetErrorBar (const char *Attribute, Set_pa XYMapSet, double DValue, ArbParam_t IValue) |
| SetValueReturnCode_e | TecUtilLineMapSetErrorBar (const char *Attribute, Set_pa LineMapSet, double DValue, ArbParam_t IValue) |
| Assign values to attributes for error bars in Line-plots. | |
| SetValueReturnCode_e | TecUtilXYMapSetIndices (const char *Attribute, const char *SubAttribute, Set_pa XYMapSet, ArbParam_t IValue) |
| SetValueReturnCode_e | TecUtilLineMapSetIndices (const char *Attribute, const char *SubAttribute, Set_pa LineMapSet, ArbParam_t IValue) |
| Assign values to attributes for index ranges in Line-plots. | |
| SetValueReturnCode_e | TecUtilPrintSetup (const char *Attribute, const char *SubAttribute, double DValue, ArbParam_t IValue) |
| Setup the attributes for printing. | |
| SetValueReturnCode_e | TecUtilExportSetup (const char *Attribute, const char *SubAttribute, double DValue, ArbParam_t IValue) |
| Set up all attributes related to exporting a plot. | |
| SetValueReturnCode_e | TecUtilFrameSetLinking (const char *Attribute, ArbParam_t IValue) |
| SetValueReturnCode_e | TecUtilLinkingSetValue (const char *Attribute, const char *SubAttribute, ArbParam_t IValue) |
| Convenience function for setting a frame linking attribute. | |
| void | TecUtilColorMapRefresh (void) |
| Refresh the current tecplot colormap. | |
| SetValueReturnCode_e | TecUtilColorMapSetBase (ContourColorMap_e BaseColorMap) |
| Convenience function used to set the color map in Tecplot to one of the base color map types. | |
| SetValueReturnCode_e | TecUtilSolutionTimeSetCurrent (double NewSolutionTime) |
| Sets the current solution time for the current frame. | |
| double TecUtil3DViewGetNearZPlane | ( | void | ) |
| Boolean_t TecUtilAnimateContourLevels | ( | SmInteger_t | StartLevel, | |
| SmInteger_t | EndLevel, | |||
| SmInteger_t | LevelSkip, | |||
| Boolean_t | CreateMovieFile, | |||
| const char * | MovieFName | |||
| ) |
Produce an animation of a contour line plot by showing a single level at a time.
The animation varies according to the currently defined contour levels.
| StartLevel | The starting contour level for the animation. | |
| EndLevel | The ending contour levels for the animation. | |
| LevelSkip | The level skip. | |
| CreateMovieFile | Set to TRUE to create a Raster Metafile of the animation. | |
| MovieFName | String specifying the file name for the movie file. This parameter is used only if CreateMovieFile is TRUE. |
INTEGER*4 FUNCTION TecUtilAnimateContourLevels( & StartLevel, & EndLevel, & LevelSkip, & CreateMovieFile, & MovieFName) INTEGER*4 StartLevel INTEGER*4 EndLevel INTEGER*4 LevelSkip INTEGER*4 CreateMovieFile CHARACTER*(*) MovieFName
Python Syntax:
Results = TecUtil.AnimateContourLevels(StartLevel, EndLevel, LevelSkip, CreateMovieFile, MovieFName)
Input:
StartLevel int
EndLevel int
LevelSkip int
CreateMovieFile boolean
MovieFName string
Output:
Results[0] ReturnVal boolean
Animate contour levels 1-10:
TecUtilAnimateContourLevels(1,10,1,FALSE,(char *)NULL);
| Boolean_t TecUtilAnimateContourLevelsX | ( | ArgList_pa | ArgList | ) |
Animate contour levels.
| ArgList | Set of Arglist entries. This is built using calls to TecUtilArgListAppendXXXX functions. Arglist Values SV_START
SV_END
SV_SKIP
SV_CREATEMOVIEFILE
SV_FNAME
SV_EXPORTFORMAT
SV_ANIMATIONSPEED
|
INTEGER*4 FUNCTION TecUtilAnimateContourLevelsX(ArgListPtr) POINTER (ArgListPtr, ArgList)
Python Syntax:
Results = TecUtil.AnimateContourLevelsX(ArgList)
Input:
ArgList dictionary
Output:
Results[0] ReturnVal boolean
Animate contour levels 1-10. Write the results to an AVI file named animc.avi.
ArgList_pa ArgList; TecUtilLockStart(AddOnID); ArgList = TecUtilArgListAlloc() TecUtilArgListAppendInt(ArgList, SV_EXPORTFORMAT, ExportFormat_AVI); TecUtilArgListAppendString(ArgList, SV_FNAME, "animc.avi"); TecUtilArgListAppendInt(ArgList, SV_START, 1); TecUtilArgListAppendInt(ArgList, SV_END, 10); TecUtilArgListAppendInt(ArgList, SV_CREATEMOVIEFILE, TRUE); IsOk = TecUtilAnimateContourLevelsX(ArgList); TecUtilArgListDealloc(&ArgList); TecUtilLockFinish(AddOnID);
| Boolean_t TecUtilAnimateIJKBlanking | ( | double | StartIMinFract, | |
| double | StartJMinFract, | |||
| double | StartKMinFract, | |||
| double | StartIMaxFract, | |||
| double | StartJMaxFract, | |||
| double | StartKMaxFract, | |||
| double | EndIMinFract, | |||
| double | EndJMinFract, | |||
| double | EndKMinFract, | |||
| double | EndIMaxFract, | |||
| double | EndJMaxFract, | |||
| double | EndKMaxFract, | |||
| int | NumSteps, | |||
| Boolean_t | CreateMovieFile, | |||
| const char * | MovieFName | |||
| ) |
Produce an animation of different IJK-blankings in your plot.
The animation starts at one IJK-blanking setting and marches through intermediate steps to a second setting.
| StartIMinFract | Min I-Index fraction for the start of the animation. For example, to start the animation with blanking in the I direction at I=20 when IMax is 200 set StartIMinFract to 0.10. | |
| StartJMinFract | Min J-Index fraction for the start of the animation. | |
| StartKMinFract | Min K-Index fraction for the start of the animation. | |
| StartIMaxFract | Max I-Index fraction for the start of the animation. For example, to start the animation with blanking in the I direction at I=20 when IMax is 200 set StartIMinFract to 0.10. | |
| StartJMaxFract | Max J-Index fraction for the start of the animation. | |
| StartKMaxFract | Max K-Index fraction for the start of the animation. | |
| EndIMinFract | Min I-Index fraction for the end of the animation. | |
| EndJMinFract | Min J-Index fraction for the end of the animation. | |
| EndKMinFract | Min K-Index fraction for the end of the animation. | |
| EndIMaxFract | Max I-Index fraction for the end of the animation. | |
| EndJMaxFract | Max J-Index fraction for the end of the animation. | |
| EndKMaxFract | Max K-Index fraction for the end of the animation. | |
| NumSteps | Number of steps or frames to create. The index blanking ranges are linearly interpolated based on the step and the Start and End fractions. | |
| CreateMovieFile | Set to TRUE if you want Tecplot to create a movie file. | |
| MovieFName | Name of the file to create if CreateMovieFile is TRUE. |
INTEGER*4 FUNCTION TecUtilAnimateIJKBlanking( & StartIMinFract, & StartJMinFract, & StartKMinFract, & StartIMaxFract, & StartJMaxFract, & StartKMaxFract, & EndIMinFract, & EndJMinFract, & EndKMinFract, & EndIMaxFract, & EndJMaxFract, & EndKMaxFract, & NumSteps, & CreateMovieFile, & MovieFName) REAL*8 StartIMinFract REAL*8 StartJMinFract REAL*8 StartKMinFract REAL*8 StartIMaxFract REAL*8 StartJMaxFract REAL*8 StartKMaxFract REAL*8 EndIMinFract REAL*8 EndJMinFract REAL*8 EndKMinFract REAL*8 EndIMaxFract REAL*8 EndJMaxFract REAL*8 EndKMaxFract INTEGER*4 NumSteps INTEGER*4 CreateMovieFile CHARACTER*(*) MovieFName
Python Syntax:
Results = TecUtil.AnimateIJKBlanking(StartIMinFract, StartJMinFract, StartKMinFract, StartIMaxFract, StartJMaxFract, StartKMaxFract, EndIMinFract, EndJMinFract, EndKMinFract, EndIMaxFract, EndJMaxFract, EndKMaxFract, NumSteps, CreateMovieFile, MovieFName)
Input:
StartIMinFract double
StartJMinFract double
StartKMinFract double
StartIMaxFract double
StartJMaxFract double
StartKMaxFract double
EndIMinFract double
EndJMinFract double
EndKMinFract double
EndIMaxFract double
EndJMaxFract double
EndKMaxFract double
NumSteps int
CreateMovieFile boolean
MovieFName string
Output:
Results[0] ReturnVal boolean
Produce an animation showing a band of I-planes traversing the entire data field using six steps:
TecUtilAnimateIJKBlanking(0.1,0.0,0.0, 1.0,1.0,1.0, 1.0,0.0,0.0, 1.0,1.0,1.0, 6, FALSE, (char *)NULL);
| Boolean_t TecUtilAnimateIJKBlankingX | ( | ArgList_pa | ArgList | ) |
Animate IJK-blanking.
| ArgList | Set of Arglist entries. This is built using calls to TecUtilArgListAppendXXXX functions. Arglist Values SV_IMINFRACT
SV_JMINFRACT
SV_KMINFRACT
SV_IMAXFRACT
SV_JMAXFRACT
SV_KMAXFRACT
SV_IMINFRACT2
SV_JMINFRACT2
SV_KMINFRACT2
SV_IMAXFRACT2
SV_JMAXFRACT2
SV_KMAXFRACT2
SV_NUMSTEPS
SV_CREATEMOVIEFILE
SV_FNAME
SV_EXPORTFORMAT
SV_ANIMATIONSPEED
|
INTEGER*4 FUNCTION TecUtilAnimateIJKBlankingX(ArgListPtr) POINTER (ArgListPtr, ArgList)
Python Syntax:
Results = TecUtil.AnimateIJKBlankingX(ArgList)
Input:
ArgList dictionary
Output:
Results[0] ReturnVal boolean
Animate IJK-blanking starting with fractions 0, 0.1, 0.1 (the defaults) for the minimum fractions, 1.0, 1.0, 1.0 for the maximum fractions. End with 0.7, 0.7, 0.7 for the minimum fractions and 0.75, 0.75, 0.75 for the maximum fractions. Do animation in ten steps.
ArgList_pa ArgList; TecUtilLockStart(AddOnID); ArgList = TecUtilArgListAlloc(); TecUtilArgListAppendInt(ArgList, SV_EXPORTFORMAT, ExportFormat_RM); TecUtilArgListAppendString(ArgList, SV_FNAME, "IJKBlanking.rm"); TecUtilArgListAppendDouble(ArgList, SV_IMAXFRACT, 1.0); TecUtilArgListAppendDouble(ArgList, SV_JMAXFRACT, 1.0); TecUtilArgListAppendDouble(ArgList, SV_KMAXFRACT, 1.0); TecUtilArgListAppendDouble(ArgList, SV_IMINFRACT2, 0.7); TecUtilArgListAppendDouble(ArgList, SV_JMINFRACT2, 0.7); TecUtilArgListAppendDouble(ArgList, SV_KMINFRACT2, 0.7); TecUtilArgListAppendDouble(ArgList, SV_IMAXFRACT2, 0.75); TecUtilArgListAppendDouble(ArgList, SV_JMAXFRACT2, 0.75); TecUtilArgListAppendDouble(ArgList, SV_KMAXFRACT2, 0.75); TecUtilArgListAppendInt(ArgList, SV_NUMSTEPS, 10); TecUtilArgListAppendInt(ArgList, SV_CREATEMOVIEFILE,TRUE); TecUtilAnimateIJKBlankingX(ArgList); TecUtilArgListDealloc(&ArgList); TecUtilLockFinish(AddOnID);
| Boolean_t TecUtilAnimateIJKPlanes | ( | char | IJOrK, | |
| LgIndex_t | StartIndex, | |||
| LgIndex_t | EndIndex, | |||
| LgIndex_t | IndexSkip, | |||
| Boolean_t | CreateMovieFile, | |||
| const char * | MovieFName | |||
| ) |
Produce an animation that cycles through I-, J-, or K-planes in an IJK-ordered data set.
| IJOrK | This can be set to `I', `J' or `K' | |
| StartIndex | The starting plane index for the animation. | |
| EndIndex | The ending plane index for the animation. | |
| IndexSkip | The plane index skip for the animation. | |
| CreateMovieFile | Set to TRUE if you want Tecplot to create a movie file. | |
| MovieFName | Name of the file to create if CreateMovieFile is TRUE. |
INTEGER*4 FUNCTION TecUtilAnimateIJKPlanes( & IJOrK, & StartIndex, & EndIndex, & IndexSkip, & CreateMovieFile, & MovieFName) CHARACTER*(*) IJOrK INTEGER*4 StartIndex INTEGER*4 EndIndex INTEGER*4 IndexSkip INTEGER*4 CreateMovieFile CHARACTER*(*) MovieFName
Python Syntax:
Results = TecUtil.AnimateIJKPlanes(IJOrK, StartIndex, EndIndex, IndexSkip, CreateMovieFile, MovieFName)
Input:
IJOrK int
StartIndex int
EndIndex int
IndexSkip int
CreateMovieFile boolean
MovieFName string
Output:
Results[0] ReturnVal boolean
Produce an animation that shows every other J-plane from J=1 to J=11:
TecUtilAnimateIJKPlanes('J', 1, // Start at J=1 11, // End at J=11 2, // Skip every other J-Plane FALSE, (char *)NULL);
| Boolean_t TecUtilAnimateIJKPlanesX | ( | ArgList_pa | ArgList | ) |
Animate I-, J-, or K-planes.
| ArgList | Set of Arglist entries. This is built using calls to TecUtilArgListAppendXXXX functions. Arglist Values SV_START
SV_END
SV_SKIP
SV_PLANES
SV_CREATEMOVIEFILE
SV_FNAME
SV_EXPORTFORMAT
SV_ANIMATIONSPEED
|
INTEGER*4 FUNCTION TecUtilAnimateIJKPlanesX(ArgListPtr) POINTER (ArgListPtr, ArgList)
Python Syntax:
Results = TecUtil.AnimateIJKPlanesX(ArgList)
Input:
ArgList dictionary
Output:
Results[0] ReturnVal boolean
Animate J-planes 5-10.
ArgList_pa ArgList; TecUtilLockStart(AddOnID); ArgList = TecUtilArgListAlloc(); TecUtilArgListAppendInt(ArgList, SV_EXPORTFORMAT, ExportFormat_AVI); TecUtilArgListAppendString(ArgList, SV_FNAME, "IJKPlanes.avi"); TecUtilArgListAppendInt(ArgList, SV_START, 5); TecUtilArgListAppendInt(ArgList, SV_END, 10); TecUtilArgListAppendInt(ArgList, SV_SKIP, 1); TecUtilArgListAppendInt(ArgList, SV_PLANES, (LgIndex_t)'J'); TecUtilArgListAppendInt(ArgList, SV_CREATEMOVIEFILE, TRUE); TecUtilAnimateIJKPlanesX(ArgList); TecUtilArgListDealloc(&ArgList); TecUtilLockFinish(AddOnID);
| Boolean_t TecUtilAnimateIsoSurfacesX | ( | ArgList_pa | ArgList | ) |
Animate iso-surfaces.
| ArgList | Set of Arglist entries. This is built using calls to TecUtilArgListAppendXXXX functions. Arglist Values SV_STARTVALUE
SV_ENDVALUE
SV_NUMSTEPS
SV_GROUP
SV_CREATEMOVIEFILE
SV_LIMITSCREENSPEED
SV_MAXSCREENSPEED
SV_FNAME
SV_EXPORTFORMAT
SV_ANIMATIONSPEED
|
INTEGER*4 FUNCTION TecUtilAnimateIsoSurfacesX(ArgListPtr) POINTER (ArgListPtr, ArgList)
Python Syntax:
Results = TecUtil.AnimateIsoSurfacesX(ArgList)
Input:
ArgList dictionary
Output:
Results[0] ReturnVal boolean
Make an animation with two cycles and ten steps per cycle. Create an AVI movie file.
ArgList_pa ArgList; TecUtilLockStart(AddOnID); ArgList = TecUtilArgListAlloc(); TecUtilArgListAppendInt(ArgList, SV_EXPORTFORMAT, ExportFormat_AVI); TecUtilArgListAppendString(ArgList, SV_FNAME, "Iso.avi"); TecUtilArgListAppendDouble(ArgList, SV_STARTVALUE, 0.1); TecUtilArgListAppendDouble(ArgList, SV_ENDVALUE, 2.9); TecUtilArgListAppendInt(ArgList, SV_NUMSTEPS, 20); TecUtilArgListAppendInt(ArgList, SV_GROUP, 1); TecUtilArgListAppendDouble(ArgList, SV_ANIMATIONSPEED, 15.3); TecUtilArgListAppendInt(ArgList, SV_CREATEMOVIEFILE, TRUE); TecUtilAnimateIsoSurfacesX(ArgList); TecUtilArgListDealloc(&ArgList); TecUtilLockFinish(AddOnID);
| Boolean_t TecUtilAnimateLineMapsX | ( | ArgList_pa | ArgList | ) |
Animate Line-mapping.
| ArgList | Set of Arglist entries. This is built using calls to TecUtilArgListAppendXXXX functions. Arglist Values SV_START
SV_END
SV_SKIP
SV_CREATEMOVIEFILE
SV_FNAME
SV_EXPORTFORMAT
SV_ANIMATIONSPEED
|
INTEGER*4 FUNCTION TecUtilAnimateLineMapsX(ArgListPtr) POINTER (ArgListPtr, ArgList)
Python Syntax:
Results = TecUtil.AnimateLineMapsX(ArgList)
Input:
ArgList dictionary
Output:
Results[0] ReturnVal boolean
Animate Line-maps 5-10. Write the results to an AVI file named Animxy.avi.
ArgList_pa ArgList; TecUtilLockStart(AddOnID); ArgList = TecUtilArgListAlloc(); TecUtilArgListAppendInt(ArgList, SV_EXPORTFORMAT, ExportFormat_AVI); TecUtilArgListAppendString(ArgList, SV_FNAME, "Animxy.avi"); TecUtilArgListAppendInt(ArgList, SV_START, 5); TecUtilArgListAppendInt(ArgList, SV_END, 10); TecUtilArgListAppendInt(ArgList, SV_CREATEMOVIEFILE, TRUE); IsOk = TecUtilAnimateLineMapsX(ArgList); TecUtilArgListDealloc(&ArgList); TecUtilLockFinish(AddOnID);
| Boolean_t TecUtilAnimateSlices | ( | SmInteger_t | StartSlice, | |
| SmInteger_t | EndSlice, | |||
| SmInteger_t | NumSlices, | |||
| Boolean_t | CreateMovieFile, | |||
| const char * | MovieFName | |||
| ) |
Animates the currently defined 3-D slices.
| StartSlice | Starting slice for the animation. Must be less than or equal to NumSlices. This is most often set to 1. | |
| EndSlice | Ending slice for the animation. EndSlice must be greator than or equal to StartSlice. | |
| NumSlices | The number of slices to distribute between the currently defined Slice 1 and Slice 2 locations. | |
| CreateMovieFile | Set to TRUE if you want Tecplot to create a movie file. | |
| MovieFName | Name of the file to create if CreateMovieFile is TRUE. |
INTEGER*4 FUNCTION TecUtilAnimateSlices( & StartSlice, & EndSlice, & NumSlices, & CreateMovieFile, & MovieFName) INTEGER*4 StartSlice INTEGER*4 EndSlice INTEGER*4 NumSlices INTEGER*4 CreateMovieFile CHARACTER*(*) MovieFName
Python Syntax:
Results = TecUtil.AnimateSlices(StartSlice, EndSlice, NumSlices, CreateMovieFile, MovieFName)
Input:
StartSlice int
EndSlice int
NumSlices int
CreateMovieFile boolean
MovieFName string
Output:
Results[0] ReturnVal boolean
Animate 50 slices, using the currently defined Slice 1 and Slice 2 positions as the beginning and end of the animation. Send the animation to a movie file.
SmInteger_t NumSlices = 50; TecUtilAnimateSlices(1, NumSlices, NumSlices, TRUE, "SliceAnimation.rm");
| Boolean_t TecUtilAnimateSlicesX | ( | ArgList_pa | ArgList | ) |
Animates slices.
| ArgList | Set of Arglist entries. This is built using calls to TecUtilArgListAppendXXXX functions. Arglist Values SV_START
SV_END
SV_NUMSLICES
SV_GROUP
SV_LIMITSCREENSPEED
SV_MAXSCREENSPEED
SV_CREATEMOVIEFILE
SV_FNAME
SV_EXPORTFORMAT
SV_ANIMATIONSPEED
|
INTEGER*4 FUNCTION TecUtilAnimateSlicesX(ArgListPtr) POINTER (ArgListPtr, ArgList)
Python Syntax:
Results = TecUtil.AnimateSlicesX(ArgList)
Input:
ArgList dictionary
Output:
Results[0] ReturnVal boolean
Animate 50 slices, using the currently defined Slice 1 and Slice 2 positions as the beginning and end of the animation. Send the animation to a movie file.
Boolean_t IsOk = TRUE; ArgList_pa ArgList; TecUtilLockStart(AddOnID); ArgList = TecUtilArgListAlloc(); TecUtilArgListAppendInt(ArgList, SV_EXPORTFORMAT, ExportFormat_AVI); TecUtilArgListAppendString(ArgList, SV_FNAME, "AnimateSlice.avi"); TecUtilArgListAppendInt(ArgList, SV_START, 1); TecUtilArgListAppendInt(ArgList, SV_END, 50); TecUtilArgListAppendInt(ArgList, SV_NUMSLICES, 50); TecUtilArgListAppendInt(ArgList, SV_GROUP, 1); TecUtilArgListAppendDouble(ArgList, SV_ANIMATIONSPEED, 15.3); TecUtilArgListAppendInt(ArgList, SV_CREATEMOVIEFILE, TRUE); IsOk = TecUtilAnimateSlicesX(ArgList); TecUtilArgListDealloc(&ArgList); TecUtilLockFinish(AddOnID);
| Boolean_t TecUtilAnimateStream | ( | int | NumStepsPerCycle, | |
| int | NumCycles, | |||
| Boolean_t | CreateMovieFile, | |||
| const char * | MovieFName | |||
| ) |
Produce an animation of stream markers or dashes, moving along the currently defined streamtrace paths.
| NumStepsPerCycle | This is the number of steps to take to complete one full cycle in time where one cycle is defined as the time it takes to complete one dash on and one dash off. The larger this number, the smoother and slower the animation. | |
| NumCycles | The number of cycles to complete during the animation. | |
| CreateMovieFile | Set to TRUE if you want Tecplot to create a movie file. | |
| MovieFName | Name of the file to create if CreateMovieFile is TRUE. |
INTEGER*4 FUNCTION TecUtilAnimateStream( & NumStepsPerCycle, & NumCycles, & CreateMovieFile, & MovieFName) INTEGER*4 NumStepsPerCycle INTEGER*4 NumCycles INTEGER*4 CreateMovieFile CHARACTER*(*) MovieFName
Python Syntax:
Results = TecUtil.AnimateStream(NumStepsPerCycle, NumCycles, CreateMovieFile, MovieFName)
Input:
NumStepsPerCycle int
NumCycles int
CreateMovieFile boolean
MovieFName string
Output:
Results[0] ReturnVal boolean
Animate streamtraces for three cycles with each cycle using 20 steps:
TecUtilAnimateStream(20,3,FALSE,(char *)NULL);
| Boolean_t TecUtilAnimateStreamX | ( | ArgList_pa | ArgList | ) |
Animate streamtraces.
| ArgList | Set of Arglist entries. This is built using calls to TecUtilArgListAppendXXXX functions. Arglist Values SV_NUMCYCLES
SV_STEPSPERCYCLE
SV_CREATEMOVIEFILE
SV_FNAME
SV_EXPORTFORMAT
SV_ANIMATIONSPEED
|
INTEGER*4 FUNCTION TecUtilAnimateStreamX(ArgListPtr) POINTER (ArgListPtr, ArgList)
Python Syntax:
Results = TecUtil.AnimateStreamX(ArgList)
Input:
ArgList dictionary
Output:
Results[0] ReturnVal boolean
Make an animation with two cycles and ten steps per cycle. Create an AVI movie file.
ArgList_pa ArgList; TecUtilLockStart(AddOnID); ArgList = TecUtilArgListAlloc(); TecUtilArgListAppendInt(ArgList, SV_EXPORTFORMAT, ExportFormat_AVI); TecUtilArgListAppendString(ArgList, SV_FNAME, "Stream.avi"); TecUtilArgListAppendInt(ArgList, SV_NUMCYCLES, 2); TecUtilArgListAppendInt(ArgList, SV_STEPSPERCYCLE, 10); TecUtilArgListAppendInt(ArgList, SV_CREATEMOVIEFILE, TRUE); TecUtilAnimateStreamX(ArgList); TecUtilArgListDealloc(&ArgList); TecUtilLockFinish(AddOnID);
| Boolean_t TecUtilAnimateTimeX | ( | ArgList_pa | ArgList | ) |
Animate Time.
| ArgList | Set of Arglist entries. This is built using calls to TecUtilArgListAppendXXXX functions. Arglist Values SV_STARTTIME
SV_ENDTIME
SV_SKIP
SV_CREATEMOVIEFILE
SV_LIMITSCREENSPEED
SV_MAXSCREENSPEED
SV_FNAME
SV_EXPORTFORMAT
SV_ANIMATIONSPEED
|
INTEGER*4 FUNCTION TecUtilAnimateIsoSurfacesX(ArgListPtr) POINTER (ArgListPtr, ArgList)
Python Syntax:
Results = TecUtil.AnimateTimeX(ArgList)
Input:
ArgList dictionary
Output:
Results[0] ReturnVal boolean
Make an animation with two cycles and ten steps per cycle. Create an AVI movie file.
ArgList_pa ArgList; TecUtilLockStart(AddOnID); ArgList = TecUtilArgListAlloc(); TecUtilArgListAppendInt(ArgList, SV_EXPORTFORMAT, ExportFormat_AVI); TecUtilArgListAppendString(ArgList, SV_FNAME, "Time.avi"); TecUtilArgListAppendDouble(ArgList, SV_STARTTIME , 0.1); TecUtilArgListAppendDouble(ArgList, SV_ENDTIME, 2.9); TecUtilArgListAppendInt(ArgList, SV_SKIP, 1); TecUtilArgListAppendDouble(ArgList, SV_ANIMATIONSPEED, 15.3); TecUtilArgListAppendInt(ArgList, SV_CREATEMOVIEFILE, TRUE); TecUtilAnimateTimeX(ArgList); TecUtilArgListDealloc(&ArgList); TecUtilLockFinish(AddOnID);
| Boolean_t TecUtilAnimateXYMaps | ( | EntIndex_t | StartMap, | |
| EntIndex_t | EndMap, | |||
| EntIndex_t | MapSkip, | |||
| Boolean_t | CreateMovieFile, | |||
| const char * | MovieFName | |||
| ) |
| Boolean_t TecUtilAnimateXYMapsX | ( | ArgList_pa | ArgList | ) |
| Boolean_t TecUtilAnimateZones | ( | EntIndex_t | StartZone, | |
| EntIndex_t | EndZone, | |||
| EntIndex_t | ZoneSkip, | |||
| Boolean_t | CreateMovieFile, | |||
| const char * | MovieFName | |||
| ) |
Produce an animation showing one zone at a time.
| StartZone | Starting zone for the animation. | |
| EndZone | Ending zone for the animation. | |
| ZoneSkip | Zone skip for the animation. | |
| CreateMovieFile | Set to TRUE if you want Tecplot to create a movie file. | |
| MovieFName | Name of the file to create if CreateMovieFile is TRUE. |
INTEGER*4 FUNCTION TecUtilAnimateZones( & StartZone, & EndZone, & ZoneSkip, & CreateMovieFile, & MovieFName) INTEGER*4 StartZone INTEGER*4 EndZone INTEGER*4 ZoneSkip INTEGER*4 CreateMovieFile CHARACTER*(*) MovieFName
Python Syntax:
Results = TecUtil.AnimateZones(StartZone, EndZone, ZoneSkip, CreateMovieFile, MovieFName)
Input:
StartZone int
EndZone int
ZoneSkip int
CreateMovieFile boolean
MovieFName string
Output:
Results[0] ReturnVal boolean
Create an animation showing (in sequence) zones 2, 4, 6, 8, and 10:
TecUtilAnimateZones(2, 10, 2, FALSE, NULL);
| Boolean_t TecUtilAnimateZonesX | ( | ArgList_pa | ArgList | ) |
Animate zones.
| ArgList | Set of Arglist entries. This is built using calls to TecUtilArgListAppendXXXX functions. Arglist Values SV_ZONEANIMATIONMODE
SV_START
SV_END
SV_SKIP
SV_CREATEMOVIEFILE
SV_FNAME
SV_EXPORTFORMAT
SV_ANIMATIONSPEED
|
INTEGER*4 FUNCTION TecUtilAnimateZonesX(ArgListPtr) POINTER (ArgListPtr, ArgList)
Python Syntax:
Results = TecUtil.AnimateZonesX(ArgList)
Input:
ArgList dictionary
Output:
Results[0] ReturnVal boolean
Animate zones 1-10. Write the results to an AVI file named Animzones.avi.
ArgList_pa ArgList; TecUtilLockStart(AddOnID); ArgList = TecUtilArgListAlloc(); TecUtilArgListAppendInt(ArgList, SV_EXPORTFORMAT, ExportFormat_AVI); TecUtilArgListAppendString(ArgList, SV_FNAME, "Animzones.avi"); TecUtilArgListAppendInt(ArgList, SV_START, 1); TecUtilArgListAppendInt(ArgList, SV_END, 10); TecUtilArgListAppendInt(ArgList, SV_CREATEMOVIEFILE, TRUE); IsOk = TecUtilAnimateZonesX(ArgList); TecUtilArgListDealloc(&ArgList); TecUtilLockFinish(AddOnID);
| Boolean_t TecUtilAutoRedrawIsActive | ( | void | ) |
Queries the auto redraw state.
INTEGER*4 FUNCTION TecUtilAutoRedrawIsActive()
Python Syntax:
Results = TecUtil.AutoRedrawIsActive()
Output:
Results[0] ReturnVal boolean
Query the auto redraw state.
{
Boolean_t AutoRedrawIsActive;
TecUtilLockStart(AddOnID);
AutoRedrawIsActive = TecUtilAutoRedrawIsActive();
TecUtilLockFinish(AddOnID);
}
| void TecUtilAxisGetRange | ( | char | Axis, | |
| short | AxisNum, | |||
| double * | AxisMin, | |||
| double * | AxisMax | |||
| ) |
Get the current minimum and maximum values for the specified axis.
| Axis | The axis to query. This can be one of `X', `Y' or `Z' | |
| AxisNum | The axis number. For XY-plots this can be any number from one to five. For all other plots this must be one. | |
| AxisMin | The current axis minimum value | |
| AxisMax | The current axis maximum value |
SUBROUTINE TecUtilAxisGetRange( & Axis, & AxisNum, & AxisMin, & AxisMax) CHARACTER*(*) Axis INTEGER*4 AxisNum REAL*8 AxisMin REAL*8 AxisMax
Python Syntax:
Results = TecUtil.AxisGetRange(Axis, AxisNum)
Input:
Axis int
AxisNum int
Output:
Results[0] AxisMin double
Results[1] AxisMax double
Get the range on Y-Axis number 2 (assume that it was previously determined that the frame mode is currently XY):
double YMin,YMax; TecUtilAxisGetRange('Y',2,&YMin,&YMax);
| Boolean_t TecUtilBlankingCheckDataPoint | ( | EntIndex_t | Zone, | |
| LgIndex_t | PointIndex | |||
| ) |
Determine if the specified data point in the specified zone is visible or if it is not drawn due to value-blanking or IJK-blanking.
| Zone | The number of the zone in which the PointIndex is located. | |
| PointIndex | The index of the point of interest. |
INTEGER*4 FUNCTION TecUtilBlankingCheckDataPoint( & Zone, & PointIndex) INTEGER*4 Zone INTEGER*4 PointIndex
Python Syntax:
Results = TecUtil.BlankingCheckDataPoint(Zone, PointIndex)
Input:
Zone int
PointIndex int
Output:
Results[0] ReturnVal boolean
Zone 4 is IJ-ordered and has IMax = 12, JMax = 8. Determine if the point (I=3, J=2) of zone 4 is visible:
Boolean_t IsVisible = TecUtilBlankingCheckDataPoint(4,(2-1)*8+3);
Zone 5 is finite-element. Determine if the point (N=17) of zone 5 is visible:
Boolean_t IsVisible = TecUtilBlankingCheckDataPoint(5, 17);
| Boolean_t TecUtilBlankingCheckFECell | ( | EntIndex_t | Zone, | |
| LgIndex_t | CellIndex | |||
| ) |
Determine if the specified element in the specified finite-element zone is visible or if it is not drawn due to value-blanking.
| Zone | The number of the zone in which the element is located. The zone must be finite-element. | |
| CellIndex | The index of the element of interest. |
INTEGER*4 FUNCTION TecUtilBlankingCheckFECell( & Zone, & CellIndex) INTEGER*4 Zone INTEGER*4 CellIndex
Python Syntax:
Results = TecUtil.BlankingCheckFECell(Zone, CellIndex)
Input:
Zone int
CellIndex int
Output:
Results[0] ReturnVal boolean
Zone 5 is finite-element. Determine if element number 13 of zone 5 is visible:
Boolean_t IsVisible = TecUtilBlankingCheckFECell(5, 13);
| Boolean_t TecUtilBlankingCheckIJKCell | ( | EntIndex_t | Zone, | |
| IJKPlanes_e | ZonePlane, | |||
| LgIndex_t | CellIndex | |||
| ) |
Determine if the specified cell in the specified IJK-ordered zone is visible or if it is not drawn due to value-blanking or IJK-blanking.
| Zone | The number of the zone in which the cell is located. The zone must be IJK-ordered. | |
| ZonePlane | The plane in which the cell resides. For I or IJ-ordered data, use Planes_K. For IJK-ordered data, this determines what to use to determine the cell. The possible values are: Planes_I, Planes_J, Planes_K, or Planes_Volume. | |
| CellIndex | The index of the cell of interest. |
INTEGER*4 FUNCTION TecUtilBlankingCheckIJKCell( & Zone, & ZonePlane, & CellIndex) INTEGER*4 Zone INTEGER*4 ZonePlane INTEGER*4 CellIndex
Python Syntax:
Results = TecUtil.BlankingCheckIJKCell(Zone, ZonePlane, CellIndex)
Input:
Zone int
ZonePlane IJKPlanes_e (defined in TecVals.py)
CellIndex int
Output:
Results[0] ReturnVal boolean
Zone 4 is IJ-ordered. Determine if cell 13 of zone 4 is visible:
Boolean_t IsVisible = TecUtilBlankingCheckIJKCell(4, Planes_K, 13);
| Boolean_t TecUtilColorMapCopyStandard | ( | ContourColorMap_e | ColorMap | ) |
Preset either the user-defined color map or the raw user-defined color map to be a copy of one of the standard color maps.
Tecplot must currently be using either the user-defined color map or the raw user-defined color map in order to use the function.
| ColorMap | Color map type to use as the source. The possible values are: ColorMap_SmRainbow, ColorMap_LgRainbow, ColorMap_Modern, ColorMap_GrayScale or ColorMap_TwoColor |
INTEGER*4 FUNCTION TecUtilColorMapCopyStandard(ColorMap) INTEGER*4 ColorMap
Python Syntax:
Results = TecUtil.ColorMapCopyStandard(ColorMap)
Input:
ColorMap ContourColorMap_e (defined in TecVals.py)
Output:
Results[0] ReturnVal boolean
Reset the user-defined color map to be a copy of the modern color map.
| void TecUtilColorMapGetBasicColorRGB | ( | ColorIndex_t | BasicColor, | |
| ColorIndex_t * | Red, | |||
| ColorIndex_t * | Green, | |||
| ColorIndex_t * | Blue | |||
| ) |
Get the RGB components of a basic color.
| BasicColor | Index of basic color to query. It is best to use the supplied constants in GLOBAL.h (e.g. Black_C, Red_C, Custom9_C). | |
| Red | Receives red component of the color. This parameter may be NULL. | |
| Green | Receives green component of the color. This parameter may be NULL. | |
| Blue | Receives blue component of the color. This parameter may be NULL |
SUBROUTINE TecUtilColorMapGetBasicColorRGB( & BasicColor, & Red, & Green, & Blue) INTEGER*4 BasicColor INTEGER*4 Red INTEGER*4 Green INTEGER*4 Blue
Python Syntax:
Results = TecUtil.ColorMapGetBasicColorRGB(BasicColor)
Input:
BasicColor TecVals color constant
Output:
Results[0] Red TecVals color constant
Results[1] Green TecVals color constant
Results[2] Blue TecVals color constant
Get the RGB components of the Custom2_C basic color.
{
Byte R,G,B;
TecUtilColorMapGetBasicColorRGB(Custom2_C,&R,&G,&B);
}
| LgIndex_t TecUtilColorMapNumBasicColors | ( | void | ) |
Get the number of basic colors in Tecplot.
INTEGER*4 FUNCTION TecUtilColorMapNumBasicColors()
Python Syntax:
Results = TecUtil.ColorMapNumBasicColors()
Output:
Results[0] ReturnVal int
Get the number of basic colors in Tecplot.
{
LgIndex_t NumBasicColors;
TecUtilLockStart(AddOnID);
NumBasicColors = TecUtilColorMapNumBasicColors();
TecUtilLockFinish(AddOnID);
}
| Boolean_t TecUtilColorMapRedistControlPts | ( | void | ) |
Redistribute the control points for the currently active color map so they are evenly spaced across the color spectrum.
This is equivalent to clicking Redistribute Control Points in the Workspace/Color Map dialog. Note that this does not change the RGB values assigned at each control point.
INTEGER*4 FUNCTION TecUtilColorMapRedistControlPts()
Python Syntax:
Results = TecUtil.ColorMapRedistControlPts()
Output:
Results[0] ReturnVal boolean
| void TecUtilColorMapRefresh | ( | void | ) |
Refresh the current tecplot colormap.
This must be called after setting basic color RGB values to apply the changes to the installed colormap.
SUBROUTINE TecUtilColorMapRefresh()
Python Syntax:
Results = TecUtil.ColorMapRefresh()
Output:
Results[0] ReturnVal NONE
Change the RGB values for basic color "Custom9" to be 85,50,99:
{
SetValueReturnCode_e SVRC;
ArgList_pa ArgList;
TecUtilLockStart(AddOnID);
ArgList = TecUtilArgListAlloc();
TecUtilArgListClear(ArgList);
TecUtilArgListAppendString(ArgList, SV_P1, SV_BASICCOLOR);
TecUtilArgListAppendString(ArgList, SV_P2, SV_CUSTOM9);
TecUtilArgListAppendString(ArgList, SV_P3, SV_R);
TecUtilArgListAppendArbParam(ArgList, SV_IVALUE, 85);
SVRC = TecUtilStyleSetLowLevelX(ArgList);
TecUtilArgListClear(ArgList);
TecUtilArgListAppendString(ArgList, SV_P1, SV_BASICCOLOR);
TecUtilArgListAppendString(ArgList, SV_P2, SV_CUSTOM9);
TecUtilArgListAppendString(ArgList, SV_P3, SV_G);
TecUtilArgListAppendArbParam(ArgList, SV_IVALUE, 50);
SVRC = TecUtilStyleSetLowLevelX(ArgList);
TecUtilArgListClear(ArgList);
TecUtilArgListAppendString(ArgList, SV_P1, SV_BASICCOLOR);
TecUtilArgListAppendString(ArgList, SV_P2, SV_CUSTOM9);
TecUtilArgListAppendString(ArgList, SV_P3, SV_B);
TecUtilArgListAppendArbParam(ArgList, SV_IVALUE, 99);
SVRC = TecUtilStyleSetLowLevelX(ArgList);
TecUtilColorMapRefresh();
TecUtilArgListDealloc(&ArgList);
}
| Boolean_t TecUtilColorMapResetToFactory | ( | void | ) |
Redistribute the control points and reset the RGB values for the currently active color map.
This is equivalent to clicking Reset on the Workspace/ColorMap dialog.
INTEGER*4 FUNCTION TecUtilColorMapResetToFactory()
Python Syntax:
Results = TecUtil.ColorMapResetToFactory()
Output:
Results[0] ReturnVal boolean
| SetValueReturnCode_e TecUtilColorMapSetBase | ( | ContourColorMap_e | BaseColorMap | ) |
Convenience function used to set the color map in Tecplot to one of the base color map types.
| BaseColorMap | Color map type to be set as the base for the global contour color map. The possible values are: ColorMap_SmRainbow, ColorMap_LgRainbow, ColorMap_Modern, ColorMap_GrayScale, ColorMap_Wild, ColorMap_UserDef, ColorMap_TwoColor or ColorMap_RawUserDef. |
INTEGER*4 FUNCTION TecUtilColorMapSetBase(BaseColorMap) INTEGER*4 BaseColorMap
Python Syntax:
Results = TecUtil.ColorMapSetBase(BaseColorMap)
Input:
BaseColorMap ContourColorMap_e (defined in TecVals.py)
Output:
Results[0] ReturnVal SetValueReturnCode_e (defined in TecVals.py)
To set the current Tecplot color map to be the large rainbow color map:
| Boolean_t TecUtilContourGetLevels | ( | SmInteger_t | ContourGroup, | |
| LgIndex_t * | NumLevels, | |||
| double ** | LevelValues | |||
| ) |
Gets the number of contour levels and contour level values currently defined for the specified contour group.
The LevelValues array must be deallocated by the addon using TecUtilArrayDealloc().
| ContourGroup | The contour group of interest and must be an integer between 1 and 4. | |
| NumLevels | Pointer to an LgIndex_t variable that will receive the current number of levels for the specified contour group. | |
| LevelValues | Pointer to a double pointer variable that will receive the allocated double array of level values or NULL if there are none |
INTEGER*4 FUNCTION TecUtilContourGetLevels( & ContourGroup, & NumLevels, & LevelValues) INTEGER*4 ContourGroup INTEGER*4 NumLevels REAL*8(*) LevelValues
Python Syntax:
This function is not supported in Python.
Fetch the number of contour levels for contour group 2:
Boolean_t IsOk; LgIndex_t NumLevels; double *LevelValues; TecUtilLockStart(AddOnID); IsOk = TecUtilContourGetLevels(2, &NumLevels, &LevelValues); if (IsOk) { if (NumLevels != 0) { LgIndex_t LIndex; printf("There are %d levels for contour group #2:\n", NumLevels); for (LIndex = 0; LIndex < NumLevels; LIndex++) printf(" %lg\n", LevelValues[LIndex]); TecUtilArrayDealloc((void **)&LevelValues); } else printf("No levels are specified for contour group #2\n"); } TecUtilLockFinish(AddOnID);
| Boolean_t TecUtilContourLabelDeleteAll | ( | void | ) |
| Boolean_t TecUtilContourLabelX | ( | ArgList_pa | ArgList | ) |
Manage contour line labels in your plot.
| ArgList | Set of Arglist entries. This is built using calls to TecUtilArgListAppendXXXX functions. |
| Type: | ContourLabelAction_e |
| Arg Function: | TecUtilArgListAppendInt() |
| Required: | Yes |
| Notes: | The possible values are: ContourLabelAction_Add and ContourLabelAction_DeleteAll |
| Type: | SmInteger_t |
| Arg Function: | TecUtilArgListAppendInt() |
| Default: | 1 |
| Required: | No |
| Notes: | Indicates which contour is affected. |
| Type: | double |
| Arg Function: | TecUtilArgListAppendDouble() |
| Default: | 0.0 |
| Required: | No |
| Notes: | This option is only applicable for SV_CONTOURLABELACTION set to ContourLabelAction_Add. |
| Type: | double |
| Arg Function: | TecUtilArgListAppendDouble() |
| Default: | 0.0 |
| Required: | No |
| Notes: | This option is only applicable for SV_CONTOURLABELACTION set to ContourLabelAction_Add. |
| Type: | double |
| Arg Function: | TecUtilArgListAppendDouble() |
| Default: | 0.0 |
| Required: | No |
| Notes: | This option is only applicable for SV_CONTOURLABELACTION set to ContourLabelAction_Add in a 3D plot. |
| Type: | Boolean_t |
| Arg Function: | TecUtilArgListAppendInt() |
| Default: | TRUE |
| Required: | No |
| Notes: | If TRUE the contour label is aligned along the contour line otherwise it is drawn horizontally. This option is only applicable for SV_CONTOURLABELACTION set to ContourLabelAction_Add. |
INTEGER*4 FUNCTION TecUtilContourLabelX(ArgListPtr) POINTER (ArgListPtr, ArgList)
Python Syntax:
Results = TecUtil.ContourLabelX(ArgList)
Input:
ArgList dictionary
Output:
Results[0] ReturnVal boolean
Add a contour label at position (0.5, 0.25) in a 2-D plot. Make it align itself to the nearest contour line.
ArgList_pa ArgList; TecUtilLockStart(AddOnID) ArgList = TecUtilArgListAlloc(); TecUtilArgListAppendInt(ArgList, SV_CONTOURLABELACTION, ContourLabelAction_Add); TecUtilArgListAppendDouble(ArgList, SV_X, 0.5); TecUtilArgListAppendDouble(ArgList, SV_Y, 0.25); TecUtilArgListAppendInt(ArgList, SV_ISALIGNED, TRUE); TecUtilContourLabelX(ArgList); TecUtilArgListDealloc(&ArgList); TecUtilLockFinish(AddOnID);
| Boolean_t TecUtilContourLevelAdd | ( | int | NumEntries, | |
| const double * | RawData_Array, | |||
| Boolean_t | ShowTrace | |||
| ) |
| Boolean_t TecUtilContourLevelNew | ( | int | NumEntries, | |
| const double * | RawData_Array, | |||
| Boolean_t | ShowTrace | |||
| ) |
| Boolean_t TecUtilContourLevelReset | ( | int | NumEntries | ) |
| Boolean_t TecUtilContourLevelX | ( | ArgList_pa | ArgList | ) |
Modify the contour levels.
| ArgList | Set of Arglist entries. This is built using calls to TecUtilArgListAppendXXXX functions. Arglist Values SV_CONTOURLEVELACTION
SV_CONTOURGROUP
SV_NUMVALUES
SV_APPROXNUMVALUES
SV_RAWDATA
SV_RANGEMIN
SV_RANGEMAX
|
SV_CONTOURLEVELACTION Description
------------------------------------------------------------------------
ContourLevelAction_Add Add a new set of contour levels to the existing
set of contour levels. You may specify the number
of the contour group being modified (SV_CONTOURGROUP)
and the number of contour levels being added
(SV_ NUMVALUES). You must specify the value of the
contour variable at each of the added levels
(SV_RAWDATA).
ContourLevelAction_New Replace the current set of contour levels with a
new set. You may specify the number of the
contour group being modified (SV_CONTOURGROUP) and
the number of contours levels in the new set
(SV_NUMVALUES). You must specify the value of the
contour variable at each of the new levels
(SV_RAWDATA).
ContourLevelAction_
DeleteRange Delete all contour levels between the specified
minimum and maximum values of the contour variable
(inclusive). You may specify the number of the
contour group being modified (SV_CONTOURGROUP),
the value of the contour variable at the minimum
end of the range (SV_RANGEMIN), and the value of
the contour variable at the maximum end of the
range (SV_RANGEMAX).
ContourLevelAction_Reset Reset the contour levels to a set of evenly
distributed values spanning the entire range of
the currently selected contouring variable. You may
specify the number of the contour group being
modified (SV_CONTOURGROUP) and the number of
contours levels in the new set (SV_NUMVALUES).
ContourLevelAction_
ResetToNice Reset the contour levels to a set of evenly
distributed values that approximately spans the
range of the currently selected contouring variable.
Exact range and number of levels will be adjusted
to make contour levels have "nice" values. You
may specify the number of the contour group being
modified (SV_CONTOURGROUP) and the approximate
number of contours levels in the new set
(SV_APPROXNUMVALUES).
ContourLevelAction_
DeleteNearest Delete the contour level with the value nearest
the supplied value. You may specify the number of
the contour group being modified (SV_CONTOURGROUP)
and the value of the contour variable to be deleted
(SV_RANGEMIN).
INTEGER*4 FUNCTION TecUtilContourLevelX(ArgListPtr) POINTER (ArgListPtr, ArgList)
Python Syntax:
Results = TecUtil.ContourLevelX(ArgList)
Input:
ArgList dictionary
Output:
Results[0] ReturnVal boolean
Add contour levels 0.1, 0.2, and 0.3 to the current set of contour levels for contour group 2:
Boolean_t IsOk = TRUE; ArgList_pa ArgList; double levels[3] = {0.1, 0.2, 0.3}; TecUtilLockStart(AddOnID); ArgList = TecUtilArgListAlloc(); TecUtilArgListAppendInt(ArgList, SV_CONTOURLEVELACTION, (LgIndex_t) ContourLevelAction_Add); TecUtilArgListAppendInt(ArgList, SV_CONTOURGROUP, 2); TecUtilArgListAppendInt(ArgList, SV_NUMVALUES, 3); TecUtilArgListAppendArray(ArgList, SV_RAWDATA, (void *)levels); IsOk = TecUtilContourLevelX(ArgList); TecUtilArgListDealloc(&ArgList); TecUtilLockFinish(AddOnID);
| SetValueReturnCode_e TecUtilContourSetVariable | ( | EntIndex_t | NewVariable | ) |
Assign which variable to use for contouring.
This function only operates on contour group 1. To operate on any contour group you must use TecUtilContourSetVariableX().
| NewVariable | Number of the variable to use. |
INTEGER*4 FUNCTION TecUtilContourSetVariable(NewVariable) INTEGER*4 NewVariable
Python Syntax:
Results = TecUtil.ContourSetVariable(NewVariable)
Input:
NewVariable int
Output:
Results[0] ReturnVal SetValueReturnCode_e (defined in TecVals.py)
To set the contour variable to be variable 3, use:
| SetValueReturnCode_e TecUtilContourSetVariableX | ( | ArgList_pa | ArgList | ) |
Assign which variable to use for contouring a specific contour group.
| ArgList | Set of Arglist entries. This is built using calls to TecUtilArgListAppendXXXX functions. Arglist Values SV_CONTOURGROUP
SV_VAR
|
INTEGER*4 FUNCTION TecUtilContourSetVariableX(ArgListPtr) POINTER (ArgListPtr, ArgList)
Python Syntax:
Results = TecUtil.ContourSetVariableX(ArgList)
Input:
ArgList dictionary
Output:
Results[0] ReturnVal SetValueReturnCode_e (defined in TecVals.py)
Set the contour variable of the second contour group to variable number 4:
TecUtilLockStart(AddOnID); ArgList = TecUtilArgListAlloc(); if (ArgList != NULL) { SetValueReturnCode_e SVRC; TecUtilArgListClear(ArgList); TecUtilArgListAppendInt(ArgList, SV_CONTOURGROUP, 2); TecUtilArgListAppendInt(ArgList, SV_VAR, 4); SVRC = TecUtilContourSetVariableX(ArgList); TecUtilArgListDealloc(&ArgList); } TecUtilLockFinish(AddOnID);
| void TecUtilConvert3DPositionToGrid | ( | double | XPosition, | |
| double | YPosition, | |||
| double | ZPosition, | |||
| double * | XGridPosition, | |||
| double * | YGridPosition, | |||
| double * | ZGridPosition | |||
| ) |
Converts from 3-D world coordinates to Tecplot's 3-D grid coordinates.
Note that these 3-D grid coordinates are only to be used for zoom and 2-D grid mode text and geometries in 3-D. Converted grid coordinates should be used immediately. This transformation may change in future versions of Tecplot. You must call TecUtilSetupTransformations() before calling this function, although TecUtilSetupTransformations() need only be called once for each sequence of calls to TecUtilConvert3DPositionToGrid().
| XPosition | X-position in world coordinates. | |
| YPosition | Y-position in world coordinates. | |
| ZPosition | Z-position in world coordinates. | |
| XGridPosition | Receives X-grid position. You may pass NULL for this parameter. | |
| YGridPosition | Receives Y-grid position. You may pass NULL for this parameter. | |
| ZGridPosition | Receives Z-grid position. You may pass NULL for this parameter. |
SUBROUTINE TecUtilConvert3DPositionToGrid( & XPosition, & YPosition, & ZPosition, & XGridPosition, & YGridPosition, & ZGridPosition) REAL*8 XPosition REAL*8 YPosition REAL*8 ZPosition REAL*8 XGridPosition REAL*8 YGridPosition REAL*8 ZGridPosition
Python Syntax:
Results = TecUtil.Convert3DPositionToGrid(XPosition, YPosition, ZPosition)
Input:
XPosition double
YPosition double
ZPosition double
Output:
Results[0] XGridPosition double
Results[1] YGridPosition double
Results[2] ZGridPosition double
Convert from 3-D world coordinates to Tecplot's 3-D grid coordinates.
{
double ZPlaneFloor;
double X,Y,Z;
TecUtilLockStart(AddOnID);
TecUtilSetupTransformations();
ZPlaneFloor = TecUtil3DViewGetNearZPlane();
TecUtilConvert3DPositionToGrid(1.0,1.0,ZPlaneFloor,&X,&Y,&Z);
TecUtilLockFinish(AddOnID);
}
| void TecUtilConvertGridTo3DPosition | ( | double | XGridPosition, | |
| double | YGridPosition, | |||
| double | ZGridPosition, | |||
| double * | XPosition, | |||
| double * | YPosition, | |||
| double * | ZPosition | |||
| ) |
Converts from Tecplot's 3-D "Grid" or view coordinates to world coordinates.
Note that these 3-D grid coordinates are taken from 2-D grid mode text and geometries when the frame is in a 3D view. This transformation may change in future versions of Tecplot. You must call TecUtilSetupTransformations() before calling this function, although TecUtilSetupTransformations() need only be called once for each sequence of calls to TecUtilConvertGridTo3DPosition().
| XGridPosition | X position in eye coordinates. | |
| YGridPosition | Y position in eye coordinates. | |
| ZGridPosition | Z position in eye coordinates. | |
| XPosition | Receives X position in world coordinates. You may pass NULL for this parameter. | |
| YPosition | Receives Y position in world coordinates. You may pass NULL for this parameter. | |
| ZPosition | Receives Z position in world coordinates. You may pass NULL for this parameter. |
SUBROUTINE TecUtilConvertGridTo3DPosition( & XGridPosition, & YGridPosition, & ZGridPosition, & XPosition, & YPosition, & ZPosition) REAL*8 XGridPosition REAL*8 YGridPosition REAL*8 ZGridPosition REAL*8 XPosition REAL*8 YPosition REAL*8 ZPosition
Python Syntax:
Results = TecUtil.ConvertGridTo3DPosition(XGridPosition, YGridPosition, ZGridPosition)
Input:
XGridPosition double
YGridPosition double
ZGridPosition double
Output:
Results[0] XPosition double
Results[1] YPosition double
Results[2] ZPosition double
Convert from Tecplot's 3-D eye (view) coordinates to 3-D world coordinates.
{
TecUtilLockStart(AddOnID);
Geom_ID GeomId = 0;
double xView = 0.0;
double yView = 0.0;
double zView = 0.0;
double xPos = 0.0;
double yPos = 0.0;
double zPos = 0.0;
TecUtilSetupTransformations();
for (GeomId = TecUtilGeomGetBase();
GeomId != TECUTILBADID;
GeomId = TecUtilGeomGetNext(GeomId))
{
TecUtilGeomGetAnchorPos(geomId, &xView, &yView, &zView);
TecUtilConvertGridTo3DPosition(xView, yView, zView, &xPos, &yPos, &zPos);
...
}
TecUtilLockFinish(AddOnID);
}
Convert from one measurement system to another.
| OldUnits | Units in which OldSize is measured. The possible values are: Units_Grid, Units_Frame, Units_Point, Units_Screen or Units_AxisPercentage. | |
| NewUnits | Unit space in which the return value is measured. The possible values are: Units_Grid, Units_Frame, Units_Point, Units_Screen or Units_AxisPercentage. | |
| OldSize | Size in the old measurement system. |
REAL*8 FUNCTION TecUtilConvertUnits( & OldUnits, & NewUnits, & OldSize) INTEGER*4 OldUnits INTEGER*4 NewUnits REAL*8 OldSize
Python Syntax:
Results = TecUtil.ConvertUnits(OldUnits, NewUnits, OldSize)
Input:
OldUnits Units_e (defined in TecVals.py)
NewUnits Units_e (defined in TecVals.py)
OldSize double
Output:
Results[0] ReturnVal double
To create a line with a line thickness of three points:
Geom_ID g; double frame_units; frame_units = TecUtilConvertUnits(Units_Point, Units_Frame, 3.); g = TecUtilGeom2DLineSegmentCreate(CoordSys_Frame, 5., 5., 95., 95.); TecUtilGeomSetLineThickness(g, frame_units)
| double TecUtilConvertXDimension | ( | CoordSys_e | OldCoordSys, | |
| CoordSys_e | NewCoordSys, | |||
| double | OldDimension | |||
| ) |
Convert the specified horizontal dimension from one coordinate system to another.
| OldCoordSys | Coordinate system in which OldDimension is measured. The possible values are: CoordSys_Grid, CoordSys_Frame, CoordSys_Paper, or CoordSys_Screen | |
| NewCoordSys | Coordinate system in which the return value is measured. The possible values are: CoordSys_Grid, CoordSys_Frame, CoordSys_Paper, or CoordSys_Screen | |
| OldDimension | Dimension to convert |
REAL*8 FUNCTION TecUtilConvertXDimension( & OldCoordSys, & NewCoordSys, & OldDimension) INTEGER*4 OldCoordSys INTEGER*4 NewCoordSys REAL*8 OldDimension
Python Syntax:
Results = TecUtil.ConvertXDimension(OldCoordSys, NewCoordSys, OldDimension)
Input:
OldCoordSys CoordSys_e (defined in TecVals.py)
NewCoordSys CoordSys_e (defined in TecVals.py)
OldDimension double
Output:
Results[0] ReturnVal double
Find the size of the current frame in screen pixels.
double X, Y, Width, Height; // get frame width and height in inches TecUtilFrameGetPosAndSize(&X,&Y, &Width, &Height); // convert width and height to screen coordinates (pixels) Width = TecUtilConvertXDimension(CoordSys_Paper, CoordSys_Screen, Width); Height = TecUtilConvertYDimension(CoordSys_Paper, CoordSys_Screen, Height);
| double TecUtilConvertXPosition | ( | CoordSys_e | OldCoordSys, | |
| CoordSys_e | NewCoordSys, | |||
| double | OldX | |||
| ) |
Convert the specified X-coordinate value from one coordinate system to another.
| OldCoordSys | The coordinate system in which OldX is currently defined. The possible values are: CoordSys_Grid, CoordSys_Frame, CoordSys_Paper, or CoordSys_Screen. | |
| NewCoordSys | The coordinate system into which to transform OldX. The possible values are: CoordSys_Grid, CoordSys_Frame, CoordSys_Paper, or CoordSys_Screen. | |
| OldX | The value to convert from one coordinate system to another |
REAL*8 FUNCTION TecUtilConvertXPosition( & OldCoordSys, & NewCoordSys, & OldX) INTEGER*4 OldCoordSys INTEGER*4 NewCoordSys REAL*8 OldX
Python Syntax:
Results = TecUtil.ConvertXPosition(OldCoordSys, NewCoordSys, OldX)
Input:
OldCoordSys CoordSys_e (defined in TecVals.py)
NewCoordSys CoordSys_e (defined in TecVals.py)
OldX double
Output:
Results[0] ReturnVal double
Determine the position on the paper of a text label. Assume the Text_ID has already been obtained (See TecUtilPickListXxx functions or TecUtilTextXxx functions for examples on how to obtain a Text_ID).
Text_ID TID; double XPos,YPos; double PaperXPos,PaperYPos; ... Text_ID obtained.... TecUtilTextGetXYPos(TID,&XPos,&YPos); PaperXPos = TecUtilConvertXPosition(TecUtilTextGetPositionCoordSys(TID), CoordSys_Paper, XPos); PaperYPos = TecUtilConvertYPosition(TecUtilTextGetPositionCoordSys(TID), CoordSys_Paper, YPos);
| double TecUtilConvertYDimension | ( | CoordSys_e | OldCoordSys, | |
| CoordSys_e | NewCoordSys, | |||
| double | OldDimension | |||
| ) |
Convert the specified vertical dimension from one coordinate system to another.
| OldCoordSys | Coordinate system in which OldDimension is measured. The possible values are: CoordSys_Grid, CoordSys_Frame, CoordSys_Paper, or CoordSys_Screen | |
| NewCoordSys | Coordinate system in which OldDimension is measured. The possible values are: CoordSys_Grid, CoordSys_Frame, CoordSys_Paper, or CoordSys_Screen | |
| OldDimension | Dimension to convert |
REAL*8 FUNCTION TecUtilConvertYDimension( & OldCoordSys, & NewCoordSys, & OldDimension) INTEGER*4 OldCoordSys INTEGER*4 NewCoordSys REAL*8 OldDimension
Python Syntax:
Results = TecUtil.ConvertYDimension(OldCoordSys, NewCoordSys, OldDimension)
Input:
OldCoordSys CoordSys_e (defined in TecVals.py)
NewCoordSys CoordSys_e (defined in TecVals.py)
OldDimension double
Output:
Results[0] ReturnVal double
Find the size of the current frame in screen pixels.
double X, Y, Width, Height; // get frame width and height in inches TecUtilFrameGetPosAndSize(&X,&Y, &Width, &Height); // convert width and height to screen coordinates (pixels) Width = TecUtilConvertXDimension(CoordSys_Paper, CoordSys_Screen, Width); Height = TecUtilConvertYDimension(CoordSys_Paper, CoordSys_Screen, Height);
| double TecUtilConvertYPosition | ( | CoordSys_e | OldCoordSys, | |
| CoordSys_e | NewCoordSys, | |||
| double | OldY | |||
| ) |
Convert the specified Y-coordinate value from one coordinate system to another.
| OldCoordSys | The coordinate system in which OldY is currently defined. The possible values are: CoordSys_Grid, CoordSys_Frame, CoordSys_Paper, or CoordSys_Screen | |
| NewCoordSys | The coordinate system into which to transform OldY. The possible values are: CoordSys_Grid, CoordSys_Frame, CoordSys_Paper, or CoordSys_Screen | |
| OldY | The value to convert from one coordinate system to another |
REAL*8 FUNCTION TecUtilConvertYPosition( & OldCoordSys, & NewCoordSys, & OldY) INTEGER*4 OldCoordSys INTEGER*4 NewCoordSys REAL*8 OldY
Python Syntax:
Results = TecUtil.ConvertYPosition(OldCoordSys, NewCoordSys, OldY)
Input:
OldCoordSys CoordSys_e (defined in TecVals.py)
NewCoordSys CoordSys_e (defined in TecVals.py)
OldY double
Output:
Results[0] ReturnVal double
Determine the position on the paper of a text label. Assume the Text_ID has already been obtained (See TecUtilPickListXxx functions or TecUtilTextXxx functions for examples on how to obtain a Text_ID).
Text_ID TID; double XPos,YPos; double PaperXPos,PaperYPos; ... Text_ID obtained.... TecUtilTextGetXYPos(TID,&XPos,&YPos); PaperXPos = TecUtilConvertXPosition(TecUtilTextGetPositionCoordSys(TID), CoordSys_Paper, XPos); PaperYPos = TecUtilConvertYPosition(TecUtilTextGetPositionCoordSys(TID), CoordSys_Paper, YPos);
| void TecUtilCreateSliceZoneShowTrace | ( | Boolean_t | DoShow | ) |
The translucent slicing plane) when preparing to extract. Typical use is to call with TRUE on launch of dialog used to extract arb slices and call with FALSE on dialog drop.
| DoShow | TRUE to allow arbitrary slice identifier. FALSE, otherwise. |
Results = TecUtil.CreateSliceZoneShowTrace(DoShow)
Input:
DoShow boolean
Output:
Results[0] ReturnVal NONE
Turn on or off all graphics drawing.
Updates to the work area, sidebar, menu, and status line are suspended unless un-suspended via a call to TecUtilWorkAreaSuspend(), TecUtilInterfaceSuspend() or TecUtilStatusSuspend().
| DoDrawing | TRUE to turn graphics drawing on, FALSE to turn off |
INTEGER*4 FUNCTION TecUtilDrawGraphics(DoDrawing) INTEGER*4 DoDrawing
Python Syntax:
Results = TecUtil.DrawGraphics(DoDrawing)
Input:
DoDrawing boolean
Output:
Results[0] ReturnVal boolean
| void TecUtilDynamicLabelRegisterCallback | ( | const char * | DynamicLabelName, | |
| DynamicLabelCallback_pf | DynamicLabelCallback, | |||
| ArbParam_t | ClientData | |||
| ) |
Registers a dynamic axis label provider callback.
| DynamicLabelName | Unique name given to the Callback. This name is used in the list of available Callback in SpecifyNumberFormat dialog. | |
| DynamicLabelCallback | A callback that will be called for the label string. | |
| ClientData | This can be any 32-bit value and will be passed to the timer callback. Typically this is a pointer to a structure |
SUBROUTINE TecUtilDynamicLabelRegisterCallback( & DynamicLabelName, & DynamicLabelCallback, & ClientData) CHARACTER*(*) DynamicLabelName POINTER (DynamicLabelCallback_pf, DynamicLabelCallback) POINTER (ClientDataPtr, ClientData)
Python Syntax:
This function is not supported in Python.
Export an image file from Tecplot.
See TecUtilExportSetup() for details on settup the exported image type, file name and so forth.
| Append | Append the image data. This can only be set to TRUE if the export format is a Raster Metafile or AVI. However, it is recommended that you use TecUtilExportStart(), TecUtilExportNextFrame(), and TecUtilExportFinish() for Raster Metafile and AVI formats. This value must be FALSE for all other formats. |
INTEGER*4 FUNCTION TecUtilExport(Append) INTEGER*4 Append
Python Syntax:
Results = TecUtil.Export(Append)
Input:
Append boolean
Output:
Results[0] ReturnVal boolean
| void TecUtilExportCancel | ( | void | ) |
Cancel a movie export which is in progress.
This function is only valid after you have called TecUtilExportStart() but before you have called TecUtilExportFinish(). It ensures that any resources used by the animation are properly released and that no partial files are created or left on the user's drive.
Fortran Syntax:
SUBROUTINE TecUtilExportCancel()
Python Syntax:
Results = TecUtil.ExportCancel()
Output:
Results[0] ReturnVal NONE
| Boolean_t TecUtilExportFinish | ( | void | ) |
This function assembles all of the exported animation frames into the final animation file.
Note that the final *.avi or *.rm file is not created until you call this function. This function will assert if there is no current animation.
INTEGER*4 FUNCTION TecUtilExportFinish()
Python Syntax:
Results = TecUtil.ExportFinish()
Output:
Results[0] ReturnVal boolean
| Boolean_t TecUtilExportIsRecording | ( | void | ) |
Checks to see if Tecplot is currently recording an animation.
Fortran Syntax:
INTEGER*4 FUNCTION TecUtilExportIsRecording()
Python Syntax:
Results = TecUtil.ExportIsRecording()
Output:
Results[0] ReturnVal boolean
| Boolean_t TecUtilExportNextFrame | ( | void | ) |
Export the next frame of a movie animation.
INTEGER*4 FUNCTION TecUtilExportNextFrame()
Python Syntax:
Results = TecUtil.ExportNextFrame()
Output:
Results[0] ReturnVal boolean
| SetValueReturnCode_e TecUtilExportSetup | ( | const char * | Attribute, | |
| const char * | SubAttribute, | |||
| double | DValue, | |||
| ArbParam_t | IValue | |||
| ) |
Set up all attributes related to exporting a plot.
Use TecUtilExport() to do the actual exporting. See the $!EXPORTSETUP macro command in Tecplot Reference Manual for more details on available options.
| Attribute | SubParameter of the $!EXPORTSETUP macro. See $!EXPORTSETUP in the Tecplot Reference Manual for more information. The posible values are listed in the Attribute column below, as well as whether the DValue or IValue parameter is used and what kind of information is expected in the DValue or IValue parameter: |
Attribute Assign To: Value Notes
--------------------------------------------------------
SV_EXPORTFNAME IValue string
SV_EXPORTFORMAT IValue ExportFormat_e
SV_MAKEROUGHDRAFT IValue Boolean_t
SV_PALETTE IValue Palette_e
SV_SUNRASTERFORMAT IValue SunRaster_e
SV_EXPORTREGION IValue ExportRegion_e
SV_EPSPREVIEWIMAGE IValue See SubAttribute
SV_GRAYSCALEDEPTH IValue SmInteger_t
SV_IMAGEWIDTH IValue ScreenDim_t
SV_CONVERTTO256COLORS IValue Boolean_t
SV_ANIMATIONSPEED DValue double
SV_USEMULTIPLECOLORTABLES IValue Boolean_t
SV_EXTRASORTFOR3DPLOTS IValue Boolean_t
SV_USESUPERSAMPLEANTIALIASING IValue Boolean_t
SV_SUPERSAMPLEFACTOR IValue SmInteger_t
SV_TIFFBYTEORDER IValue TIFFByteOrder_e
SV_JPEGENCODING IValue JPEGEncoding_e
SV_QUALITY DValue double
SV_FLASHIMAGETYPE IValue FlashImageType_e
SV_FLASHCOMPRESSIONTYPE IValue FlashCompressionType_e
SV_RESIZEFILTER IValue ImageResizeFilter_e
| SubAttribute | SubParameter of the $!EXPORTSETUP macro command. See $!EXPORTSETUP in the Tecplot Reference Manual for more information. Only used with an Attribute of SV_EPSPREVIEWIMAGE. If SubAttribute is not used, pass NULL. Available options are listed in the SubAttribute column below, as well as whether the DValue or IValue parameter is used and what kind of information is expected in the DValue or IValue parameter: For an Attribute of SV_EPSPREVIEWIMAGE the possible values are: |
Attribute Assign to: Value Notes
--------------------------------------------------------
SV_IMAGETYPE IValue EPSPreviewImage_e
SV_IMAGEWIDTH IValue Must be > 0
SV_IMAGEHEIGHT IValue Must be > 0
SV_GRAYSCALEDEPTH IValue Must be > 0
| DValue | If the Attribute/SubAttribute requires a double or float value pass it here. Otherwise, use 0.0. | |
| IValue | If the Attribute/SubAttribute requires a value other than double or float value (that is, an integer, enumerated type, boolean value, or a string), pass it here. Otherwise, use 0.0. Always typecast the IValue parameter to (ArbParam_t). |
INTEGER*4 FUNCTION TecUtilExportSetup( & Attribute, & SubAttribute, & DValue, & IValuePtr) CHARACTER*(*) Attribute CHARACTER*(*) SubAttribute REAL*8 DValue POINTER (IValuePtr, IValue)
Python Syntax:
Results = TecUtil.ExportSetup(Attribute, SubAttribute, DValue, IValue)
Input:
Attribute string
SubAttribute string
DValue double
IValue (depends on attribute)
Output:
Results[0] ReturnVal SetValueReturnCode_e (defined in TecVals.py)
Export an EPS file with a TIFF preview image to the file "file1.eps." Then, export a PostScript Image file with a 1.25 scale factor to the file "file1.ps."
TecUtilExportSetup(SV_EXPORTFNAME, NULL, 0.0, (ArbParam_t)"file1.eps"); TecUtilExportSetup(SV_EXPORTFORMAT, NULL, 0.0, (ArbParam_t)ExportFormat_EPS); TecUtilExportSetup(SV_EPSPREVIEWIMAGE, SV_IMAGETYPE, 0.0, (ArbParam_t)Image_TIFF); TecUtilExport(); TecUtilExportSetup(SV_EXPORTFNAME, NULL, 0.0, (ArbParam_t)"file1.ps"); TecUtilExportSetup(SV_EXPORTFORMAT, NULL, 0.0, (ArbParam_t)ExportFormat_PSImage); TecUtilExportSetup(SV_EXPORTSCALEFACTOR, NULL, 1.25, (ArbParam_t)0); TecUtilExport();
| Boolean_t TecUtilExportStart | ( | void | ) |
This functions starts a new animation and exports the first frame.
Use TecUtilExportIsRecording() to make sure an export session is not in progress before calling this function.
INTEGER*4 FUNCTION TecUtilExportStart()
Python Syntax:
Results = TecUtil.ExportStart()
Output:
Results[0] ReturnVal boolean
This example makes use of the following export functions:
TecUtilExportIsRecording()
TecUtilExportSetup()
TecUtilExportStart()
TecUtilExportCancel()
TecUtilExportNextFrame()
TecUtilExportFinish()
This example may be used as a template when creating an animation routine. { int ii; Boolean_t IsOk; TecUtilLockStart(AddOnID); // Make sure there is no current export session before starting a new one. if ( TecUtilExportIsRecording() ) { TecUtilDialogErrMsg("An export session is alread in progress."); IsOk = FALSE; } else { // Setup the export format and the file name. TecUtilExportSetup(SV_EXPORTFNAME, NULL, 0.0, (ArbParam_t)"export.avi"); TecUtilExportSetup(SV_EXPORTFORMAT, NULL, 0.0, (ArbParam_t)ExportFormat_AVI); // Start the export session. IsOk = TecUtilExportStart(); } if ( IsOk ) { for (ii=0; ii<4; ii++) { // Rotate the plot around the PSI axis by 5 degrees. IsOk = TecUtilViewRotate3D(RotateAxis_Psi, 5.0, 0.0, 0.0, 0.0, RotateOriginLocation_DefinedOrigin); // Export the new image. if ( IsOk ) { IsOk = TecUtilExportNextFrame(); } // If the rotation or the exporting of the next frame // was not sucessful, abandon the export session. if ( !IsOk ) { TecUtilExportCancel(); break; } } } // If everything was successful, finish the export session. if ( IsOk ) IsOk = TecUtilExportFinish(); if ( !IsOk ) TecUtilDialogErrMsg("Error exporting, file may not be complete."); TecUtilLockFinish(AddOnID); }
| Boolean_t TecUtilFieldLayerIsActive | ( | const char * | LayerShowFlag | ) |
Indicates if the field layer of interest is active or not.
| LayerShowFlag | The show flag for the field layer of interest. Possible values are:
SV_SHOWMESH
SV_SHOWCONTOUR
SV_SHOWVECTOR
SV_SHOWSCATTER
SV_SHOWSHADE
SV_SHOWEDGE
SV_USELIGHTINGEFFECT
SV_USETRANSLUCENCY
|
INTEGER*4 FUNCTION TecUtilFieldLayerIsActive(LayerShowFlag) CHARACTER*(*) LayerShowFlag
Python Syntax:
Results = TecUtil.FieldLayerIsActive(LayerShowFlag)
Input:
LayerShowFlag string
Output:
Results[0] ReturnVal boolean
Determine if the field's contour layer is on:
if (TecUtilFieldLayerIsActive(SV_SHOWCONTOUR)) { // do something with the field's contour level }
| SetValueReturnCode_e TecUtilFieldLayerSetIsActive | ( | const char * | LayerShowFlag, | |
| Boolean_t | TurnOnFieldLayer | |||
| ) |
Instructs Tecplot to turn the specified layer on or off.
| LayerShowFlag | The show flag for the field layer of interest. Possible values are:
SV_SHOWMESH
SV_SHOWCONTOUR
SV_SHOWVECTOR
SV_SHOWSCATTER
SV_SHOWSHADE
SV_SHOWEDGE
SV_USELIGHTINGEFFECT
SV_USETRANSLUCENCY
| |
| TurnOnFieldLayer | If TRUE, Tecplot will turn on the layer, otherwise it will turn the layer off |
INTEGER*4 FUNCTION TecUtilFieldLayerSetIsActive( & LayerShowFlag, & TurnOnFieldLayer) CHARACTER*(*) LayerShowFlag INTEGER*4 TurnOnFieldLayer
Python Syntax:
Results = TecUtil.FieldLayerSetIsActive(LayerShowFlag, TurnOnFieldLayer)
Input:
LayerShowFlag string
TurnOnFieldLayer boolean
Output:
Results[0] ReturnVal SetValueReturnCode_e (defined in TecVals.py)
Turn on the field's contour layer:
SetValueReturnCode_e SVRC; SVRC = TecUtilFieldLayerSetIsActive(SV_SHOWCONTOUR, TRUE);
Obtain the set of active Field-maps.
| ActiveFieldMaps | Receives the set of active Field-maps. You must call TecUtilSetDealloc() when you are through using the set. It must not be NULL. |
INTEGER*4 FUNCTION TecUtilFieldMapGetActive(ActiveFieldMapsPtr) POINTER (ActiveFieldMapsPtr, ActiveFieldMaps)
Python Syntax:
Results = TecUtil.FieldMapGetActive()
Output:
Results[0] ReturnVal boolean
Results[1] ActiveFieldMaps sequence of ints
Get the set of active Line-maps:
Set_pa s = NULL; if (TecUtiFieldMapGetActive(&s)) { // maps are now in s TecUtilSetDealloc(&s); }
| EntIndex_t TecUtilFieldMapGetCandidateZone | ( | EntIndex_t | FieldMap | ) |
Returns the number of the candidate zone for the fieldmap.
INTEGER*4 FUNCTION TecUtilFieldMapGetCandidateZone(FieldMap) INTEGER*4 FieldMap
Python Syntax:
Results = TecUtil.FieldMapGetCandidateZone(FieldMap)
Input:
FieldMap int
Output:
Results[0] ReturnVal int
| EntIndex_t TecUtilFieldMapGetCount | ( | void | ) |
Returns the number of Field-maps.
INTEGER*4 FUNCTION TecUtilFieldMapGetCount()
Python Syntax:
Results = TecUtil.FieldMapGetCount()
Output:
Results[0] ReturnVal int
| FieldMapMode_e TecUtilFieldMapGetMode | ( | EntIndex_t | FieldMap | ) |
Returns the mode of a fieldmap.
INTEGER*4 FUNCTION TecUtilFieldMapGetMode(FieldMap) INTEGER*4 FieldMap
Python Syntax:
Results = TecUtil.FieldMapGetMode(FieldMap)
Input:
FieldMap int
Output:
Results[0] ReturnVal FieldMapMode_e (defined in TecVals.py)
| Boolean_t TecUtilFieldMapHasFEZones | ( | EntIndex_t | FieldMap | ) |
Determines if the fieldmap contains any FE zones.
INTEGER*4 FUNCTION TecUtilFieldMapHasFEZones(FieldMap) INTEGER*4 FieldMap
Python Syntax:
Results = TecUtil.FieldMapHasFEZones(FieldMap)
Input:
FieldMap int
Output:
Results[0] ReturnVal boolean
| Boolean_t TecUtilFieldMapHasIJKOrderedZones | ( | EntIndex_t | FieldMap | ) |
Determines if the fieldmap contains any IJK ordered zones.
INTEGER*4 FUNCTION TecUtilFieldMapHasIJKOrderedZones(FieldMap) INTEGER*4 FieldMap
Python Syntax:
Results = TecUtil.FieldMapHasIJKOrderedZones(FieldMap)
Input:
FieldMap int
Output:
Results[0] ReturnVal boolean
| Boolean_t TecUtilFieldMapHasLinearZones | ( | EntIndex_t | FieldMap | ) |
Determines if the fieldmap contains any Linear zones.
INTEGER*4 FUNCTION TecUtilFieldMapHasLinearZones(FieldMap) INTEGER*4 FieldMap
Python Syntax:
Results = TecUtil.FieldMapHasLinearZones(FieldMap)
Input:
FieldMap int
Output:
Results[0] ReturnVal boolean
| Boolean_t TecUtilFieldMapHasOrderedZones | ( | EntIndex_t | FieldMap | ) |
Determines if the fieldmap contains any ordered zones.
INTEGER*4 FUNCTION TecUtilFieldMapHasOrderedZones(FieldMap) INTEGER*4 FieldMap
Python Syntax:
Results = TecUtil.FieldMapHasOrderedZones(FieldMap)
Input:
FieldMap int
Output:
Results[0] ReturnVal boolean
| Boolean_t TecUtilFieldMapHasSurfaceZones | ( | EntIndex_t | FieldMap | ) |
Determines if the fieldmap contains any Surface zones.
INTEGER*4 FUNCTION TecUtilFieldMapHasSurfaceZones(FieldMap) INTEGER*4 FieldMap
Python Syntax:
Results = TecUtil.FieldMapHasSurfaceZones(FieldMap)
Input:
FieldMap int
Output:
Results[0] ReturnVal boolean
| Boolean_t TecUtilFieldMapHasVolumeZones | ( | EntIndex_t | FieldMap | ) |
Determines if the fieldmap contains any Volume zones.
INTEGER*4 FUNCTION TecUtilFieldMapHasVolumeZones(FieldMap) INTEGER*4 FieldMap
Python Syntax:
Results = TecUtil.FieldMapHasVolumeZones(FieldMap)
Input:
FieldMap int
Output:
Results[0] ReturnVal boolean
| Boolean_t TecUtilFieldMapIsActive | ( | EntIndex_t | FieldMap | ) |
Determine if an Field-map is active.
| FieldMap | number of the field map. |
INTEGER*4 FUNCTION TecUtilFieldMapIsActive(FieldMap) INTEGER*4 FieldMap
Python Syntax:
Results = TecUtil.FieldMapIsActive(FieldMap)
Input:
FieldMap int
Output:
Results[0] ReturnVal boolean
| Boolean_t TecUtilFieldMapIsRelevant | ( | EntIndex_t | FieldMap | ) |
Determines if the fieldmap is relevant for the current time step.
INTEGER*4 FUNCTION TecUtilFieldMapIsRelevant(FieldMap) INTEGER*4 FieldMap
Python Syntax:
Results = TecUtil.FieldMapIsRelevant(FieldMap)
Input:
FieldMap int
Output:
Results[0] ReturnVal boolean
| SetValueReturnCode_e TecUtilFieldSetLayer | ( | const char * | LayerShowFlag, | |
| Boolean_t | TurnOnFieldLayer | |||
| ) |
| ArbParam_t TecUtilFieldStyleGetArbValue | ( | EntIndex_t | Zone, | |
| const char * | S1, | |||
| const char * | S2, | |||
| const char * | S3 | |||
| ) |
Queries a zone attribute.
You can use this function to query any plot attribute that is not a floating point value. To query a floating point plot attribute, use TecUtilFieldStyleGetDoubleValue().
| Zone | Zone number to query | |
| S1 | First parameter that defines the attribute to query. The parameters follow the same order that you would use when constructing a set value macro command. If a parameter is not used, then it must be NULL. If you are not sure of the possible values for an enumerated type, you can find the definitions in the Include/GLOBAL.h directory, below the Tecplot home directory. These parameters are actually strings, but you can use the supplied SV_ constants from the SV.h include file. Using the SV_ constants will help prevent misspellings and other errors. | |
| S2 | Second parameter that defines the attribute to query. See S1. | |
| S3 | Third parameter that defines the attribute to query. See S1. |
SUBROUTINE TecUtilFieldStyleGetArbValue( & Zone, & S1, & S2, & S3, & ResultPtr) INTEGER*4 Zone CHARACTER*(*) S1 CHARACTER*(*) S2 CHARACTER*(*) S3 POINTER (ResultPtr, Result)
Python Syntax:
This function is not supported in Python.
Query the mesh color for zone 2.
{
// Equivalent macro command to set the color is:
// $!FIELD [2] MESH {Color = ...}
ColorIndex_t MeshColor;
ArbParam_t Result;
TecUtilLockStart(AddOnID);
MeshColor = (ColorIndex_t)
TecUtilFieldStyleGetArbValue(2,SV_MESH,SV_COLOR,NULL);
TecUtilLockFinish(AddOnID);
}
| double TecUtilFieldStyleGetDoubleValue | ( | EntIndex_t | Zone, | |
| const char * | S1, | |||
| const char * | S2, | |||
| const char * | S3 | |||
| ) |
Queries a zone attribute.
You can use this function to query any plot attribute that is a floating point value. To query a non-floating point plot attribute, use TecUtilFieldStyleGetArbValue().
| Zone | Zone number to query. | |
| S1 | First parameter used to define the attribute to query. The parameters follow the same order that you would use when constructing the $!FIELD macro command. | |
| S2 | Second parameter used to define the attribute to query. See S1. | |
| S3 | Third parameter used to define the attribute to query. See S1. |
REAL*8 FUNCTION TecUtilFieldStyleGetDoubleValue( & Zone, & S1, & S2, & S3) INTEGER*4 Zone CHARACTER*(*) S1 CHARACTER*(*) S2 CHARACTER*(*) S3
Python Syntax:
Results = TecUtil.FieldStyleGetDoubleValue(Zone, S1, S2, S3)
Input:
Zone int
S1 string
S2 string
S3 string
Output:
Results[0] ReturnVal double
Query the mesh pattern length for for zone 2.
{
// Equivalent macro command to set the color is:
// $!FIELD [2] MESH {P ATTERNLENGTH = ... }
double MeshPatternLength;
TecUtilLockStart(AddOnID);
MeshPatternLength = TecUtilFieldStyleGetDoubleValue(2,SV_MESH,
SV_PATTERNLENGTH,NULL);
TecUtilLockFinish(AddOnID);
}
| Boolean_t TecUtilFrameCreateNew | ( | Boolean_t | UseSuppliedFrameSize, | |
| double | XPos, | |||
| double | YPos, | |||
| double | Width, | |||
| double | Height | |||
| ) |
Creates a new frame.
| UseSuppliedFrameSize | If set to TRUE, then XYPos, Width, and Height are used to position and size the new frame. Otherwise, the frame is created with the position and size of the factory default frame | |
| XPos | X-Position (in inches) of the frame relative to the left edge of the paper. The frame is anchored in its upper left corner. | |
| YPos | Y-Position (in inches) of the frame relative to the top edge of the paper. | |
| Width | Width of the frame in inches. | |
| Height | Height of the frame in inches. Note that the Y-direction is positive in the down direction on the paper |
INTEGER*4 FUNCTION TecUtilFrameCreateNew( & UseSuppliedFrameSize, & XPos, & YPos, & Width, & Height) INTEGER*4 UseSuppliedFrameSize REAL*8 XPos REAL*8 YPos REAL*8 Width REAL*8 Height
Python Syntax:
Results = TecUtil.FrameCreateNew(UseSuppliedFrameSize, XPos, YPos, Width, Height)
Input:
UseSuppliedFrameSize boolean
XPos double
YPos double
Width double
Height double
Output:
Results[0] ReturnVal boolean
Create two new frames:
// let Tecplot position the frame Boolean_t IsOk1 = TecUtilFrameCreateNew(FALSE,0,0,0,0); // use an absolute position Boolean_t IsOk2 = TecUtilFrameCreateNew(TRUE, 1,1,7,7);
| Boolean_t TecUtilFrameDeleteTop | ( | void | ) |
Delete the top (active) frame.
If there is only one frame when this is called, a new empty frame is automatically created after this command is executed. (Thus, you can never have a workspace without at least one frame.)
INTEGER*4 FUNCTION TecUtilFrameDeleteTop()
Python Syntax:
Results = TecUtil.FrameDeleteTop()
Output:
Results[0] ReturnVal boolean
| Boolean_t TecUtilFrameFitAllToPaper | ( | void | ) |
Resize all frames so that they fit inside the hardclip limits of the paper.
INTEGER*4 FUNCTION TecUtilFrameFitAllToPaper()
Python Syntax:
Results = TecUtil.FrameFitAllToPaper()
Output:
Results[0] ReturnVal boolean
| ColorIndex_t TecUtilFrameGetBackgroundColor | ( | void | ) |
This function gets the current background color of the frame.
INTEGER*4 FUNCTION TecUtilFrameGetBackgroundColor()
Python Syntax:
Results = TecUtil.FrameGetBackgroundColor()
Output:
Results[0] ReturnVal TecVals color constant
| int TecUtilFrameGetCount | ( | void | ) |
Get a count of the number of frames currently defined.
INTEGER*4 FUNCTION TecUtilFrameGetCount()
Python Syntax:
Results = TecUtil.FrameGetCount()
Output:
Results[0] ReturnVal int
| ArbParam_t TecUtilFrameGetLinking | ( | const char * | Attribute | ) |
| FrameMode_e TecUtilFrameGetMode | ( | void | ) |
| Boolean_t TecUtilFrameGetName | ( | char ** | Name | ) |
Get the name of the current frame.
| Name | Address of character string. Space for the new name will be allocated for you. You must later free the string by using TecUtilStringDealloc(). |
INTEGER*4 FUNCTION TecUtilFrameGetName( & Name, & NameLength) CHARACTER*(*) Name INTEGER*4 NameLength
Python Syntax:
Results = TecUtil.FrameGetName()
Output:
Results[0] ReturnVal boolean
Results[1] Name string
Get the name of the current frame:
char *name = NULL; if ( TecUtilFrameGetName(&name) ) { // do something TecUtilStringDealloc(&name); }
| PlotType_e TecUtilFrameGetPlotType | ( | void | ) |
Get the plot type of the current frame.
INTEGER*4 FUNCTION TecUtilFrameGetPlotType()
Python Syntax:
Results = TecUtil.FrameGetPlotType()
Output:
Results[0] ReturnVal PlotType_e (defined in TecVals.py)
Do something when the frame mode is XY Line:
if ( TecUtilFrameGetPlotType() == PlotType_XYLine ) { // do something }
| void TecUtilFrameGetPosAndSize | ( | double * | X, | |
| double * | Y, | |||
| double * | Width, | |||
| double * | Height | |||
| ) |
Get the position and size of a frame.
| X | Returned X-Coordinate for left hand side of the frame (in inches) relative to the left hand side of the paper. | |
| Y | Returned Y-Coordinate for top of the frame (in inches) relative to the top of the paper. | |
| Width | Width of the frame (in inches). | |
| Height | Height of the frame (in inches). |
SUBROUTINE TecUtilFrameGetPosAndSize( & X, & Y, & Width, & Height) REAL*8 X REAL*8 Y REAL*8 Width REAL*8 Height
Python Syntax:
Results = TecUtil.FrameGetPosAndSize()
Output:
Results[0] X double
Results[1] Y double
Results[2] Width double
Results[3] Height double
Get the current frame's position and size:
double x, y, width, height; TecUtilFrameGetPosAndSize(&x, &y, &width, &height);
| UniqueID_t TecUtilFrameGetUniqueID | ( | void | ) |
Gets a unique ID for a frame.
A unique ID is an integer that is unique to a frame. The frame can be compared to other frames or pushed or popped by this unique ID using TecUtilFramePopByUniqueID() and TecUtilFramePushByUniqueID().
INTEGER*4 FUNCTION TecUtilFrameGetUniqueID()
Python Syntax:
Results = TecUtil.FrameGetUniqueID()
Output:
Results[0] ReturnVal long
Push the current frame using a unique ID:
{
UniqueID_t ID;
TecUtilLockStart(AddOnID);
ID = TecUtilFrameGetUniqueID();
TecUtilFramePushByUniqueID(ID);
TecUtilLockFinish(AddOnID);
}
| void TecUtilFrameLightweightPopEnd | ( | void | ) |
Ends a sequence of lightweight frame pops.
See TecUtilLightweightPopStart() for more information on lightweight frame popping.
Fortran Syntax:
SUBROUTINE TecUtilFrameLightweightPopEnd()
Python Syntax:
Results = TecUtil.FrameLightweightPopEnd()
Output:
Results[0] ReturnVal NONE
Set the name of all frames to Hi Mom.
{
TecUtilLockStart(AddOnID);
TecUtilFrameLightweightPopStart();
do
{
TecUtilFrameSetName("Hi Mom");
} while ( TecUtilFrameLightweightPopNext() );
TecUtilFrameLightweightPopEnd();
// Don't redraw until TecUtilFrameLightweightPopEnd() is called
TecUtilRedraw(TRUE);
TecUtilLockFinish(AddOnID);
}
| Boolean_t TecUtilFrameLightweightPopNext | ( | void | ) |
Pop the next frame.
See TecUtilLightweightPopStart() for more information on lightweight frame popping.
INTEGER*4 FUNCTION TecUtilFrameLightweightPopNext()
Python Syntax:
Results = TecUtil.FrameLightweightPopNext()
Output:
Results[0] ReturnVal boolean
Set the name of all frames to Hi Mom.
{
TecUtilLockStart(AddOnID);
TecUtilFrameLightweightPopStart();
do
{
TecUtilFrameSetName("Hi Mom");
} while ( TecUtilFrameLightweightPopNext() );
TecUtilFrameLightweightPopEnd();
// Don't redraw until TecUtilFrameLightweightPopEnd() is called
TecUtilRedraw(TRUE);
TecUtilLockFinish(AddOnID);
}
| void TecUtilFrameLightweightPopStart | ( | void | ) |
Initialize lightweight frame pop.
Lightweight frame pops have much less overhead compared to TecUtilFramePop(), but you are more restricted in what you can do after each pop. Thus this function can be used when:
* Speed is important * You plan to cycle through and pop all of the frames * You will not do anything which will cause a redraw of the frame after the frame pop.
Call this function before calling TecUtilFrameLightweightPopNext().
Fortran Syntax:
SUBROUTINE TecUtilFrameLightweightPopStart()
Python Syntax:
Results = TecUtil.FrameLightweightPopStart()
Output:
Results[0] ReturnVal NONE
Set the name of all frames to Hi Mom.
{
TecUtilLockStart(AddOnID);
TecUtilFrameLightweightPopStart();
do
{
TecUtilFrameSetName("Hi Mom");
} while ( TecUtilFrameLightweightPopNext() );
TecUtilFrameLightweightPopEnd();
// Don't redraw until TecUtilFrameLightweightPopEnd() is called
TecUtilRedraw(TRUE);
TecUtilLockFinish(AddOnID);
}
| Boolean_t TecUtilFramePop | ( | int | FrameNum | ) |
Pop a frame to the top (that is, make it the active frame).
| FrameNum | Frame to be popped. Frames are numbered 1 to numframes with frame 1 drawn first and the highest numbered frame drawn last when RedrawAll is executed. See TecUtilFrameGetCount() to get the number of frames currently defined. |
INTEGER*4 FUNCTION TecUtilFramePop(FrameNum) INTEGER*4 FrameNum
Python Syntax:
Results = TecUtil.FramePop(FrameNum)
Input:
FrameNum int
Output:
Results[0] ReturnVal boolean
Pop the frame underneath the current frame assuming that there are at least two frames.
TecUtilFramePop(TecUtilFrameGetCount() - 1);
| Boolean_t TecUtilFramePopAtPosition | ( | double | X, | |
| double | Y | |||
| ) |
Pop the frame on top at a specified position on the paper.
| X | X-Coordinates to specify a position on the paper of the frame to be popped. X is in inches from the left edge of the paper. | |
| Y | Y-Coordinates to specify a position on the paper of the frame to be popped. Y is in inches from the top edge of the paper. |
INTEGER*4 FUNCTION TecUtilFramePopAtPosition( & X, & Y) REAL*8 X REAL*8 Y
Python Syntax:
Results = TecUtil.FramePopAtPosition(X, Y)
Input:
X double
Y double
Output:
Results[0] ReturnVal boolean
Pop the frame currently visible at one inch from the left, two inches from the right of the paper, and make that frame the current frame:
TecUtilFramePopAtPosition(1.0, 2.0);
| Boolean_t TecUtilFramePopByName | ( | const char * | Name | ) |
Pop a frame (specified by name) to the top.
| Name | Name of the frame to pop. Use TecUtilFrameGetName() to get the name of the current frame. |
INTEGER*4 FUNCTION TecUtilFramePopByName(Name) CHARACTER*(*) Name
Python Syntax:
Results = TecUtil.FramePopByName(Name)
Input:
Name string
Output:
Results[0] ReturnVal boolean
Pop the frame with the name "Frame 001", and make that frame the current frame:
TecUtilFramePopByName("Frame 001");
| Boolean_t TecUtilFramePopByUniqueID | ( | UniqueID_t | UniqueID | ) |
Pops a frame identified by a unique ID.
| UniqueID | Unique ID of the frame. |
INTEGER*4 FUNCTION TecUtilFramePopByUniqueID(UniqueID) INTEGER*4 UniqueID
Python Syntax:
Results = TecUtil.FramePopByUniqueID(UniqueID)
Input:
UniqueID long
Output:
Results[0] ReturnVal boolean
Pop the current frame using a unique id.
{
UniqueID_t id;
TecUtilLockStart(AddOnID);
id = TecUtilFrameGetUniqueID();
TecUtilFramePopByUniqueID(id);
TecUtilLockFinish(AddOnID);
}
| Boolean_t TecUtilFramePush | ( | int | FrameNum | ) |
Push a frame to the bottom of the frame stack.
In other words it is given the frame number 1 and therefore drawn first.
| FrameNum | Frame to be pushed. Frames are numbered 1 to numframes with frame 1 drawn first and the highest numbered frame drawn last when Redraw All is executed. See TecUtilFrameGetCount() to get the number of frames currently defined. |
INTEGER*4 FUNCTION TecUtilFramePush(FrameNum) INTEGER*4 FrameNum
Python Syntax:
Results = TecUtil.FramePush(FrameNum)
Input:
FrameNum int
Output:
Results[0] ReturnVal boolean
Assuming that there are at least two frames, push the frame underlying the top frame to the bottom of the frame stack.
TecUtilFramePush(TecUtilFrameGetCount() - 1);
| Boolean_t TecUtilFramePushByName | ( | const char * | Name | ) |
Push a frame (specified by name) to the bottom.
| Name | Name of the frame to push. Use TecUtilFrameGetName() to get the name of the current frame |
INTEGER*4 FUNCTION TecUtilFramePushByName(Name) CHARACTER*(*) Name
Python Syntax:
Results = TecUtil.FramePushByName(Name)
Input:
Name string
Output:
Results[0] ReturnVal boolean
Push the frame with the name "Frame 001" to the bottom, and make the frame under that frame the current frame:
TecUtilFramePushByName("Frame 001");
| Boolean_t TecUtilFramePushByUniqueID | ( | UniqueID_t | UniqueID | ) |
Pushes a frame identified by a unique ID.
| UniqueID | Unique ID of the frame. |
INTEGER*4 FUNCTION TecUtilFramePushByUniqueID(UniqueID) INTEGER*4 UniqueID
Python Syntax:
Results = TecUtil.FramePushByUniqueID(UniqueID)
Input:
UniqueID long
Output:
Results[0] ReturnVal boolean
Push the current frame using a unique id
{
UniqueID_t id;
TecUtilLockStart(AddOnID);
id = TecUtilFrameGetUniqueID();
TecUtilFramePushByUniqueID(id);
TecUtilLockFinish(AddOnID);
}
| Boolean_t TecUtilFramePushTop | ( | void | ) |
Push the top (active) frame to the bottom.
INTEGER*4 FUNCTION TecUtilFramePushTop()
Python Syntax:
Results = TecUtil.FramePushTop()
Output:
Results[0] ReturnVal boolean
| SetValueReturnCode_e TecUtilFrameSetLinking | ( | const char * | Attribute, | |
| ArbParam_t | IValue | |||
| ) |
| SetValueReturnCode_e TecUtilFrameSetMode | ( | FrameMode_e | NewFrameMode | ) |
| SetValueReturnCode_e TecUtilFrameSetName | ( | const char * | Name | ) |
Set the name for the current frame.
| Name | Name to assign to the current frame. |
INTEGER*4 FUNCTION TecUtilFrameSetName(Name) CHARACTER*(*) Name
Python Syntax:
Results = TecUtil.FrameSetName(Name)
Input:
Name string
Output:
Results[0] ReturnVal SetValueReturnCode_e (defined in TecVals.py)
Rename the current frame to be "XY-plot #1":
TecUtilFrameSetName("XY-plot #1");
| SetValueReturnCode_e TecUtilFrameSetPlotType | ( | PlotType_e | NewPlotType | ) |
Set the current frame's plot type.
| NewPlotType | Plot type to switch to. The possible values are: PlotType_Cartesian3D, PlotType_Cartesian2D, PlotType_XYLine, PlotType_PolarLine, or PlotType_Sketch |
INTEGER*4 FUNCTION TecUtilFrameSetPlotType(NewPlotType) INTEGER*4 NewPlotType
Python Syntax:
Results = TecUtil.FrameSetPlotType(NewPlotType)
Input:
NewPlotType PlotType_e (defined in TecVals.py)
Output:
Results[0] ReturnVal SetValueReturnCode_e (defined in TecVals.py)
Set the current frame's plot type to be Cartesian 3D:
| SetValueReturnCode_e TecUtilFrameSetPosAndSize | ( | double | X, | |
| double | Y, | |||
| double | Width, | |||
| double | Height | |||
| ) |
Sets the position and size of the current frame.
| X | X-Coordinate for the upper left-hand corner of the frame in inches relative to the upper left-hand corner of the paper | |
| Y | Y-Coordinate for the upper left-hand corner of the frame in inches relative to the upper left-hand corner of the paper | |
| Width | Width of the frame in inches. | |
| Height | Height of the frame in inches. |
INTEGER*4 FUNCTION TecUtilFrameSetPosAndSize( & X, & Y, & Width, & Height) REAL*8 X REAL*8 Y REAL*8 Width REAL*8 Height
Python Syntax:
Results = TecUtil.FrameSetPosAndSize(X, Y, Width, Height)
Input:
X double
Y double
Width double
Height double
Output:
Results[0] ReturnVal SetValueReturnCode_e (defined in TecVals.py)
Set the frame's position and size:
TecUtilFrameSetPosAndSize(1.0,1.0,3.0,3.0);
| 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.
| 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. |
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.
| 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 |
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.
| 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 |
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.
| 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 |
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.
| 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 |
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().
| 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. |
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);
Get a point (X,Y) of a 2-D polyline.
| 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 |
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);
Set a point (X,Y) of a 2-D polyline.
| 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 |
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.
| 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. |
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);
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.
| 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. |
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.
| 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 |
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.
| 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 |
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.
| 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 |
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.
| 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 |
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.
| 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 |
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.
| 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 |
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.
| 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. |
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.
| GID | ID of the geometry. This must be a polyline or a multi-polyline geometry |
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.
| GID | ID of the geometry. This must be a polyline or a multi-polyline geometry |
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.
| GID | ID of the geometry. This must be a polyline or a multi-polyline geometry |
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.
| GID | ID of the geometry. This must be a polyline or a multi-polyline geometry |
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.
| GID | ID of the geometry. This must be a polyline or a multi-polyline geometry | |
| ArrowheadAngle | Angle for the arrowhead measured in degrees |
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, ArrowheadAttach_AtEnd); TecUtilGeomArrowheadSetAngle(g, 15.);
| void TecUtilGeomArrowheadSetAttach | ( | Geom_ID | GID, | |
| ArrowheadAttachment_e | ArrowheadAttachment | |||
| ) |
Set the arrowhead attachment for a geometry.
| GID | ID of the geometry. This must be a polyline or a multi-polyline geometry | |
| ArrowheadAttachment | The arrowhead attachment style. The possible values are: ArrowheadAttach_None ArrowheadAttach_AtBeginning ArrowheadAttach_AtEnd ArrowheadAttach_AtBothEnds |
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, ArrowheadAttach_AtBothEnds);
| void TecUtilGeomArrowheadSetSize | ( | Geom_ID | GID, | |
| double | ArrowheadSize | |||
| ) |
Set the arrowhead size for a geometry.
| GID | ID of the geometry. This must be a polyline or a multi-polyline geometry | |
| ArrowheadSize | The arrowhead size in frame units |
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, ArrowheadAttach_AtEnd); TecUtilGeomArrowheadSetSize(g, 10.);
| void TecUtilGeomArrowheadSetStyle | ( | Geom_ID | GID, | |
| ArrowheadStyle_e | ArrowheadStyle | |||
| ) |
Set the arrowhead style for a geometry.
| GID | ID of the geometry. This must be a polyline or a multi-polyline geometry | |
| ArrowheadStyle | The arrowhead style. The possible values are: Arrowhead_Plain, Arrowhead_Filled or Arrowhead_Hollow. |
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, ArrowheadAttach_AtEnd); TecUtilGeomArrowheadSetStyle(g, Arrowhead_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().
| 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 |
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.
| GID | Geometry ID. This must be a circle geometry |
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.
| GID | Geometry ID. This must be a circle geometry | |
| Radius | New radius of the circle. This must be non-zero |
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.
| GID | Handle to a geometry object |
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.
| 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 |
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.
| GID | ID of a geometry. This must be a circle or ellipse geometry |
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.
| 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 |
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.
| 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 |
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.
| 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 |
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.
| 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 |
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.
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.
| GID | ID of a geometry. |
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.
| GID | ID of a geometry. |
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.
| GID | ID of a geometry. |
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.
| GID | ID of a geometry. |
INTEGER*4 FUNCTION TecUtilGeomGetFillColor(GIDPtr) POINTER(GIDPtr, GID)
Python Syntax:
Results = TecUtil.GeomGetFillColor(GID)
Input:
GID long
Output:
Results[0] ReturnVal TecVals color constant
Determine if a geometry if filled.
| GID | ID of a geometry. |
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.
| GID | ID of a geometry. This must be a circle or ellipse geometry |
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.
| GID | ID of a geometry. |
REAL*8 FUNCTION TecUtilGeomGetLineThickness(GIDPtr) POINTER(GIDPtr, GID)
Python Syntax:
Results = TecUtil.GeomGetLineThickness(GID)
Input:
GID long
Output:
Results[0] ReturnVal double
Get the geometry macro function command.
| 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 |
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
Get the next geometry in the list of geometries attached to the current frame.
| GID | ID of a geometry. |
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.
| GID | ID of a geometry. |
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.
| GID | ID of a geometry. |
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)
Get the previous geometry in the list of geometries attached to the current frame.
| GID | ID of a geometry. |
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));
Get the geometry scope.
| GID | ID of a geometry. |
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.
| GID | ID of a geometry. |
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 | |||
| ) |
| 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.
| GID | ID of a geometry. |
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.
| 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(). |
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.
| 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 |
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.
| GID | Geometry ID. Must be an image geometry |
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.
| 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. |
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);
Queries the state of the "preserve aspect ratio" toggle for an image geometry.
| GID | Geometry ID. Must be an image geometry |
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.
| GID | Geometry ID. Must be an image geometry |
SUBROUTINE TecUtilGeomImageResetAspectRati(GIDPtr)
POINTER(GIDPtr, GID)
Python Syntax:
Results = TecUtil.GeomImageResetAspectRatio(GID)
Input:
GID long
Output:
Results[0] ReturnVal NONE
| 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.
| 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 |
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.
| GID | Geometry ID. Must be an image geometry | |
| ResizeFilter | Resize filter. See ImageResizeFilter_e. |
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:
Queries the state of the "preserve aspect ratio" toggle for an image geometry.
| GID | Geometry ID. Must be an image geometry | |
| MaintainAspectRatio | TRUE to preserve the aspect ratio when drawing an image geometry |
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.
| GID | Geometry ID. Must be an image geometry | |
| Width | New width of the geometry. Must be greater than 0.0 |
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);
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.
| GID | Geometry ID. Must be an image geometry |
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);
Validate a geometry ID.
| GID | Geometry ID. |
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);
Get information about the number of points in a polyline of a multi-polyline geometry.
| GID | Geometry ID. Must be a multi-polyline geometry | |
| PolyNum | Polyline of the multi-polyline geometry (starts at one) |
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);
Get the number of polylines in a multi-polyline geometry.
| GID | Geometry ID. Must be a multi-polyline geometry |
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);
Get the number of points in a polyline geometry.
| GID | Geometry ID. Must be a multi-polyline geometry |
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.
| 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. |
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.
| 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 |
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.
| 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 |
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.
| 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) |
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();
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.
| GID | Id of the geometry. | |
| Attached | TRUE to attach the geometry to a zone or an Line-mapping. |
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.
| GID | ID of the geometry | |
| Clipping | New clipping property for the geometry. The possible values are: Clipping_ClipToViewport and Clipping_ClipToFrame |
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.
| 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. |
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.
| GID | ID of the geometry | |
| DrawOrder | Must be DrawOrder_BeforeData or DrawOrder_AfterData. |
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.
| 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 |
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);
Set whether or not a geometry is filled with a color.
Use TecUtilGeomSetFillColor() to specify the actual color to fill the geometry with.
| GID | ID of a geometry | |
| IsFilled | TRUE to fill the geometry, FALSE to not fill. |
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.
| 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 |
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.
| GID | ID of a geometry | |
| LineThickness | Thickness of the lines in frame units |
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.);
Set the macro function command for a geometry.
| 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 |
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.
| GID | ID of a geometry | |
| PatternLength | Length of the line pattern in frame units. |
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.
| 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 |
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);
Set the scope for a geometry.
| 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). |
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 | |||
| ) |
| 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.
| GID | ID of a geometry | |
| ZoneOrMap | Zone number or mapping number to which the geometry should be attached |
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.
| 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 |
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.
| GID | Geometry ID. Must be a square geometry. |
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.
| GID | Geometry ID. Must be a square geometry. | |
| Size | New size of the square. Must be non-zero. |
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);
| LgIndex_t TecUtilLimitGetValue | ( | const char * | LimitString | ) |
Convenience function to query Tecplot for a limit value.
These are the same integer values you can set using the $!LIMITS command in the Tecplot macro language.
| LimitString | This must be one of the following: MaxPtsInALine, MaxChrsInTextLabels, MaxNumContourLevels, MaxPreplotZones, IPCTimeoutSeconds, MaxThreads, MaxAvailableProcessors, MaxUsableMemory, PreloadDataTimeThresholdInMS. |
INTEGER*4 FUNCTION TecUtilLimitGetValue(LimitString) CHARACTER*(*) LimitString
Python Syntax:
Results = TecUtil.LimitGetValue(LimitString)
Input:
LimitString string
Output:
Results[0] ReturnVal int
Get the number of points allowed per polyline in Tecplot:
LgIndex_t MaxPtsPerLine; MaxPtsPerLine = TecUtilLimitGetValue("MaxPtsInALine");
| Boolean_t TecUtilLineMapCopy | ( | EntIndex_t | SourceMap, | |
| EntIndex_t | DestMap | |||
| ) |
Copy attributes from an existing Line-mapping to another.
| SourceMap | Existing Line-map to copy. Must be greater than or equal to one and less than or equal to the current number of maps | |
| DestMap | Destination map. Must be greater than or equal to one and less than or equal to the current number of maps plus one |
INTEGER*4 FUNCTION TecUtilLineMapCopy( & SourceMap, & DestMap) INTEGER*4 SourceMap INTEGER*4 DestMap
Python Syntax:
Results = TecUtil.LineMapCopy(SourceMap, DestMap)
Input:
SourceMap int
DestMap int
Output:
Results[0] ReturnVal boolean
Duplicate the first Line-map:
Boolean_t IsOk = TecUtilLineMapCopy(1,2); if (!IsOk) { // function NOT successful }
| Boolean_t TecUtilLineMapCreate | ( | void | ) |
Create a new Line-mapping.
INTEGER*4 FUNCTION TecUtilLineMapCreate()
Python Syntax:
Results = TecUtil.LineMapCreate()
Output:
Results[0] ReturnVal boolean
Delete one or more Line-maps.
| MapsToDelete | Set of maps to delete |
INTEGER*4 FUNCTION TecUtilLineMapDelete(MapsToDeletePtr) POINTER (MapsToDeletePtr, MapsToDelete)
Python Syntax:
Results = TecUtil.LineMapDelete(MapsToDelete)
Input:
MapsToDelete sequence of ints
Output:
Results[0] ReturnVal boolean
Delete maps 1 and 3:
Set_pa set = TecUtilSetAlloc(FALSE); if (set) { TecUtilSetAddMember(set,1,TRUE); TecUtilSetAddMember(set,3,TRUE); TecUtilLineMapDelete(set); TecUtilSetDealloc(&set); }
Obtain the set of active Line-maps.
| ActiveLineMaps | Receives the set of active Line-maps. You must call TecUtilSetDealloc() when you are through using the set. It must not be NULL. |
INTEGER*4 FUNCTION TecUtilLineMapGetActive(ActiveLineMapsPtr) POINTER (ActiveLineMapsPtr, ActiveLineMaps)
Python Syntax:
Results = TecUtil.LineMapGetActive()
Output:
Results[0] ReturnVal boolean
Results[1] ActiveLineMaps sequence of ints
Get the set of active Line-maps:
Set_pa s = NULL; if (TecUtilLineMapGetActive(&s)) { // maps are now in s TecUtilSetDealloc(&s); }
| void TecUtilLineMapGetAssignment | ( | EntIndex_t | LineMap, | |
| EntIndex_t * | Zone, | |||
| EntIndex_t * | XOrThetaVar, | |||
| EntIndex_t * | YOrRVar, | |||
| SmInteger_t * | XAxis, | |||
| SmInteger_t * | YAxis, | |||
| FunctionDependency_e * | FunctionDependency | |||
| ) |
Get the assignment information for a given Line-map.
| LineMap | Map number to query | |
| Zone | Zone number assigned to the Line-map. Set to NULL if you are not interested in this returned value. | |
| XOrThetaVar | Receives the X-axis or Theta variable number assigned to the Line-map. Will only receive a Theta value if plot is in polar mode. Set to NULL if you are not interested in this returned value | |
| YOrRVar | Receives the Y-axis or Radian variable number assigned to the Line-map. Will only receive Radian value if plot is in polar mode. Set to NULL if you are not interested in this returned value. | |
| XAxis | Receives the X-axis number assigned to the Line-map. Set to NULL if you are not interested in this returned value. | |
| YAxis | Receives the Y-axis number assigned to the Line-map. Set to NULL if you are not interested in this returned value | |
| FunctionDependency | Receives the Function dependency assigned to the Line-map. Set to NULL if you are not interested in this returned value |
SUBROUTINE TecUtilLineMapGetAssignment( & LineMap, & Zone, & XOrThetaVar, & YOrRVar, & XAxis, & YAxis, & FunctionDependency) INTEGER*4 LineMap INTEGER*4 Zone INTEGER*4 XOrThetaVar INTEGER*4 YOrRVar INTEGER*4 XAxis INTEGER*4 YAxis INTEGER*4 FunctionDependency
Python Syntax:
Results = TecUtil.LineMapGetAssignment(LineMap)
Input:
LineMap int
Output:
Results[0] Zone int
Results[1] XOrThetaVar int
Results[2] YOrRVar int
Results[3] XAxis int
Results[4] YAxis int
Results[5] FunctionDependency FunctionDependency_e (defined in TecVals.py)
Obtain the zone number and which variables are used for X and Y for Line-map number 3:
EntIndex_t Zone; EntIndex_t XVar; EntIndex_t YVar; TecUtilLineMapGetAssignment(3, &Zone, &XVar, &YVar, (SmInteger_t *)NULL, (SmInteger_t *)NULL, (FunctionDependency_e *)NULL);
| EntIndex_t TecUtilLineMapGetCount | ( | void | ) |
Returns the number of Line-maps.
INTEGER*4 FUNCTION TecUtilLineMapGetCount()
Python Syntax:
Results = TecUtil.LineMapGetCount()
Output:
Results[0] ReturnVal int
| Boolean_t TecUtilLineMapGetName | ( | EntIndex_t | Map, | |
| char ** | Name | |||
| ) |
Get the name of an Line-map.
| Map | Number of the Line-map | |
| Name | Allocated string containing the Line-map name |
INTEGER*4 FUNCTION TecUtilLineMapGetName( & Map, & Name, & ReturnedNameLength) INTEGER*4 Map CHARACTER*(*) Name INTEGER*4 ReturnedNameLength
Python Syntax:
Results = TecUtil.LineMapGetName(Map)
Input:
Map int
Output:
Results[0] ReturnVal boolean
Results[1] Name string
Get the name of Line-map 3:
Boolean_t IsOk; char *MapName = NULL; IsOk = TecUtilLineMapGetName(3,&MapName);
| EntIndex_t TecUtilLineMapGetNumByUniqueID | ( | UniqueID_t | UniqueID | ) |
Gets a line map number, given a unique ID.
| UniqueID | Unique ID of the line map. |
INTEGER*4 FUNCTION TecUtilLineMapGetNumByUniqueID(UniqueID) INTEGER*4 UniqueID
Python Syntax:
Results = TecUtil.LineMapGetNumByUniqueID(UniqueID)
Input:
UniqueID long
Output:
Results[0] ReturnVal int
Get a line map number from a unique ID:
{
extern UniqueID_t ID; // previously initialized
TecUtilLockStart(AddOnID);
if ( TecUtilDataSetIsAvailable() )
{
EntIndex_t MapNum = TecUtilLineMapGetNumByUniqueID(ID);
if (MapNum != TECUTILBADID)
{
...
}
}
TecUtilLockFinish(AddOnID);
}
| UniqueID_t TecUtilLineMapGetUniqueID | ( | EntIndex_t | LineMap | ) |
Gets a unique ID for a line map.
A unique ID is an integer that uniquely identifies a line map. An addon can use these IDs to internally keep track of a set of line maps. TecUtilLineMapGetNumByUniqueID() can be used to convert between a unique ID and a line map number.
| LineMap | Line map number to query. |
INTEGER*4 FUNCTION TecUtilLineMapGetUniqueID(LineMap) INTEGER*4 Map
Python Syntax:
Results = TecUtil.LineMapGetUniqueID(LineMap)
Input:
LineMap int
Output:
Results[0] ReturnVal long
Get the unique ID for line map N:
... N is assigned...
{
TecUtilLockStart(AddOnID);
if ( TecUtilDataSetIsAvailable() && TecUtilLineMapGetCount() >= N )
{
UniqueID_t ID = TecUtilLineMapGetUniqueID(N);
...
}
TecUtilLockFinish(AddOnID);
}
| Boolean_t TecUtilLineMapIsActive | ( | EntIndex_t | LineMap | ) |
Determine if an Line-map is active.
INTEGER*4 FUNCTION TecUtilLineMapIsActive(LineMap) INTEGER*4 LineMap
Python Syntax:
Results = TecUtil.LineMapIsActive(LineMap)
Input:
LineMap int
Output:
Results[0] ReturnVal boolean
| SetValueReturnCode_e TecUtilLineMapSetActive | ( | Set_pa | LineMapSet, | |
| AssignOp_e | AssignModifier | |||
| ) |
Assigns which Line-maps are active.
| LineMapSet | Set of Line-maps used to change the current set of active Line-maps. How the active Line-maps are changed is based on the AssignModifier | |
| AssignModifier | The possible values are: AssignOp_Equals, AssignOp_PlusEquals, AssignOp_MinusEquals |
INTEGER*4 FUNCTION TecUtilLineMapSetActive( & LineMapSetPtr, & AssignModifier) POINTER (LineMapSetPtr, LineMapSet) INTEGER*4 AssignModifier
Python Syntax:
Results = TecUtil.LineMapSetActive(LineMapSet, AssignModifier)
Input:
LineMapSet sequence of ints
AssignModifier AssignOp_e (defined in TecVals.py)
Output:
Results[0] ReturnVal SetValueReturnCode_e (defined in TecVals.py)
Add Line-map 3 to the set of Line-maps:
Set_pa set = TecUtilSetAlloc(FALSE); TecUtilSetAddMember(set,3,FALSE); TecUtilLineMapSetActive(set,AssignOp_PlusEquals); TecUtilSetDealloc(&set);
| SetValueReturnCode_e TecUtilLineMapSetAssignment | ( | const char * | Attribute, | |
| Set_pa | LineMapSet, | |||
| double | DValue, | |||
| ArbParam_t | IValue | |||
| ) |
Define Line-map assignments.
| Attribute | Specify the attribute to change. The possible values are: |
Attribute Assign To Value Notes
---------------------------------------------------------
SV_ZONE IValue Valid Zone Number
SV_XAXISVAR IValue Valid Variable Number
SV_YAXISVAR IValue Valid Variable Number
SV_XAXIS IValue Axis number (1-5)
SV_YAXIS IValue Axis number (1-5)
SV_FUNCTIONDEPENDENCY IValue FunctionDependency_e
SV_SORT IValue LineMapSort_e
SV_SORTVAR IValue Valid Variable number.
| LineMapSet | Set of Line-maps to operate on. Use NULL to specify all Line-maps | |
| DValue | If the attribute requires a floating point value, put that value in DValue, otherwise DValue is not used. (Reserved for future use) | |
| IValue | If the attribute requires an integer, enumerated value, or a handle to a string then assigned it to the IValue parameter. Always typecast the IValue parameter to ArbParam_t |
INTEGER*4 FUNCTION TecUtilLineMapSetAssignment( & Attribute, & LineMapSetPtr, & DValue, & IValuePtr) CHARACTER*(*) Attribute POINTER (LineMapSetPtr, LineMapSet) REAL*8 DValue POINTER (IValuePtr, IValue)
Python Syntax:
Results = TecUtil.LineMapSetAssignment(Attribute, LineMapSet, DValue, IValue)
Input:
Attribute string
LineMapSet sequence of ints
DValue double
IValue (depends on attribute)
Output:
Results[0] ReturnVal SetValueReturnCode_e (defined in TecVals.py)
Assign variable 1 to be on the X-axis and variable 4 to be on the Y-axis for Line-mapping number 7:
Set_pa set = TecUtilSetAlloc(FALSE); TecUtilSetAddMember(set,7,FALSE); TecUtilLineMapSetAssignment(SV_XAXISVAR,set,0.0,(ArbParam_t)1); TecUtilLineMapSetAssignment(SV_YAXISVAR,set,0.0,(ArbParam_t)4); TecUtilSetDealloc(&set);
| SetValueReturnCode_e TecUtilLineMapSetBarChart | ( | const char * | Attribute, | |
| Set_pa | LineMapSet, | |||
| double | DValue, | |||
| ArbParam_t | IValue | |||
| ) |
Assign values to attributes for bar charts in Line-plots.
| Attribute | Specify the attribute to change. The possible values are: |
Attribute Assign To Value Notes
---------------------------------------------------------
SV_SHOW IValue TRUE,FALSE
SV_COLOR IValue ColorIndex_t
SV_ISFILLED IValue TRUE,FALSE
SV_FILLCOLOR IValue ColorIndex_t
SV_SIZE DValue Frame Units
SV_LINETHICKNESS DValue Frame Units
| LineMapSet | Set of Line-maps to operate on. Pass NULL to specify all Line-maps | |
| DValue | If the attribute requires a floating point value, put that value in DValue, otherwise DValue is not used. | |
| IValue | If the attribute requires an integer, enumerated value, or a handle to a string then assigned it to the IValue parameter. Always typecast the IValue parameter to ArbParam_t |
INTEGER*4 FUNCTION TecUtilLineMapSetBarChart( & Attribute, & LineMapSetPtr, & DValue, & IValuePtr) CHARACTER*(*) Attribute POINTER (LineMapSetPtr,LineMapSet) REAL*8 DValue POINTER (IValuePtr,IValue)
Python Syntax:
Results = TecUtil.LineMapSetBarChart(Attribute, LineMapSet, DValue, IValue)
Input:
Attribute string
LineMapSet sequence of ints
DValue double
IValue (depends on attribute)
Output:
Results[0] ReturnVal SetValueReturnCode_e (defined in TecVals.py)
Set the fill color of the bar chart to red for Line-mapping number 7:
Set_pa set = TecUtilSetAlloc(FALSE); TecUtilSetAddMember(set,7,FALSE); TecUtilLineMapSetBarChart(SV_FILLCOLOR,set,0.0,(ArbParam_t)Red_C); TecUtilSetDealloc(&set);
| SetValueReturnCode_e TecUtilLineMapSetCurve | ( | const char * | Attribute, | |
| Set_pa | LineMapSet, | |||
| double | DValue, | |||
| ArbParam_t | IValue | |||
| ) |
Assign values to attributes for curves in Line-plots.
| Attribute | Specify the attribute to change. The possible values are: |
Attribute Assign To Value Notes
---------------------------------------------------------
SV_NUMPTS IValue
SV_POLYORDER IValue 1-10
SV_WEIGHTVAR IValue Valid variable number
SV_USEWEIGHTVAR IValue TRUE,FALSE
SV_INDVARMIN DValue
SV_INDVARMAX DValue
SV_USEINDVARRANGE IValue TRUE,FALSE
SV_CLAMPSPLINE IValue TRUE,FALSE
SV_SPLINESLOPE1 DValue
SV_SPLINESLOPE2 DValue
SV_EXTENDEDNAME IValue String
SV_EXTENDEDSETTINGS IValue String
SV_CURVETYPE IValue CurveType_e
| LineMapSet | Set of Line-maps to operate on. Pass NULL to operate on all Line-maps | |
| DValue | If the attribute requires a floating point value, then put that value in DValue, otherwise DValue is not used | |
| IValue | If the attribute requires an integer, enumerated value, or a handle to a string then assigned it to the IValue parameter. Always typecast the IValue parameter to ArbParam_t |
INTEGER*4 FUNCTION TecUtilLineMapSetCurve( & Attribute, & LineMapSetPtr, & DValue, & IValuePtr) CHARACTER*(*) Attribute POINTER (LineMapSetPtr, LineMapSet) REAL*8 DValue POINTER (IValuePtr, IValue)
Python Syntax:
Results = TecUtil.LineMapSetCurve(Attribute, LineMapSet, DValue, IValue)
Input:
Attribute string
LineMapSet sequence of ints
DValue double
IValue (depends on attribute)
Output:
Results[0] ReturnVal SetValueReturnCode_e (defined in TecVals.py)
Set Line-mappings 3-5 to draw a polynomial curve fit of order 5. Note that you must set the curve type first.
Set_pa set = TecUtilSetAlloc(FALSE); TecUtilSetAddMember(set,3,FALSE); TecUtilSetAddMember(set,4,FALSE); TecUtilSetAddMember(set,5,FALSE); TecUtilLineMapSetCurve(SV_CURVETYPE,set,0.0,(ArbParam_t)CurveType_PoylnomialFit); TecUtilLineMapSetCurve(SV_POLYORDER,set,0.0,(ArbParam_t)5); TecUtilSetDealloc(&set);
| SetValueReturnCode_e TecUtilLineMapSetErrorBar | ( | const char * | Attribute, | |
| Set_pa | LineMapSet, | |||
| double | DValue, | |||
| ArbParam_t | IValue | |||
| ) |
Assign values to attributes for error bars in Line-plots.
| Attribute | Specify the attribute to change. The possible values are in the table below: |
Attribute Assign To Value Notes
---------------------------------------------------------
SV_SHOW IValue TRUE,FALSE
SV_VAR IValue Valid Variable Number
SV_BARTYPE IValue ErrorBar_e
SV_COLOR IValue ColorIndex_t
SV_LINETHICKNESS DValue Frame Units
SV_SIZE DValue Frame Units
SV_SKIPMODE IValue SkipMode_e
| LineMapSet | Set of Line-maps to operate on. | |
| DValue | If the attribute requires a floating point value then put that value in DValue, otherwise DValue is not used. | |
| IValue | If the attribute requires an integer, enumerated value, or a handle to a string then assign it to the IValue parameter. Always typecast the IValue parameter to ArbParam_t. |
INTEGER*4 FUNCTION TecUtilLineMapSetErrorBar( & Attribute, & LineMapSetPtr, & DValue, & IValuePtr) CHARACTER*(*) Attribute POINTER (LineMapSetPtr, LineMapSet) REAL*8 DValue POINTER (IValuePtr, IValue)
Python Syntax:
Results = TecUtil.LineMapSetErrorBar(Attribute, LineMapSet, DValue, IValue)
Input:
Attribute string
LineMapSet sequence of ints
DValue double
IValue (depends on attribute)
Output:
Results[0] ReturnVal SetValueReturnCode_e (defined in TecVals.py)
Make Error Bars red for all Line-mappings:
TecUtilLineMapSetErrorBar(SV_COLOR,NULL,0.0,(ArbParam_t)Red_C);
| SetValueReturnCode_e TecUtilLineMapSetIndices | ( | const char * | Attribute, | |
| const char * | SubAttribute, | |||
| Set_pa | LineMapSet, | |||
| ArbParam_t | IValue | |||
| ) |
Assign values to attributes for index ranges in Line-plots.
| Attribute | Specify the attribute to change. Set SubAttribute. | |
| SubAttribute | Specify the sub-attribute to change. The following table shows the possible values for Attribute and SubAttribute: |
Attribute SubAttribute Value Notes
--------------------------------------------------
SV_IJKLINES NULL IJKLines_e
SV_IRANGE SV_MIN Min range, 0 = IMax
SV_IRANGE SV_MAX Max range, 0 = IMax
SV_IRANGE SV_SKIP Index skip, 0 = IMax-1
SV_JRANGE SV_MIN Min range, 0 = JMax
SV_JRANGE SV_MAX Max range, 0 = JMax
SV_JRANGE SV_SKIP Index skip, 0 = JMax-1
SV_KRANGE SV_MIN Min range, 0 = KMax
SV_KRANGE SV_MAX Max range, 0 = KMax
SV_KRANGE SV_SKIP Index skip, 0 = KMax-1
| LineMapSet | Set of Line-maps to operate on. Pass NULL to affect all Line-maps. | |
| IValue | Pass the value via the IValue prameter. Always typecast the IValue parameter to ArbParam_t. |
INTEGER*4 FUNCTION TecUtilLineMapSetIndices( & Attribute, & SubAttribute, & LineMapSetPtr, & IValuePtr) CHARACTER*(*) Attribute CHARACTER*(*) SubAttribute POINTER (LineMapSetPtr, LineMapSet) POINTER (IValuePtr, IValue)
Python Syntax:
Results = TecUtil.LineMapSetIndices(Attribute, SubAttribute, LineMapSet, IValue)
Input:
Attribute string
SubAttribute string
LineMapSet sequence of ints
IValue (depends on attribute)
Output:
Results[0] ReturnVal SetValueReturnCode_e (defined in TecVals.py)
Set the I-range to 0-10 for all Line-mappings:
TecUtilLineMapSetIndices(SV_IRANGE,SV_MIN,NULL,(ArbParam_t)0); TecUtilLineMapSetIndices(SV_IRANGE,SV_MAX,NULL,(ArbParam_t)10);
| SetValueReturnCode_e TecUtilLineMapSetLine | ( | const char * | Attribute, | |
| Set_pa | LineMapSet, | |||
| double | DValue, | |||
| ArbParam_t | IValue | |||
| ) |
Assign values to attributes for lines in Line-plots.
| Attribute | Specify the attribute to change. The possible values are in the table below: |
Attribute Assign To Value Notes
---------------------------------------------------------
SV_SHOW IValue TRUE,FALSE
SV_COLOR IValue ColorIndex_t
SV_LINEPATTERN IValue LinePattern_e
SV_PATTERNLENGTH DValue Valid pattern length
SV_LINETHICKNESS DValue Valid line thickness
| LineMapSet | Set of Line-maps to operate on. | |
| DValue | If the attribute requires a floating point value then put that value in DValue, otherwise DValue is not used. | |
| IValue | If the attribute requires an integer, enumerated value, or a handle to a string then assign it to the IValue parameter. Always typecast the IValue parameter to ArbParam_t. |
INTEGER*4 FUNCTION TecUtilLineMapSetLine( & Attribute, & LineMapSetPtr, & DValue, & IValuePtr) CHARACTER*(*) Attribute POINTER (LineMapSetPtr, LineMapSet) REAL*8 DValue POINTER (IValuePtr, IValue)
Python Syntax:
Results = TecUtil.LineMapSetLine(Attribute, LineMapSet, DValue, IValue)
Input:
Attribute string
LineMapSet sequence of ints
DValue double
IValue (depends on attribute)
Output:
Results[0] ReturnVal SetValueReturnCode_e (defined in TecVals.py)
Set line patterns in Line-mappings 3-5 to dashed:
Set_pa set = TecUtilSetAlloc(FALSE); TecUtilSetAddMember(set,3,FALSE); TecUtilSetAddMember(set,4,FALSE); TecUtilSetAddMember(set,5,FALSE); TecUtilLineMapSetLine(SV_SHOW,set,0.0,(ArbParam_t)TRUE); TecUtilLineMapSetLine(SV_LINEPATTERN, set, 0.0 (ArbParam_t)LinePattern_Dashed); TecUtilSetDealloc(&set);
| SetValueReturnCode_e TecUtilLineMapSetName | ( | Set_pa | LineMapSet, | |
| const char * | NewName | |||
| ) |
Set the name of an Line-map.
| LineMapSet | Set of maps to operate on. Pass NULL to operate on all maps | |
| NewName | New name of the map(s). Must not be NULL |
INTEGER*4 FUNCTION TecUtilLineMapSetName( & LineMapSetPtr, & NewName) POINTER (LineMapSetPtr, LineMapSet) CHARACTER*(*) NewName
Python Syntax:
Results = TecUtil.LineMapSetName(LineMapSet, NewName)
Input:
LineMapSet sequence of ints
NewName string
Output:
Results[0] ReturnVal SetValueReturnCode_e (defined in TecVals.py)
Set the name of the first Line-map:
Set_pa set = TecUtilSetAlloc(FALSE); TecUtilSetAddMember(set,1,FALSE); TecUtilLineMapSetName(set,"MyName"); TecUtilSetDealloc(&set);
| SetValueReturnCode_e TecUtilLineMapSetSymbol | ( | const char * | Attribute, | |
| Set_pa | LineMapSet, | |||
| double | DValue, | |||
| ArbParam_t | IValue | |||
| ) |
Assign values to attributes for symbols in Line-plots.
All attributes except for symbol shape are set here. Use TecUtilLineMapSetSymbolShape() to set the symbol shape.
| Attribute | Specify the attribute to change. The possible values are in the table below: |
Attribute Assign To Value Notes
-------------------------------------------------------------------
SV_SHOW IValue TRUE,FALSE
SV_COLOR IValue ColorIndex_t
SV_ISFILLED IValue TRUE,FALSE
SV_FILLCOLOR IValue ColorIndex_t
SV_SIZE DValue Frame Units
SV_LINETHICKNESS DValue Valid line thickness
SV_SKIPMODE IValue Skip_ByIndex,Skip_ByFrameUnits
SV_SKIPPING DValue If SkipMode is Skip_ByIndex
then set to index skip. If
SkipMode is Skip_ByFrameUnits then
supply a distance in frame units.
| LineMapSet | Set of Line-maps to operate on. | |
| DValue | If the attribute requires a floating point value then put that value in DValue, otherwise DValue is not used. | |
| IValue | If the attribute requires an integer, enumerated value, or a handle to a string then assign it to the IValue parameter. Always typecast the IValue parameter to ArbParam_t. |
INTEGER*4 FUNCTION TecUtilLineMapSetSymbol( & Attribute, & LineMapSetPtr, & DValue, & IValuePtr) CHARACTER*(*) Attribute POINTER (LineMapSetPtr, LineMapSet) REAL*8 DValue POINTER (IValuePtr, IValue)
Python Syntax:
Results = TecUtil.LineMapSetSymbol(Attribute, LineMapSet, DValue, IValue)
Input:
Attribute string
LineMapSet sequence of ints
DValue double
IValue (depends on attribute)
Output:
Results[0] ReturnVal SetValueReturnCode_e (defined in TecVals.py)
Set the skip mode of all Line-maps to frame units (distance):
TecUtilLineMapSetSymbol(SV_SKIPMODE,NULL,0.0, (ArbParam_t)Skip_ByFrameUnits);
| SetValueReturnCode_e TecUtilLineMapSetSymbolShape | ( | const char * | Attribute, | |
| Set_pa | LineMapSet, | |||
| ArbParam_t | IValue | |||
| ) |
Assign values for the symbol shape in Line-plots.
| Attribute | Specify the attribute to change. The possible values are in the table below: |
Attribute Assign To Value Notes
----------------------------------------------------------------
SV_ISASCII IValue TRUE,FALSE
SV_ASCIICHAR IValue String containing a single character.
SV_GEOMSHAPE IValue GeomShape_e
| LineMapSet | Set of Line-maps to operate on. | |
| IValue | If the attribute requires an integer, enumerated value, or a handle to a string then assign it to the IValue parameter. Always typecast the IValue parameter to ArbParam_t. |
INTEGER*4 FUNCTION TecUtilLineMapSetSymbolShape( & Attribute, & LineMapSetPtr, & IValuePtr) CHARACTER*(*) Attribute POINTER (LineMapSetPtr, LineMapSet) POINTER (IValuePtr, IValue)
Python Syntax:
Results = TecUtil.LineMapSetSymbolShape(Attribute, LineMapSet, IValue)
Input:
Attribute string
LineMapSet sequence of ints
IValue (depends on attribute)
Output:
Results[0] ReturnVal SetValueReturnCode_e (defined in TecVals.py)
Change the symbol shape for symbols drawn with Line-map 3 to use circles:
Set_pa set = TecUtilSetAlloc(FALSE); TecUtilSetAddMember(set, 3,FALSE); TecUtilLineMapSetSymbolShape(SV_ISASCII, set,0.0, (ArbParam_t)FALSE); TecUtilLineMapSetSymbolShape(SV_GEOMSHAPE,set,0.0, (ArbParam_t)GeomShape_Circle); TecUtilSetDealloc(&set);
Shift a list of Line-maps to the bottom of the Line-map list.
This in effect causes the selected Line-maps to be drawn last.
| MapsToShift | Set of maps to shift. Must not be NULL |
INTEGER*4 FUNCTION TecUtilLineMapShiftToBottom(MapsToShiftPtr) POINTER (MapsToShiftPtr, MapsToShift)
Python Syntax:
Results = TecUtil.LineMapShiftToBottom(MapsToShift)
Input:
MapsToShift sequence of ints
Output:
Results[0] ReturnVal boolean
Shift Line-maps 2 and 4 to the bottom:
Set_pa set = TecUtilSetAlloc(FALSE); TecUtilSetAddMember(set,2,FALSE); TecUtilSetAddMember(set,4,FALSE); TecUtilLineMapShiftToBottom(set); TecUtilSetDealloc(&set);
Shift a list of Line-maps to the top of the Line-map list.
This in effect causes the selected Line-maps to be drawn first.
| MapsToShift | Set of maps to shift. Must not be NULL |
INTEGER*4 FUNCTION TecUtilLineMapShiftToTop(MapsToShiftPtr) POINTER (MapsToShiftPtr, MapsToShift)
Python Syntax:
Results = TecUtil.LineMapShiftToTop(MapsToShift)
Input:
MapsToShift sequence of ints
Output:
Results[0] ReturnVal boolean
Shift Line-maps 2 and 4 to the top:
Set_pa set = TecUtilSetAlloc(FALSE); TecUtilSetAddMember(set,2,FALSE); TecUtilSetAddMember(set,4,FALSE); TecUtilLineMapShiftToBottom(set); TecUtilSetDealloc(&set);
| ArbParam_t TecUtilLineMapStyleGetArbValue | ( | EntIndex_t | LineMap, | |
| const char * | S1, | |||
| const char * | S2, | |||
| const char * | S3 | |||
| ) |
Queries an Line-map attribute.
You can use this function to query any Line-map attribute that is not a floating point value. To query a floating point attribute, use TecUtilLineMapStyleGetDoubleValue().
| LineMap | Line-map number to query | |
| S1 | First parameter used to define the attribute to query. The parameters follow the same order that you would use when constructing a set value macro command. If a parameter is not used, then it must be NULL.These parameters are actually strings, but you can use the supplied SV_ constants from the SV.h include file. Using the SV_ constants will help prevent misspellings and other errors.If you are not sure of the possible values for an enumerate type, you can find the definitions in Include/GLOBAL.h below the Teclot home directory. | |
| S2 | Second parameter used to define the attribute to query. See S1. | |
| S3 | Third parameter used to define the attribute to query. See S1.This function will assert if the combination of parameters or the LineMap number is invalid. |
SUBROUTINE TecUtilLineMapStyleGetArbValue( & LineMap, & S1, & S2, & S3, & ResultPtr) INTEGER*4 LineMap CHARACTER*(*) S1 CHARACTER*(*) S2 CHARACTER*(*) S3 POINTER (ResultPtr, Result)
Python Syntax:
This function is not supported in Python.
Query the name of Line-map number 2.
{
// Equivalent macro command to set the color is: $!LINEMAP [2] NAME = "..."
char *LineMapName = NULL;
TecUtilLockStart(AddOnID);
MapName = (const char *) TecUtilLineMapStyleGetArbValue(2,SV_NAME,NULL,NULL);
// Use MapName.
TecUtilStringDealloc(&MapName); // When finished
TecUtilLockFinish(AddOnID);
}
Get the error bar variable for line map 7:
EntIndex_t ErrorBarVar; TecUtilLockStart(AddOnID); LineThickness = (EntIndex_t)TecUtilLineMapStyleGetArbValue(7, SV_ERRORBARS, SV_VAR, NULL); TecUtilLockFinish(AddOnID);
| double TecUtilLineMapStyleGetDoubleValue | ( | EntIndex_t | LineMap, | |
| const char * | S1, | |||
| const char * | S2, | |||
| const char * | S3 | |||
| ) |
Queries an Line-map attribute.
You can use this function to query any attribute that is a floating point value. To query a non-floating point attribute, use TecUtilLineMapStyleGetArbValue().
| LineMap | Line-map number to query | |
| S1 | First parameter used to define the attribute to query. The parameters follow the same order that you would use when constructing a set value macro command. If a parameter is not used, then it must be NULL.These parameters are actually strings, but you can use the supplied SV_ constants from the SV.h include file. Using the SV_ constants will help prevent misspellings and other errors.If you are not sure of the possible values for an enumerate type, you can find the definitions in Include/GLOBAL.h below the Teclot home directory. | |
| S2 | Second parameter used to define the attribute to query. See S1. | |
| S3 | Third parameter used to define the attribute to query. See S1. |
REAL*8 FUNCTION TecUtilLineMapStyleGetDoubleValue( & LineMap, & S1, & S2, & S3) INTEGER*4 LineMap CHARACTER*(*) S1 CHARACTER*(*) S2 CHARACTER*(*) S3
Python Syntax:
Results = TecUtil.LineMapStyleGetDoubleValue(LineMap, S1, S2, S3)
Input:
LineMap int
S1 string
S2 string
S3 string
Output:
Results[0] ReturnVal double
Query the pattern length for Line-map number 2.
{
// Equivalent macro command to set the pattern
// length is: $!LINEMAP [2] LINES { PATTERNLENGTH = ... }
double LinePatternLength;
TecUtilLockStart(AddOnID);
LinePatternLength = TecUtilLineMapStyleGetDoubleValue(2,SV_LINES,
SV_PATTERNLENGTH,
NULL);
TecUtilLockFinish(AddOnID);
}
| Boolean_t TecUtilLinePlotLayerIsActive | ( | const char * | LayerShowFlag | ) |
Indicates if the line plot layer of interest is active or not.
| LayerShowFlag | Show flag for the line plot layer of interest. |
INTEGER*4 FUNCTION TecUtilLinePlotLayerIsActive(LayerShowFlag) CHARACTER*(*) LayerShowFlag
Python Syntax:
Results = TecUtil.LinePlotLayerIsActive(LayerShowFlag)
Input:
LayerShowFlag string
Output:
Results[0] ReturnVal boolean
Determine if the line plot's symbol layer is on:
if (TecUtilLinePlotLayerIsActive(SV_SHOWSYMBOLS)) { // Do something with the line plot's symbols }
| SetValueReturnCode_e TecUtilLinePlotLayerSetIsActive | ( | const char * | LayerShowFlag, | |
| Boolean_t | TurnOnLinePlotLayer | |||
| ) |
Instructs Tecplot to turn on or off the specified line plot layer.
| LayerShowFlag | Show flag for the line plot layer of interest | |
| TurnOnLinePlotLayer | If TRUE Tecplot will turn on the layer, otherwise it will turn the layer off. |
INTEGER*4 FUNCTION TecUtilLinePlotLayerSetIsActive( & LayerShowFlag, & TurnOnLinePlotLayer) CHARACTER*(*) LayerShowFlag INTEGER*4 TurnOnLinePlotLayer
Python Syntax:
Results = TecUtil.LinePlotLayerSetIsActive(LayerShowFlag, TurnOnLinePlotLayer)
Input:
LayerShowFlag string
TurnOnLinePlotLayer boolean
Output:
Results[0] ReturnVal SetValueReturnCode_e (defined in TecVals.py)
Turn on the line plot's symbol layer:
SetValueReturnCode_e SVRC; SVRC = TecUtilLinePlotLayerSetIsActive(SV_SHOWSYMBOLS, TRUE);
| ArbParam_t TecUtilLinkingGetValue | ( | const char * | Attribute, | |
| const char * | SubAttribute | |||
| ) |
Gets frame linking attributes.
| Attribute | Valid values: SV_BETWEENFRAMES and SV_WITHINFRAME. | |
| SubAttribute | Attribute to set. For Attribute SV_BETWEENFRAMES the subattribute must be one of SV_LINKCONTOURLEVELS, SV_LINKFRAMESIZEANDPOSITION, SV_LINKXAXISRANGE, SV_LINKYAXISRANGE, SV_LINK3DVIEW, SV_LINKGROUP. For Attribute SV_WITHINFRAME the subattribute must be one of SV_LINKAXISSTYLE, SV_LINKGRIDLINESTYLE, SV_LINKLAYERLINECOLOR, SV_LINKLAYERLINEPATTERN |
SUBROUTINE TecUtilLinkingGetValue( & Attribute, & SubAttribute, & ResultPtr) CHARACTER*(*) Attribute CHARACTER*(*) SubAttribute POINTER (ResultPtr, Result)
Python Syntax:
This function is not supported in Python.
Query the group number of the current frame:
SmInteger_t GroupNumber; GroupNumber = (SmInteger_t)TecUtilFrameGetLinking(SV_BETWEENFRAMES, SV_LINKGROUP);
| SetValueReturnCode_e TecUtilLinkingSetValue | ( | const char * | Attribute, | |
| const char * | SubAttribute, | |||
| ArbParam_t | IValue | |||
| ) |
Convenience function for setting a frame linking attribute.
This function in turn calls TecUtilStyleSetLowLevel().
| Attribute | Valid values: SV_BETWEENFRAMES and SV_WITHINFRAME | |
| SubAttribute | Attribute to set. For Attribute SV_BETWEENFRAMES the subattribute must be one of SV_LINKCONTOURLEVELS, SV_LINKFRAMESIZEANDPOSITION, SV_LINKXAXISRANGE, SV_LINKYAXISRANGE, SV_LINK3DVIEW, SV_LINKGROUP. For Attribute SV_WITHINFRAME the subattribute must be one of SV_LINKAXISSTYLE, SV_LINKGRIDLINESTYLE, SV_LINKLAYERLINECOLOR, SV_LINKLAYERLINEPATTERN | |
| IValue | If Attribute is SV_LINKGROUP then this is the group number otherwise this is set to TRUE or FALSE |
INTEGER*4 FUNCTION TecUtilLinkingSetValue( & Attribute, & SubAttribute, & IValuePtr) CHARACTER*(*) Attribute CHARACTER*(*) SubAttribute POINTER (IValuePtr, IValue)
Python Syntax:
Results = TecUtil.LinkingSetValue(Attribute, SubAttribute, IValue)
Input:
Attribute string
SubAttribute string
IValue (depends on attribute)
Output:
Results[0] ReturnVal SetValueReturnCode_e (defined in TecVals.py)
Turn on linking for contour levels.
TecUtilLinkingSetValue(SV_BETWEENFRAMES, SV_LINKCONTOURLEVELS,TRUE);
| Boolean_t TecUtilNewLayout | ( | void | ) |
Delete all frames and data sets (clear the current layout).
A blank default frame will be created for you.
INTEGER*4 FUNCTION TecUtilNewLayout()
Python Syntax:
Results = TecUtil.NewLayout()
Output:
Results[0] ReturnVal boolean
Clear the current layout:
Boolean_t IsOk = TecUtilNewLayout();
| Boolean_t TecUtilOpenLayout | ( | const char * | FName, | |
| StringList_pa | AltInstructions, | |||
| Boolean_t | Append | |||
| ) |
Open and read in a new layout file.
| FName | The name of the layout file to open | |
| AltInstructions | Alternate instructions for the layout file. In most cases, this will be a string list containing file names which will override the data files listed in the layout file. Use NULL to load the data referenced in the layout file | |
| Append | TRUE to append the new layout file to the current layout or FALSE to replace the current layout |
INTEGER*4 FUNCTION TecUtilOpenLayout( & FName, & AltInstructionsPtr, & Append) CHARACTER*(*) FName POINTER (AltInstructionsPtr, AltInstructions) INTEGER*4 Append
Python Syntax:
Results = TecUtil.OpenLayout(FName, AltInstructions, Append)
Input:
FName string
AltInstructions sequence of strings
Append boolean
Output:
Results[0] ReturnVal boolean
Open a layout file called "experiment.lay." Then, append a layout called "calculate.lay," overriding the first data file referenced in that layout with a file called "newdata.plt":
StringList_pa AltInst = TecUtilStringListAlloc(); TecUtilStringListAppendString(AltInst, "newdata.plt"); TecUtilOpenLayout("experiment.lay", (StringList_pa)NULL, FALSE); TecUtilOpenLayout("calculate.lay", AltInst, TRUE); TecUtilStringListDealloc(&AltInst);
| void TecUtilPageClear | ( | void | ) |
Deletes all frames in the current page.
Fortran Syntax:
INTEGER*4 FUNCTION TecUtilPageClear()
Python Syntax:
Results = TecUtil.PageClear()
Output:
Results[0] ReturnVal NONE
| Boolean_t TecUtilPageCreateNew | ( | void | ) |
Creates a new page.
INTEGER*4 FUNCTION TecUtilPageCreateNew()
Results = TecUtil.PageCreateNew()
Output:
Results[0] ReturnVal boolean
| void TecUtilPageDelete | ( | void | ) |
Deletes the current page.
Will set the next page from the internal linked list to be current.
Fortran Syntax:
INTEGER*4 FUNCTION TecUtilPageDelete()
Python Syntax:
Results = TecUtil.PageDelete()
Output:
Results[0] ReturnVal NONE
| LgIndex_t TecUtilPageGetCount | ( | void | ) |
Returns the number of pages managed by Tecplot.
INTEGER*4 FUNCTION TecUtilPageGetCount()
Python Syntax:
Results = TecUtil.PageGetCount()
Output:
Results[0] ReturnVal int
| Boolean_t TecUtilPageGetName | ( | char ** | PageName | ) |
Get the name of the current page.
| PageName | Receives the name of the current page. You must free the returned string with TecUtilStringDealloc(). |
INTEGER*4 FUNCTION TecUtili(
& PageName,
& PageNameLength)
CHARACTER*(*) PageName
INTEGER*4 PageNameLength
Python Syntax:
Results = TecUtil.PageGetName()
Output:
Results[0] ReturnVal boolean
Results[1] PageName string
| UniqueID_t TecUtilPageGetUniqueID | ( | void | ) |
Returns the unique ID of the current page.
Fortran Syntax:
INTEGER*4 FUNCTION TecUtilPageGetUniqueID()
Python Syntax:
Results = TecUtil.PageGetUniqueID()
Output:
Results[0] ReturnVal long
| Boolean_t TecUtilPageSetCurrentByName | ( | const char * | PageName | ) |
Sets the current page to one matching the passed name.
| PageName | the name of the page to be set as the current. |
INTEGER*4 FUNCTION TecUtilPageSetCurrentByName(PageName) CHARACTER*(*) PageName
Python Syntax:
Results = TecUtil.PageSetCurrentByName(PageName)
Input:
PageName string
Output:
Results[0] ReturnVal boolean
| Boolean_t TecUtilPageSetCurrentByUniqueID | ( | UniqueID_t | UniqueID | ) |
Sets the current page to one matching the passed unique ID.
| UniqueID | ID of the page to be set as the current. |
INTEGER*4 FUNCTION TecUtilPageSetCurrentByUniqueID(UniqueID) POINTER (ValuePtr, UniqueID)
Python Syntax:
Results = TecUtil.PageSetCurrentByUniqueID(UniqueID)
Input:
UniqueID long
Output:
Results[0] ReturnVal boolean
| void TecUtilPageSetCurrentToNext | ( | void | ) |
Changes the current page to the next one in the internal linked list of pages.
Fortran Syntax:
INTEGER*4 FUNCTION TecUtilFrameSetCurrentToNext()
Python Syntax:
Results = TecUtil.PageSetCurrentToNext()
Output:
Results[0] ReturnVal NONE
| void TecUtilPageSetCurrentToPrev | ( | void | ) |
Changes the current page to the previous one in the internal linked list of pages.
Fortran Syntax:
INTEGER*4 FUNCTION TecUtilFrameSetCurrentToPrev()
Python Syntax:
Results = TecUtil.PageSetCurrentToPrev()
Output:
Results[0] ReturnVal NONE
| SetValueReturnCode_e TecUtilPageSetName | ( | const char * | Name | ) |
Set the name for the current page.
| Name | Name to assign to the current page. |
INTEGER*4 FUNCTION TecUtilPageSetName(Name) CHARACTER*(*) Name
Python Syntax:
Results = TecUtil.PageSetName(Name)
Input:
Name string
Output:
Results[0] ReturnVal SetValueReturnCode_e (defined in TecVals.py)
| void TecUtilPaperGetDimensions | ( | double * | Width, | |
| double * | Height | |||
| ) |
Get the dimensions of the currently defined paper in the Tecplot workspace.
| Width | Width of the paper (in inches). | |
| Height | Height of the paper (in inches). |
SUBROUTINE TecUtilPaperGetDimensions( & Width, & Height) REAL*8 Width REAL*8 Height
Python Syntax:
Results = TecUtil.PaperGetDimensions()
Output:
Results[0] Width double
Results[1] Height double
Get the current paper's position and size:
double width, height; TecUtilPaperGetDimensions(&width, &height);
| Boolean_t TecUtilPrint | ( | void | ) |
Print the current layout to a printer or send the print instructions to a file.
Use the TecUtilPrintSetup() function to configure printing.
INTEGER*4 FUNCTION TecUtilPrint()
Python Syntax:
Results = TecUtil.Print()
Output:
Results[0] ReturnVal boolean
Setup to print to a grayscale PostScript file called "print.ps" with black flooding appearing as a light gray and then do the printing:
TecUtilPrintSetup("PALETTE", NULL, 0.0, (ArbParam_t)Palette_Monochrome); TecUtilPrintSetup("DRIVER", NULL, 0.0, (ArbParam_t)PD_PS); TecUtilPrintSetup("PRINTFNAME", NULL, 0.0, (ArbParam_t)"print.ps"); TecUtilPrintSetup("MONOFLOODMAP", "BLACKSHADE", 90.0, (ArbParam_t)0); TecUtilPrint();
| SetValueReturnCode_e TecUtilPrintSetup | ( | const char * | Attribute, | |
| const char * | SubAttribute, | |||
| double | DValue, | |||
| ArbParam_t | IValue | |||
| ) |
Setup the attributes for printing.
Use TecUtilPrint() to do the actual printing. See the $!PRINTSETUP macro command in the Tecplot Reference Manual for more details on available options.
| Attribute | First parameter used in the $!PRINTSETUP macro command. See the Tecplot Reference Manual for the possible combinations of Attribute and SubAttribute. The following table shows all possible values for attribute and the corresponding type: |
Attribute I or D Value Type
-----------------------------------------------------------------
SV_PRINTFNAME IValue (char *)
SV_PRECISION IValue (SmInteger_t)
SV_SENDPRINTTOFILE IValue (Boolean_t)
SV_NUMHARDCOPYCOPIES IValue (SmInteger_t)
SV_MAKEROUGHDRAFT IValue (Boolean_t)
SV_LARGEPAPEROK IValue (Boolean_t)
SV_DRIVER IValue (PrinterDriver_e)
SV_PALETTE IValue (Palette_e)
SV_PENSPEED IValue (SmInteger_t)
SV_PLOTTERUNITSPERINCH DValue (double)
SV_WINPRINTERSMAPCOLORTOMONO IValue (Boolean_t)
SV_SPOOLER ------ Base on SubAttribute
SV_JOBCONTROL ------ Base on SubAttribute
SV_NUMLIGHTSOURCESHADES IValue (SmInteger_t)
SV_FORCEEXTRA3DSORTING IValue (Boolean_t)
SV_PRINTRENDERTYPE IValeu (PrintRenderType_e)
SV_IMAGERESOLUTION IValue (LgIndex_t)
| SubAttribute | Second Parameter in the $!PRINTSETUP macro command. See $!PRINTSETUP in the Tecplot Reference Manual for more information. Only used with an Attribute of SV_PLOTTERPENMAP, SV_MONOFLOODMAP, SV_MONOLINEANDTEXTMAP, SV_SPOOLER, or SV_JOBCONTROL. If SubAttribute is not used, pass NULL. The following table shows values for SubAttribute: |
SV_HPGL2MONOSPOOLCMD
SV_HPGL2COLORSPOOLCMD
SV_HPGLSPOOLCMD
SV_PSMONOSPOOLCMD
SV_PSCOLORSPOOLCMD
SV_LGSPOOLCMD
If Attribute is SV_JOBCONTROL, the sent value is ALWAYS a string (thus assigned to IValue) and SubAttribute can be one of:
SV_HPGLMOPUPSTR
SV_HPGL2MOPUPSTR
SV_POSTMOPUPSTR
SV_LGMOPUPSTR
SV_HPGLSETUPSTR
SV_HPGL2SETUPSTR
SV_POSTSETUPSTR
SV_LGSETUPSTR
| DValue | If the Attribute/SubAttribute requires a double or float value, pass it here. Otherwise, use 0.0. | |
| IValue | If the Attribute/SubAttribute requires a value other than a double or float value (that is, an integer, enumerated type, boolean value, or a string), pass it here. Otherwise, use zero. Always typecast the IValue parameter to (ArbParam_t).The possible values for an Attribute of SV_DRIVER are PD_HPGL, PD_HPGL2, PD_PS, PD_LASERG, PD_EPS, and PD_WINDOWS.The possible values for an Attribute of SV_PALETTE are Palette_Monochrome, Palette_PenPlotter, and Palette_Color. |
INTEGER*4 FUNCTION TecUtilPrintSetup( & Attribute, & SubAttribute, & DValue, & IValuePtr) CHARACTER*(*) Attribute CHARACTER*(*) SubAttribute REAL*8 DValue POINTER (IValuePtr, IValue)
Python Syntax:
Results = TecUtil.PrintSetup(Attribute, SubAttribute, DValue, IValue)
Input:
Attribute string
SubAttribute string
DValue double
IValue (depends on attribute)
Output:
Results[0] ReturnVal SetValueReturnCode_e (defined in TecVals.py)
Change the type of print output to be postscript:
SetValueReturnCode_e SVRC; SVRC = TecUtilPrintSetup(SV_DRIVER, NULL, 0.0, // Not used (ArbParam_t)PD_PS);
Change the name of the output file for print commands to be "myprint.ps"
SetValueReturnCode_e SVRC; SVRC = TecUtilPrintSetup(SV_PRINTFNAME, NULL, 0.0, // Not used (ArbParam_t)"myprint.ps");
Set the print spooler command for color output to be "lpr -hpcolor \@"
SetValueReturnCode_e SVRC; SVRC = TecUtilPrintSetup(SV_SPOOLER, SV_PSCOLORSPOOLCMD, 0.0, // Not used (ArbParam_t)"lpr -hpcolor @");
| Boolean_t TecUtilRawColorMap | ( | int | NumRawRGBValues, | |
| ColorIndex_t * | RawRValues_Array, | |||
| ColorIndex_t * | RawGValues_Array, | |||
| ColorIndex_t * | RawBValues_Array | |||
| ) |
Assign the RGB values that define the Raw User-Defined color map.
This does not set the color map to use the Raw User-Defined color map. Use TecUtilColorMapSetBase() to assign the color map.
| NumRawRGBValues | The number of RGB values to use to define the Raw User-Defined color map. This must be less than MaxRawColorMapEntries. | |
| RawRValues_Array | An array of size NumRawRGBValues which contains the red values to define the Raw User-Defined color map. | |
| RawGValues_Array | An array of size NumRawRGBValues which contains the green values to define the Raw UserDefined color map. | |
| RawBValues_Array | An array of size NumRawRGBValues which contains the blue values to define the Raw User-Defined color map. |
INTEGER*4 FUNCTION TecUtilRawColorMap( & NumRawRGBValues, & RawRValues_Array, & RawGValues_Array, & RawBValues_Array) INTEGER*4 NumRawRGBValues INTEGER*4 RawRValues_Array INTEGER*4 RawGValues_Array INTEGER*4 RawBValues_Array
Python Syntax:
Results = TecUtil.RawColorMap(NumRawRGBValues, RawRValues_Array, RawGValues_Array, RawBValues_Array)
Input:
NumRawRGBValues int
RawRValues_Array list of ints
RawGValues_Array list of ints
RawBValues_Array list of ints
Output:
Results[0] ReturnVal boolean
Define the Raw User-Defined color map to be five RGB values: blue, cyan, green, yellow, and red and assign Tecplot to use the Raw User-Defined color map.
ColorIndex_t RValues[5]; ColorIndex_t GValues[5] ColorIndex_t BValues[5]; RValues[0] = 0; GValues[0] = 0; BValues[0] = 255; RValues[1] = 0; GValues[1] = 255; BValues[1] = 255; RValues[2] = 0; GValues[2] = 255; BValues[2] = 0; RValues[3] = 255; GValues[3] = 255; BValues[3] = 0; RValues[4] = 255; GValues[4] = 0; BValues[4] = 0; TecUtilRawColorMap(5, RValues, GValues, BValues); TecUtilColorMapSetBase(ColorMap_RawUserDef);
| Boolean_t TecUtilReadColorMap | ( | const char * | FName | ) |
Load a color map file.
| FName | Name of the color map file to load |
INTEGER*4 FUNCTION TecUtilReadColorMap(FName) CHARACTER*(*) FName
Python Syntax:
Results = TecUtil.ReadColorMap(FName)
Input:
FName string
Output:
Results[0] ReturnVal boolean
Load the color map file temp.map.
TecUtilReadColorMap("temp.map");
| Boolean_t TecUtilReadStylesheet | ( | const char * | FName, | |
| Boolean_t | IncludePlotStyle, | |||
| Boolean_t | IncludeText, | |||
| Boolean_t | IncludeGeom, | |||
| Boolean_t | IncludeStreamPositions, | |||
| Boolean_t | IncludeContourLevels, | |||
| Boolean_t | MergeStyle, | |||
| Boolean_t | IncludeFrameSizeAndPosition | |||
| ) |
Read a stylesheet file into the current frame.
| FName | The name of the stylesheet file to read | |
| IncludePlotStyle | Set to TRUE to process commands related to the style of the plot (that is, mesh color, vector type, etc.) | |
| IncludeText | Set to TRUE to load any text in the stylesheet | |
| IncludeGeom | Set to TRUE to load any geometries in the stylesheet | |
| IncludeStreamPositions | Set to TRUE to load any streamtrace starting positions in the stylesheet | |
| IncludeContourLevels | Set to TRUE to load any contour level information in the stylesheet. | |
| MergeStyle | Set to TRUE to merge the current frame style with the new stylesheet. Set to FALSE to reset the style of the current frame back to factory defaults before reading in the stylesheet | |
| IncludeFrameSizeAndPosition | Set to TRUE to resize and position the current frame to the specifications of the stylesheet file. Set to FALSE to keep the current frame's size and position |
INTEGER*4 FUNCTION TecUtilReadStylesheet( & FName, & IncludePlotStyle, & IncludeText, & IncludeGeom, & IncludeStreamPositions, & IncludeContourLevels, & MergeStyle, & IncludeFrameSizeAndPosition) CHARACTER*(*) FName INTEGER*4 IncludePlotStyle INTEGER*4 IncludeText INTEGER*4 IncludeGeom INTEGER*4 IncludeStreamPositions INTEGER*4 IncludeContourLevels INTEGER*4 MergeStyle INTEGER*4 IncludeFrameSizeAndPosition
Python Syntax:
Results = TecUtil.ReadStylesheet(FName, IncludePlotStyle, IncludeText, IncludeGeom, IncludeStreamPositions, IncludeContourLevels, MergeStyle, IncludeFrameSizeAndPosition)
Input:
FName string
IncludePlotStyle boolean
IncludeText boolean
IncludeGeom boolean
IncludeStreamPositions boolean
IncludeContourLevels boolean
MergeStyle boolean
IncludeFrameSizeAndPosition boolean
Output:
Results[0] ReturnVal boolean
Load in the stylesheet file1.sty, choosing to reset the style of the current frame back to factory defaults first. Next, load only text and geometries from the stylesheet file2.sty, adding them to the current style:
Boolean_t IsOk; IsOk = TecUtilReadStylesheet("file1.sty", TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, TRUE); IsOk = TecUtilReadStylesheet("file2.sty", FALSE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE);
Redraw the current frame.
| DoFullDrawing | Set to FALSE to only draw a trace of the data in the current frame. Set to TRUE to do a full redraw. |
INTEGER*4 FUNCTION TecUtilRedraw(DoFullDrawing) INTEGER*4 DoFullDrawing
Python Syntax:
Results = TecUtil.Redraw(DoFullDrawing)
Input:
DoFullDrawing boolean
Output:
Results[0] ReturnVal boolean
Do a complete redraw of the current frame:
TecUtilRedraw(TRUE);
Redraw all frames.
| DoFullDrawing | Set to FALSE to only draw a trace of the data in all frames. Set to TRUE to do a full redraw. |
INTEGER*4 FUNCTION TecUtilRedrawAll(DoFullDrawing) INTEGER*4 DoFullDrawing
Python Syntax:
Results = TecUtil.RedrawAll(DoFullDrawing)
Input:
DoFullDrawing boolean
Output:
Results[0] ReturnVal boolean
Do a complete redraw of all frames:
TecUtilRedrawAll(TRUE);
| Boolean_t TecUtilReset3DAxes | ( | void | ) |
Reset the ranges on the 3-D axes.
The current frame mode must be 3D to use this function.
INTEGER*4 FUNCTION TecUtilReset3DAxes()
Python Syntax:
Results = TecUtil.Reset3DAxes()
Output:
Results[0] ReturnVal boolean
| Boolean_t TecUtilReset3DOrigin | ( | void | ) |
Reposition the rotation origin in 3-D to be at the centroid of the data.
The current frame must be in 3D mode to use this function.
INTEGER*4 FUNCTION TecUtilReset3DOrigin()
Python Syntax:
Results = TecUtil.Reset3DOrigin()
Output:
Results[0] ReturnVal boolean
| Boolean_t TecUtilReset3DOriginX | ( | ArgList_pa | ArgList | ) |
Reposition the rotation origin in 3-D to the specified location.
The current frame must be in 3D frame mode to use this function.
| ArgList | Set of Arglist entries. This is built using calls to TecUtilArgListAppendXXXX functions. Arglist Values SV_ORIGINRESETLOCATION
|
INTEGER*4 FUNCTION TecUtilReset3DOriginX(ArgListPtr) POINTER (ArgListPtr, ArgList)
Python Syntax:
Results = TecUtil.Reset3DOriginX(ArgList)
Input:
ArgList dictionary
Output:
Results[0] ReturnVal boolean
Reset the origin location to the center of the current view.
Boolean_t IsOk = TRUE; ArgList_pa ArgList; TecUtilLockStart(AddOnID); ArgList = TecUtilArgListAlloc(); TecUtilArgListAppendInt(ArgList, SV_ORIGINRESETLOCATION, OriginResetLocation_ViewCenter); IsOk = TecUtilReset3DOriginX(ArgList); TecUtilArgListDealloc(&ArgList); TecUtilLockFinish(AddOnID);
| Boolean_t TecUtilReset3DScaleFactors | ( | void | ) |
Recalculate the scale factors for the 3-D axes.
Aspect ratio limits are taken into account. The current frame must be in 3D frame mode to use this function.
INTEGER*4 FUNCTION TecUtilReset3DScaleFactors()
Python Syntax:
Results = TecUtil.Reset3DScaleFactors()
Output:
Results[0] ReturnVal boolean
| Boolean_t TecUtilResetVectorLength | ( | void | ) |
Reset the length of the vectors.
Tecplot will find the vector with the largest magnitude and set the scaling factor so it will appear on the screen using the default length as specified in the configuration file with the $!FRAMESETUP VECTDEFLEN macro command. The current frame must have a plot type of cartesian 2D or 3D to use this function.
INTEGER*4 FUNCTION TecUtilResetVectorLength()
Python Syntax:
Results = TecUtil.ResetVectorLength()
Output:
Results[0] ReturnVal boolean
| Boolean_t TecUtilRotate2D | ( | Set_pa | ZoneSet, | |
| double | RotateAmountInDegrees, | |||
| double | XOrigin, | |||
| double | YOrigin | |||
| ) |
| Boolean_t TecUtilSaveLayoutX | ( | ArgList_pa | ArgList | ) |
Save the current layout to a file.
| ArgList | Set of Arglist entries. This is built using calls to TecUtilArgListAppendXXXX functions. Arglist Values SV_FNAME
SV_INCLUDEDATA
SV_INCLUDEPREVIEW
SV_USERELATIVEPATHS
SV_POSTLAYOUTCOMMANDS
|
INTEGER*4 FUNCTION TecUtilSaveLayoutX(ArgListPtr) POINTER (ArgListPtr, ArgList)
Python Syntax:
Results = TecUtil.SaveLayoutX(ArgList)
Input:
ArgList dictionary
Output:
Results[0] ReturnVal boolean
Save a layout package named temp.lpk, without a preview image:
TecUtilArgListClear(ArgList); TecUtilArgListAppendString(ArgList, SV_FNAME, "temp.lpk"); TecUtilArgListAppendInt(ArgList, SV_INCLUDEDATA, TRUE); TecUtilArgListAppendInt(ArgList, SV_INCLUDEPREVIEW, FALSE); IsOk = TecUtilSaveLayoutX(ArgList);
Save a layout named temp.lay using relative path names:
TecUtilArgListClear(ArgList); TecUtilArgListAppendString(ArgList, SV_FNAME, "temp.lpk"); TecUtilArgListAppendInt(ArgList, SV_USERELATIVEPATHS, TRUE); TecUtilArgListAppendInt(ArgList, SV_INCLUDEPREVIEW, FALSE); IsOk = TecUtilSaveLayoutX(ArgList);
| Boolean_t TecUtilScatterResetRelSize | ( | void | ) |
Reset the relative scatter sizing.
Tecplot will find the scatter with the largest size and set the scaling factor so it will appear on the screen using the default length as specified in the configuration file with the $!BASICSIZE SYMBOLSIZE { MEDIUM = <double> } macro command. The current frame must have a plot type of cartesian 2D or 3D to use this function.
INTEGER*4 FUNCTION TecUtilScatterResetRelSize()
Python Syntax:
Results = TecUtil.ScatterResetRelSize()
Output:
Results[0] ReturnVal boolean
| Boolean_t TecUtilSet3DEyeDistance | ( | double | EyeDistance | ) |
Sets the distance the viewer is from the plane that is parallel to the screen and passes through the 3-D rotation origin.
| EyeDistance | The distance from the 3-D rotation origin to set the viewer |
INTEGER*4 FUNCTION TecUtilSet3DEyeDistance(EyeDistance) REAL*8 EyeDistance
Python Syntax:
Results = TecUtil.Set3DEyeDistance(EyeDistance)
Input:
EyeDistance double
Output:
Results[0] ReturnVal boolean
| void TecUtilSetupTransformations | ( | void | ) |
Initializes transformation information so that coordinate conversion functions can be used.
This function must be called before any sequence of calls to TecUtilConvert3DPositionToGrid().
Fortran Syntax:
SUBROUTINE TecUtilSetupTransformations()
Python Syntax:
Results = TecUtil.SetupTransformations()
Output:
Results[0] ReturnVal NONE
Convert from 3-D world coordinates to Tecplot's 3-D grid coordinates.
{
double ZPlaneFloor;
double X,Y,Z;
TecUtilLockStart(AddOnID);
TecUtilSetupTransformations();
ZPlaneFloor = TecUtil3DViewGetNearZPlane();
TecUtilConvert3DPositionToGrid(1.0,1.0,ZPlaneFloor,&X,&Y,&Z);
TecUtilLockFinish(AddOnID);
}
| double TecUtilSolutionTimeGetCurrent | ( | void | ) |
Returns the current solution time for the current frame.
REAL*8 FUNCTION TecUtilSolutionTimeGetCurrent();
Python Syntax:
Results = TecUtil.SolutionTimeGetCurrent()
Output:
Results[0] ReturnVal double
| SetValueReturnCode_e TecUtilSolutionTimeSetCurrent | ( | double | NewSolutionTime | ) |
Sets the current solution time for the current frame.
| NewSolutionTime | Value of the new solution time for the current frame. |
INTEGER*4 FUNCTION TecUtilSolutionTimeSetCurrent(NewSolutionTime) REAL*8 NewSolutionTime
Python Syntax:
Results = TecUtil.SolutionTimeSetCurrent(NewSolutionTime)
Input:
NewSolutionTime double
Output:
Results[0] ReturnVal SetValueReturnCode_e (defined in TecVals.py)
| Boolean_t TecUtilStreamtraceAdd | ( | int | NumRakePoints, | |
| Streamtrace_e | StreamType, | |||
| StreamDir_e | Direction, | |||
| double | StartXPos, | |||
| double | StartYPos, | |||
| double | StartZPos, | |||
| double | AltStartXPos, | |||
| double | AltStartYPos, | |||
| double | AltStartZPos | |||
| ) |
Add a single streamtrace or a rake of streamtraces to the current frame.
The frame must be a 2-D or 3-D field plot.
| NumRakePoints | The number of points in the rake of streamtraces which are being added. Use one if just one streamtrace is being added. The number must be greater than zero | |
| StreamType | The type of streamtraces which are being added. The possible values are: Streamtrace_SurfaceLine, Streamtrace_VolumeLine, Streamtrace_VolumeRibbon, Streamtrace_VolumeRod, Streamtrace_TwoDLine | |
| Direction | The direction of the streamtraces which are being added. The possible values are: StreamDir_Forward, StreamDir_Reverse, or StreamDir_Both | |
| StartXPos | X-Coordinate for the starting position of the streamtraces being added. If NumRakePoints is greater than one, then this is the starting position of the rake of streamtraces which are being added. StartZPos is only used for 3-D streamtraces | |
| StartYPos | Y-Coordinate for the starting position of the streamtraces being added. | |
| StartZPos | Z-Coordinate for the starting position of the streamtraces being added. Only used streamtraces are 3-D. | |
| AltStartXPos | X-Coordinate for the alternate starting position of the streamtraces which are being added. If NumRakePoints is one, this value is ignored (except in the case of streamtraces of type ribbon or rod, in which case the alternate starting position defines the streamtrace orientation). Otherwise, these values define the ending position of the rake of streamtraces which are being added. | |
| AltStartYPos | Y-Coordinate for the alternate starting position of the streamtraces which are being added. See AltStartXPos. | |
| AltStartZPos | Z-Coordinate for the alternate starting position of the streamtraces which are being added. See AltStartXPos. |
INTEGER*4 FUNCTION TecUtilStreamtraceAdd( & NumRakePoints, & StreamType, & Direction, & StartXPos, & StartYPos, & StartZPos, & AltStartXPos, & AltStartYPos, & AltStartZPos) INTEGER*4 NumRakePoints INTEGER*4 StreamType INTEGER*4 Direction REAL*8 StartXPos REAL*8 StartYPos REAL*8 StartZPos REAL*8 AltStartXPos REAL*8 AltStartYPos REAL*8 AltStartZPos
Python Syntax:
Results = TecUtil.StreamtraceAdd(NumRakePoints, StreamType, Direction, StartXPos, StartYPos, StartZPos, AltStartXPos, AltStartYPos, AltStartZPos)
Input:
NumRakePoints int
StreamType Streamtrace_e (defined in TecVals.py)
Direction StreamDir_e (defined in TecVals.py)
StartXPos double
StartYPos double
StartZPos double
AltStartXPos double
AltStartYPos double
AltStartZPos double
Output:
Results[0] ReturnVal boolean
Add a single 2-D line streamtrace to the current frame:
Boolean_t IsOk = FALSE; double Xp = 0.0; double Yp = 0.0; Xp = 10.0; Yp = 15.0; IsOk = TecUtilStreamtraceAdd(1, Streamtrace_TwoDLine, StreamDir_Forward, Xp, Yp, 0.0, 0.0, 0.0, 0.0); if (IsOk) { // do more processing . . . }
| Boolean_t TecUtilStreamtraceDeleteAll | ( | void | ) |
Delete all streamtraces in the current frame.
Streamtraces are numbered sequentially.
INTEGER*4 FUNCTION TecUtilStreamtraceDeleteAll()
Python Syntax:
Results = TecUtil.StreamtraceDeleteAll()
Output:
Results[0] ReturnVal boolean
| Boolean_t TecUtilStreamtraceDeleteRange | ( | int | Start, | |
| int | End | |||
| ) |
Delete a range of streamtraces.
Streamtraces are numbered sequentially in the order they were created.
| Start | Starting stream in the range of Streamtraces to delete. | |
| End | Ending stream in the range of Streamtraces to delete. |
INTEGER*4 FUNCTION TecUtilStreamtraceDeleteRange( & Start, & End) INTEGER*4 Start INTEGER*4 End
Python Syntax:
Results = TecUtil.StreamtraceDeleteRange(Start, End)
Input:
Start int
End int
Output:
Results[0] ReturnVal boolean
Delete streamtraces 1 through 5.
Boolean_t IsOk = FALSE; IsOk = TecUtilStreamtraceDeleteRange(1, 5); if (IsOk) { // do more processing . . . }
| int TecUtilStreamtraceGetCount | ( | void | ) |
Get the number of active streamtraces.
INTEGER*4 FUNCTION TecUtilStreamtraceGetCount()
Python Syntax:
Results = TecUtil.StreamtraceGetCount()
Output:
Results[0] ReturnVal int
| void TecUtilStreamtraceGetPos | ( | int | StreamNumber, | |
| double * | X, | |||
| double * | Y, | |||
| double * | Z | |||
| ) |
Get the starting position for a given streamtrace.
| StreamNumber | Number of the streamtrace | |
| X | References to the Variable in which to store the X-position of the streamtrace. | |
| Y | References to the Variable in which to store the Y-position of the streamtrace. | |
| Z | References to the Variable in which to store the Z-position of the streamtrace. |
SUBROUTINE TecUtilStreamtraceGetPos( & StreamNumber, & X, & Y, & Z) INTEGER*4 StreamNumber REAL*8 X REAL*8 Y REAL*8 Z
Python Syntax:
Results = TecUtil.StreamtraceGetPos(StreamNumber)
Input:
StreamNumber int
Output:
Results[0] X double
Results[1] Y double
Results[2] Z double
Get the position of streamtrace number 3.
double X,Y,Z; TecUtilStreamtraceGetPos(3,&X,&Y,&Z);
| Boolean_t TecUtilStreamtraceResetDelta | ( | void | ) |
Resets the time interval between stream markers.
INTEGER*4 FUNCTION TecUtilStreamtraceResetDelta()
Python Syntax:
Results = TecUtil.StreamtraceResetDelta()
Output:
Results[0] ReturnVal boolean
| Boolean_t TecUtilStreamtraceSetTermLine | ( | int | NumPoints, | |
| const double * | XTermLinePts_Array, | |||
| const double * | YTermLinePts_Array | |||
| ) |
Set the position of the termination line for streamtraces.
| NumPoints | The number of XY-termination line points supplied. The number must be greater than zero, and less than or equal to the number of XY-termination points supplied | |
| XTermLinePts_Array | Array of X-termination line ordinates | |
| YTermLinePts_Array | Array of Y-termination line ordinates |
INTEGER*4 FUNCTION TecUtilStreamtraceSetTermLine( & NumPoints, & XTermLinePts_Array, & YTermLinePts_Array) INTEGER*4 NumPoints REAL*8 XTermLinePts_Array REAL*8 YTermLinePts_Array
Python Syntax:
Results = TecUtil.StreamtraceSetTermLine(NumPoints, XTermLinePts_Array, YTermLinePts_Array)
Input:
NumPoints int
XTermLinePts_Array list of doubles
YTermLinePts_Array list of doubles
Output:
Results[0] ReturnVal boolean
Define a line for terminating streamtraces.
Boolean_t IsOk = FALSE; double Xp[2]; double Yp[2]; Xp[0] = 0.0; Yp[0] = 0.0; Xp[1] = 5.0; Yp[1] = 8.0; IsOk = TecUtilStreamtraceSetTermLine(2, Xp, Yp); if (IsOk) { // do more processing . . . }
| GetValueReturnCode_e TecUtilStyleGetLowLevelX | ( | ArgList_pa | ArgList | ) |
Low level function used to get most frame and base attribute values in Tecplot.
The parameters to TecUtilStyleGetLowLevelX() mimic the Macro Frame SetValue Commands described in the Tecplot Reference Manual.
| ArgList | Set of Arglist entries. This is built using calls to TecUtilArgListAppendXXXX functions. Arglist Values SV_P1
SV_P2
SV_P3
SV_P4
SV_P5
SV_P6
SV_OFFSET1
SV_OFFSET2
SV_DVALUE
SV_IVALUE
|
GetValue_Ok Value was assigned to either the double
or ArbParam_t value given.
GetValue_ResultTypeError Resulting type mismatch with the supplied
DValue or IValue.
GetValue_SyntaxError SV_P# parameters did not follow the macro
command syntax. The parameters must mimic the
macro command language and only for the
branches of the language tree that are
available.
Fortran Syntax:
INTEGER*4 FUNCTION TecUtilStyleGetLowLevelX(ArgListPtr) POINTER (ArgListPtr, ArgList)
Python Syntax:
This function is not supported in Python.
Make some miscellaneous queries:
ArgList_pa ArgList; ArbParam_t IValue; double DValue; GetValueReturnCode_e GVRC; TecUtilLockStart(AddOnID); ArgList = TecUtilArgListAlloc(); // get mesh color for zone 2... assuming Tecplot's plot type is cartesian TecUtilArgListClear(ArgList); TecUtilArgListAppendInt(ArgList, SV_OFFSET1, 2); TecUtilArgListAppendString(ArgList, SV_P1, SV_FIELD); TecUtilArgListAppendString(ArgList, SV_P2, SV_MESH); TecUtilArgListAppendString(ArgList, SV_P3, SV_COLOR); TecUtilArgListAppendArbParamPtr(ArgList, SV_IVALUE, &IValue); GVRC = TecUtilStyleGetLowLevelX(ArgList); if (GVRC == GetValue_Ok) { ColorIndex_t MeshColor = (ColorIndex_t)IValue; printf("Zone 2's mesh color is %d\n", MeshColor); } // get the line thickness of zone 3... same assumptions as above TecUtilArgListClear(ArgList); TecUtilArgListAppendInt(ArgList, SV_OFFSET1, 3); TecUtilArgListAppendString(ArgList, SV_P1, SV_FIELD); TecUtilArgListAppendString(ArgList, SV_P2, SV_MESH); TecUtilArgListAppendString(ArgList, SV_P3, SV_LINETHICKNESS); TecUtilArgListAppendDoublePtr(ArgList, SV_DVALUE, &DValue); GVRC = TecUtilStyleGetLowLevelX(ArgList); if (GVRC == GetValue_Ok) { double MeshLineThickness = DValue; printf("Zone 3's mesh line thickness is %lg\n", MeshLineThickenss); } // get the positive prefix number for contour group 1's contour legend TecUtilArgListClear(ArgList); TecUtilArgListAppendInt(ArgList, SV_OFFSET1, 1); TecUtilArgListAppendString(ArgList, SV_P1, SV_GLOBALCONTOUR); TecUtilArgListAppendString(ArgList, SV_P2, SV_LEGEND); TecUtilArgListAppendString(ArgList, SV_P3, SV_NUMFORMAT); TecUtilArgListAppendString(ArgList, SV_P3, SV_POSITIVEPREFIX); TecUtilArgListAppendArbParamPtr(ArgList, SV_IVALUE, &IValue); if (GVRC == GetValue_Ok) { char *PositivePrefixStr = (char *)IValue; if (PositivePrefixStr != NULL) { printf("Positive prefix number format for " "contour group 1's contour legend is:%s\n", PositivePrefixStr); TecUtilStringDealloc(&PositivePrefixStr); } else printf("Positive prefix number format for " "contour group 1's contour legend " "was not specified.\n"); } TecUtilArgListDealloc(&ArgList); TecUtilLockFinish(AddOnID);
| Boolean_t TecUtilStyleSetBase | ( | StyleBase_e | StyleBase | ) |
Set the frame style defaults used by Tecplot when creating new frames.
During normal operation, Tecplot bases the style of a new frame on the factory defaults plus any changes assigned in the Tecplot configuration file. Layout files and stylesheet files, however, rely on Tecplot basing new frames only on the factory defaults. This command is typically not used by the casual user.
| StyleBase | Style base used by Tecplot for all future frames. This may be set to StyleBase_Factory or StyleBase_Config |
INTEGER*4 FUNCTION TecUtilStyleSetBase(StyleBase) INTEGER*4 StyleBase
Python Syntax:
Results = TecUtil.StyleSetBase(StyleBase)
Input:
StyleBase StyleBase_e (defined in TecVals.py)
Output:
Results[0] ReturnVal boolean
Instruct Tecplot to create all future frames based upon the factory defaults, ignoring any modifications specified in the user's tecplot.cfg file.
| SetValueReturnCode_e TecUtilStyleSetLowLevel | ( | Widget | TextFieldWidget, | |
| double | DValue, | |||
| ArbParam_t | IValue, | |||
| ArbParam_t | SetOrOffset, | |||
| AssignOp_e | AssignModifier, | |||
| const char * | P1, | |||
| const char * | P2, | |||
| const char * | P3, | |||
| const char * | P4, | |||
| const char * | P5, | |||
| const char * | P6, | |||
| Boolean_t | OkToRecord | |||
| ) |
Low level function used to set most frame and base attribute values in Tecplot.
Use this function only if you cannot find an appropriate convenience function that will do the job. As of Tecplot v. 10, this function has ben superseded by TecUtilStyleSetLowLevelX(). The parameters to TecUtilStyleSetLowLevel() mimic the Macro Frame SetValue Commands and Macro General SetValue Commands described in the Tecplot Reference Manual.
| TextFieldWidget | Under Windows, this parameter is not allowed and must be set to NULL.Under Motif, if the value is coming from a text field and you supply the text field's name to TecUtilStyleSetLowLevel(), the following will happen: It will parse the value in the text field for you.Tecplot will repair the text field if the input value is invalid | |
| DValue | If the attribute to be assigned requires a floating point value and TextFieldWidget is set to NULL then DValue is used as the value to assign | |
| IValue | If the attribute to be assigned requires an integer, an enumerated value, or is a handle to a string, and, TextFieldWidget is set to NULL then IValue is used as the value to assign | |
| SetOrOffset | Some attributes require further definition on what to assign the incoming value to. When assigning to SV_FIELD attributes (that is, mesh color, scatter symbol size, and so forth) or to SV_LINEMAP attributes (that is, bar chart color, error bar type, and so forth). SetOrOffset is a Set_pa type.For field attributes it represents the set of zones to operate on and for Line-map attributes it represents the set of Line-maps to operate on. In a few other cases, SetOrOffset represents the offset into a list of items. For example, when assigning attributes for the third X-axis in an XY-plot, SetOrOffset is set to 3 | |
| AssignModifier | The possible values are: AssignOp_Equals: Assign the value directly to the attribute; AssignOp_PlusEquals: Add the value to the current attribute value; AssignOp_MinusEquals: Subtract the value from the current attribute value; AssignOp_TimesEquals: Multiply the value with the current attribute value; AssignOp_DivideEquals: Divide the current attribute value by the supplied value. | |
| P1 | The first parameter used to define the attribute to assign to. Attributes in Tecplot are defined hierarchically. These parameters follow the same order as you would use when constructing a macro command. These parameters are actually strings but you can use the supplied SV_XXXXX constants from the SV.h include file. Using the SV_ constants will help prevent misspellings and other errors | |
| P2 | The second parameter used to define the attribute to assign to. See P1. | |
| P3 | The third parameter used to define the attribute to assign to. See P1. | |
| P4 | The fourth parameter used to define the attribute to assign to. See P1. | |
| P5 | The fifth parameter used to define the attribute to assign to. See P1. | |
| P6 | The sixth parameter used to define the attribute to assign to. See P1. | |
| OkToRecord | Not used anymore. Always set to FALSE. |
SetValue_NoAttachedDatasetError
SetValue_NoAttachedFrameError
SetValue_NotAllowedInConfigError
SetValue_ValueRangeError
SetValue_ValueSyntaxError
SetValue_AssignOpError
SetValue_InvalidVarOrZone
SetValue_InternalMemoryError
SetValue_ContextError1
SetValue_ContextError2
Usually, a return value of SetValue_Ok or SetValue_DuplicateValue can be interpreted as being successful.
Fortran Syntax:
INTEGER*4 FUNCTION TecUtilStyleSetLowLevel( & TextFieldWidgetPtr, & DValue, & IValuePtr, & SetOrOffsetPtr, & AssignModifier, & P1, & P2, & P3, & P4, & P5, & P6, & OkToRecord) POINTER (TextFieldWidgetPtr, TextFieldWidget) REAL*8 DValue POINTER (IValuePtr, IValue) POINTER (SetOrOffsetPtr, SetOrOffset) INTEGER*4 AssignModifier CHARACTER*(*) P1 CHARACTER*(*) P2 CHARACTER*(*) P3 CHARACTER*(*) P4 CHARACTER*(*) P5 CHARACTER*(*) P6 INTEGER*4 OkToRecord
Python Syntax:
This function is not supported in Python.
Call TecUtilStyleSetLowLevel() to assign the color red to the text on the second Y-axis in an XY-plot.
From the reference manual (or by recording a macro) we see that the macro command to accomplish this feat is:
$!XYAXIS YDETAIL 2 { TICKLABEL { COLOR = BLUE } }
The corresponding call to TecUtilStyleSetLowLevel() is then:
S = TecUtilStyleSetLowLevel((Widget)NULL, 0.0, // Not Used (ArbParam_t)Blue_C, (ArbParam_t)2, // second Y-Axis AssignOp_Equals, SV_XYAXIS, SV_YDETAIL, SV_TICKLABEL, SV_COLOR, (char *)NULL, (char *)NULL, TRUE);
From the Tecplot Reference Manual (or by recording a macro) we see that the macro command to accomplish this feat is:
$!FIELD [1-3,7,9] POINTS { IJKSKIP { I = 2 } }
The corresponding call to TecUtilStyleSetLowLevel() is then:
Set_pa ZoneSet; SetValueReturnCode_e SVRC; ZoneSet = TecUtilSetAlloc(FALSE); TecUtilSetAddMember(ZoneSet,1,FALSE); TecUtilSetAddMember(ZoneSet,2,FALSE); TecUtilSetAddMember(ZoneSet,3,FALSE); TecUtilSetAddMember(ZoneSet,7,FALSE); TecUtilSetAddMember(ZoneSet,9,FALSE);
For the following
$!Field [zoneset] Points {IJKSkip {I = (LgIndex_t)}}
use the corresponding TecUtilStyleSetLowLevel() call:
SVRC = TecUtilStyleSetLowLevel((Widget)NULL, 0.0, // Not used (ArbParam_t)2, // Vector Skip (ArbParam_t)ZoneSet, AssignOp_Equals, SV_FIELD, SV_POINTS, SV_IJKSKIP, SV_I, (char *)NULL, (char *)NULL, FALSE);
The above task could also be accomplished by using the convenience function TecUtilZoneSetVectorIJKSkip() as follows:
S = TecUtilZoneSetVectorIJKSkip(SV_I, ZoneSet, 2);
Call TecUtilStyleSetLowLevel() to assign the I-Skip to 2 for vectors and scatter symbols in zones 1-3, 7, and 9.
From the Tecplot Reference Manual (or by recording a macro) we see that the macro command to accomplish this feat is:
$!FIELD [1-3,7,9] POINTS { IJKSKIP { I = 2 } }
The corresponding call to TecUtilStyleSetLowLevel() is then:
Set_pa ZoneSet; SetValueReturnCode_e SVRC; ZoneSet = TecUtilSetAlloc(FALSE); TecUtilSetAddMember(ZoneSet,1,FALSE); TecUtilSetAddMember(ZoneSet,2,FALSE); TecUtilSetAddMember(ZoneSet,3,FALSE); TecUtilSetAddMember(ZoneSet,7,FALSE); TecUtilSetAddMember(ZoneSet,9,FALSE);
For the following
$!Field [zoneset] Points {IJKSkip {I = (LgIndex_t)}}
use the corresponding TecUtilStyleSetLowLevel() call:
SVRC = TecUtilStyleSetLowLevel((Widget)NULL, 0.0, // Not used (ArbParam_t)2, // Vector Skip (ArbParam_t)ZoneSet, AssignOp_Equals, SV_FIELD, SV_POINTS, SV_IJKSKIP, SV_I, (char *)NULL, (char *)NULL, FALSE);
The above task could also be accomplished by using the convenience function TecUtilZoneSetVectorIJKSkip() as follows:
S = TecUtilZoneSetVectorIJKSkip(SV_I, ZoneSet, 2);
FORTRAN EXAMPLE: Set Surfaces to plot to be I-Planes for zone 2.
Call TecUtilSetAlloc(IShowErr,ZoneListPtr) IErr = TecUtilSetAddMember(ZoneListPtr,2,IShowErr) C C ... Must use a pointer to ship IValue because call stack expects C ... argument the size of a pointer. C IValuePtr = SurfacesToPlot_IPlanes ISVRC = TecUtilStyleSetLowLevel(LocalNullPtr, & 0.0D0, & IValuePtr, & ZoneListPtr, & AssignOp_Equals, & 'FIELD'//char(0), & 'SURFACES'//char(0), & 'SURFACESTOPLOT'//char(0), & char(0), & char(0), & char(0), & FALSE) Call TecUtilSetDealloc(ZoneListPtr)
| SetValueReturnCode_e TecUtilStyleSetLowLevelX | ( | ArgList_pa | ArgList | ) |
Low level function used to set most frame and base attribute values in Tecplot.
Use this function only if you cannot find an appropriate convenience function that will do the job. The parameters to TecUtilStyleSetLowLevelX() mimic the Macro Frame SetValue Commands and Macro General SetValue Commands described in the Tecplot Reference Manual.
| ArgList | Set of Arglist entries. This is built using calls to TecUtilArgListAppendXXXX functions. Arglist Values SV_P1
SV_P2
SV_P3
SV_P4
SV_P5
SV_P6
SV_OBJECTSET
SV_OFFSET1
SV_OFFSET2
SV_ASSIGNMODIFIER
SV_DVALUE
SV_IVALUE
SV_STRVALUE
|
INTEGER*4 FUNCTION TecUtilStyleSetLowLevelX(ArgListPtr) POINTER (ArgListPtr, ArgList)
Python Syntax:
Results = TecUtil.StyleSetLowLevelX(ArgList)
Input:
ArgList dictionary
Output:
Results[0] ReturnVal SetValueReturnCode_e (defined in TecVals.py)
Set the contour variable of the second contour group to variable number 4:
TecUtilLockStart(AddOnID); ArgList = TecUtilArgListAlloc(); if (ArgList != NULL) { SetValueReturnCode_e SVRC; TecUtilArgListClear(ArgList); TecUtilArgListAppendString(ArgList, SV_P1, SV_GLOBALCONTOUR); TecUtilArgListAppendString(ArgList, SV_P2, SV_VAR) TecUtilArgListAppendInt(ArgList, SV_OFFSET1, 2); // contour group TecUtilArgListAppendArbParam(ArgList, SV_IVALUE, 4); // variable SVRC = TecUtilStyleSetLowLevelX(ArgList); // A more conventient way to do this is to use the // TecUtilContourSetVariableX() function. TecUtilArgListClear(ArgList); TecUtilArgListAppendInt(ArgList, SV_CONTOURGROUP, 2); TecUtilArgListAppendInt(ArgList, SV_VAR, 4); SVRC = TecUtilContourSetVariableX(ArgList); TecUtilArgListDealloc(&ArgList); } TecUtilLockFinish(AddOnID);
FORTRAN EXAMPLE:
This will set the value blanking condition cutoff value to be V3 >= 0.6
Using the "X" function we have the following arglist entries are available:
Name Type
-------------------------------
'P1' string
'P2' string
'P3' string
'P4' string
'P5' string
'P6' string
'OBJECTSET' Set_pa
'OFFSET1' LgIndex_t
'OFFSET2' LgIndex_t
'ASSIGNMODIFIER' AssignOp_e
'DVALUE' double
'IVALUE' ArbParam_t
C
C ... Set the value blanking variable to 3
C
Call TecUtilArgListAlloc(ArgListPtr)
IErr = TecUtilArgListAppendString(ArgListPtr,
& 'P1'//char(0),
& 'BLANKING'//char(0))
IErr = TecUtilArgListAppendString(ArgListPtr,
& 'P2'//char(0),
& 'VALUE'//char(0))
IErr = TecUtilArgListAppendString(ArgListPtr,
& 'P3'//char(0),
& 'CONSTRAINT'//char(0))
IErr = TecUtilArgListAppendString(ArgListPtr,
& 'P4'//char(0),
& 'VARA'//char(0))
IErr = TecUtilArgListAppendInt( ArgListPtr,
& 'OFFSET1'//char(0),
& 1)
IValuePtr = 3
IErr = TecUtilArgListAppendArbParam( ArgListPtr,
& 'IVALUE'//char(0),
& IValuePtr)
write(*,*) 'setting constraint vara'
IRet = TecUtilStyleSetLowLevelX(ArgListPtr)
Call TecUtilArgListDealloc(ArgListPtr)
C
C ... Set cutoff value.
C
Call TecUtilArgListAlloc(ArgListPtr)
IErr = TecUtilArgListAppendString(ArgListPtr,
& 'P1'//char(0),
& 'BLANKING'//char(0))
IErr = TecUtilArgListAppendString(ArgListPtr,
& 'P2'//char(0),
& 'VALUE'//char(0))
IErr = TecUtilArgListAppendString(ArgListPtr,
& 'P3'//char(0),
& 'CONSTRAINT'//char(0))
IErr = TecUtilArgListAppendString(ArgListPtr,
& 'P4'//char(0),
& 'VALUECUTOFF'//char(0))
IErr = TecUtilArgListAppendInt( ArgListPtr,
& 'OFFSET1'//char(0),
& 1)
IErr = TecUtilArgListAppendDouble( ArgListPtr,
& 'DVALUE'//char(0),
& 0.6D0)
write(*,*) 'setting constraint value cut-off'
IRet = TecUtilStyleSetLowLevelX(ArgListPtr)
Call TecUtilArgListDealloc(ArgListPtr)
| Text_ID TecUtilText3DCreate | ( | double | PosX, | |
| double | PosY, | |||
| double | PosZ, | |||
| Units_e | HeightUnits, | |||
| double | Height, | |||
| const char * | Text | |||
| ) |
Create a 3D text label in Tecplot.
| PosX | The X-position of the text label. | |
| PosY | The Y-position of the text label. | |
| PosZ | The Z-position of the text label. | |
| HeightUnits | The units to use for the text height. | |
| Height | The height of the text. | |
| Text | The text character string. |
SUBROUTINE TecUtilText3DCreate( & PosX, & PosY, & PosZ, & HeightUnits, & Height, & Text, & ResultPtr) REAL*8 PosX REAL*8 PosY REAL*8 PosZ INTEGER*4 HeightUnits REAL*8 Height CHARACTER*(*) Text POINTER (ResultPtr, Result)
Python Syntax:
Results = TecUtil.Text3DCreate(PosX, PosY, PosZ, HeightUnits, Height, Text)
Input:
PosX double
PosY double
PosZ double
HeightUnits Units_e (defined in TecVals.py)
Height double
Text string
Output:
Results[0] ReturnVal long
| ColorIndex_t TecUtilTextBoxGetColor | ( | Text_ID | TID | ) |
Get the line color of the box surrounding the text object.
| TID | Handle to a text object. |
INTEGER*4 FUNCTION TecUtilTextBoxGetColor(TIDPtr) POINTER(TIDPtr, TID)
Python Syntax:
Results = TecUtil.TextBoxGetColor(TID)
Input:
TID long
Output:
Results[0] ReturnVal TecVals color constant
| ColorIndex_t TecUtilTextBoxGetFillColor | ( | Text_ID | TID | ) |
Get the fill color of the box surrounding the text object.
| TID | Handle to a text object. |
INTEGER*4 FUNCTION TecUtilTextBoxGetFillColor(TIDPtr) POINTER(TIDPtr, TID)
Python Syntax:
Results = TecUtil.TextBoxGetFillColor(TID)
Input:
TID long
Output:
Results[0] ReturnVal TecVals color constant
| double TecUtilTextBoxGetLineThickness | ( | Text_ID | TID | ) |
Get the line thickness of the text box border.
| TID | Handle to a text object. |
REAL*8 FUNCTION TecUtilTextBoxGetLineThickness(TIDPtr) POINTER(TIDPtr, TID)
Python Syntax:
Results = TecUtil.TextBoxGetLineThickness(TID)
Input:
TID long
Output:
Results[0] ReturnVal double
| double TecUtilTextBoxGetMargin | ( | Text_ID | TID | ) |
Get the margin between the text and the box surrounding the text object.
| TID | Handle to a text object. |
REAL*8 FUNCTION TecUtilTextBoxGetMargin(TIDPtr) POINTER(TIDPtr, TID)
Python Syntax:
Results = TecUtil.TextBoxGetMargin(TID)
Input:
TID long
Output:
Results[0] ReturnVal double
| void TecUtilTextBoxGetPosition | ( | Text_ID | T, | |
| double * | X1, | |||
| double * | Y1, | |||
| double * | X2, | |||
| double * | Y2, | |||
| double * | X3, | |||
| double * | Y3, | |||
| double * | X4, | |||
| double * | Y4 | |||
| ) |
Get the position of the four corners of the box surrounding the text object.
| T | Handle to a text object. | |
| X1 | Returned X-Coordinate for bottom left corner of the text box. | |
| Y1 | Returned Y-Coordinate for bottom left corner of the text box. | |
| X2 | Returned X-Coordinate for bottom right corner of the text box. | |
| Y2 | Returned Y-Coordinate for bottom right corner of the text box. | |
| X3 | Returned X-Coordinate for upper right corner of the text box. | |
| Y3 | Returned Y-Coordinate for upper right corner of the text box. | |
| X4 | Returned X-Coordinate for upper left corner of the text box. | |
| Y4 | Returned Y-Coordinate for upper left corner of the text box. |
SUBROUTINE TecUtilTextBoxGetPosition( & T, & X1, & Y1, & X2, & Y2, & X3, & Y3, & X4, & Y4) INTEGER*4 T REAL*8 X1 REAL*8 Y1 REAL*8 X2 REAL*8 Y2 REAL*8 X3 REAL*8 Y3 REAL*8 X4 REAL*8 Y4
Python Syntax:
Results = TecUtil.TextBoxGetPosition(T)
Input:
T long
Output:
Results[0] X1 double
Results[1] Y1 double
Results[2] X2 double
Results[3] Y2 double
Results[4] X3 double
Results[5] Y3 double
Results[6] X4 double
Results[7] Y4 double
Obtain the four corners of the text referenced by T.
// variable T of type Text_ID already obtained at this point. double X1,Y1,X2,Y2,X3,Y3,X4,Y4; TecUtilTextBoxGetPosition(T,&X1,&Y1,&X2,&Y2,&X3,&Y3,&X4,&Y4);
Get the type of the box surrounding the text object.
| TID | Handle to a text object. |
INTEGER*4 FUNCTION TecUtilTextBoxGetType(TIDPtr) POINTER(TIDPtr, TID)
Python Syntax:
Results = TecUtil.TextBoxGetType(TID)
Input:
TID long
Output:
Results[0] ReturnVal TextBox_e (defined in TecVals.py)
| void TecUtilTextBoxSetColor | ( | Text_ID | TID, | |
| ColorIndex_t | BoxColor | |||
| ) |
Set the line color for the box surrounding a text object.
| TID | Handle to a text object. | |
| BoxColor | Line color of the box. The possible values are: Black_C, Blue_C, Red_C, Green_C, Cyan_C, Purple_C, Yellow_C, White_C, CustomXX_C where XX is in the range 1-64. |
SUBROUTINE TecUtilTextBoxSetColor( & TIDPtr, & BoxColor) POINTER (TIDPtr, TID) INTEGER*4 BoxColor
Python Syntax:
Results = TecUtil.TextBoxSetColor(TID, BoxColor)
Input:
TID long
BoxColor TecVals color constant
Output:
Results[0] ReturnVal NONE
Create a boxed text label with the box color set to red.
Text_ID Text; Text = TecUtilTextCreate(CoordSys_Frame,50.0,50.0,Units_Point, 30.0,"Hi Mom"); TecUtilTextBoxSetType(Text, TextBox_Hollow); TecUtilTextBoxSetColor(Text, Red_C);
| void TecUtilTextBoxSetFillColor | ( | Text_ID | TID, | |
| ColorIndex_t | BoxFillColor | |||
| ) |
Set the fill color of the box surrounding a text object.
| TID | Handle to a text object. | |
| BoxFillColor | Fill color of the box. The possible values are: Black_C, Blue_C, Red_C, Green_C, Cyan_C, Purple_C, Yellow_C, White_C, CustomXX_C where XX is in the range 1-64. |
SUBROUTINE TecUtilTextBoxSetFillColor( & TIDPtr, & BoxFillColor) POINTER (TIDPtr, TID) INTEGER*4 BoxFillColor
Python Syntax:
Results = TecUtil.TextBoxSetFillColor(TID, BoxFillColor)
Input:
TID long
BoxFillColor TecVals color constant
Output:
Results[0] ReturnVal NONE
Create a filled boxed text label with a fill color of blue.
Text_ID Text; Text = TecUtilTextCreate(CoordSys_Frame,50.0,50.0,Units_Point,30.0, "Hi Mom"); TecUtilTextBoxSetType(Text, TextBox_Filled); TecUtilTextBoxSetColor(Text, Blue_C);
| void TecUtilTextBoxSetLineThickness | ( | Text_ID | TID, | |
| double | LineThickness | |||
| ) |
Set the line thickness of the box surrounding the text object.
| TID | Handle to a text object. | |
| LineThickness | Line thickness of the box, in frame units |
SUBROUTINE TecUtilTextBoxSetLineThickness( & TIDPtr, & LineThickness) POINTER (TIDPtr, TID) REAL*8 LineThickness
Python Syntax:
Results = TecUtil.TextBoxSetLineThickness(TID, LineThickness)
Input:
TID long
LineThickness double
Output:
Results[0] ReturnVal NONE
| void TecUtilTextBoxSetMargin | ( | Text_ID | TID, | |
| double | Margin | |||
| ) |
Set the margin between the text and the box surrounding the text object.
| TID | Handle to a text object. | |
| Margin | Margin between the text and the box in percentage of the text height |
SUBROUTINE TecUtilTextBoxSetMargin( & TIDPtr, & Margin) POINTER (TIDPtr, TID) REAL*8 Margin
Python Syntax:
Results = TecUtil.TextBoxSetMargin(TID, Margin)
Input:
TID long
Margin double
Output:
Results[0] ReturnVal NONE
Create a boxed text label with a box margin of 60 percent of the height of the text:
Text_ID Text; Text = TecUtilTextCreate(CoordSys_Frame,50.0,50.0,Units_Points,30.0, "Hi Mom"); TecUtilTextBoxSetType(Text, TextBox_Hollow); TecUtilTextBoxSetMargin(Text, 60.0);
Set the type of the box surrounding the text object.
| TID | Handle to a text object. | |
| TextBoxType | Text box type. The possible values are: TextBox_None, TextBox_Filled, TextBox_Hollow |
SUBROUTINE TecUtilTextBoxSetType( & TIDPtr, & TextBoxType) POINTER (TIDPtr, TID) INTEGER*4 TextBoxType
Python Syntax:
Results = TecUtil.TextBoxSetType(TID, TextBoxType)
Input:
TID long
TextBoxType TextBox_e (defined in TecVals.py)
Output:
Results[0] ReturnVal NONE
Create a hollow boxed text label.
Text_ID Text; Text = TecUtilTextCreate(CoordSys_Frame,50.0,50.0,Units_Points, 30.0,"Hi Mom"); TecUtilTextBoxSetType(Text, TextBox_Hollow);
| Text_ID TecUtilTextCreate | ( | CoordSys_e | PositionCoordSys, | |
| double | PosX, | |||
| double | PosY, | |||
| Units_e | HeightUnits, | |||
| double | Height, | |||
| const char * | Text | |||
| ) |
Creates a text object.
Use the handle obtained from this function to set text attributes using the TecUtilTextSetXxx functions. Units are in frame coordinates by default.
| PositionCoordSys | Coordinate system used to position the text object. The possible values are: CoordSys_Grid or CoordSys_Frame | |
| PosX | X-Coordinate for anchor position of the text in the specified PositionCoordSys coordinate system. | |
| PosY | Y-Coordinate for anchor position of the text in the specified PositionCoordSys coordinate system. | |
| HeightUnits | Units for the character height of the text. If PositionCoordSys is CoordSys_Frame, units must be Units_Frame or Units_Point. If PositionCoordSys is CoordSys_Grid, units must be Units_Frame or Units_Grid. | |
| Height | Character height of the text in the specified HeightUnits units | |
| Text | String to use to create the text object. Cannot be NULL |
SUBROUTINE TecUtilTextCreate( & PositionCoordSys, & PosX, & PosY, & HeightUnits, & Height, & Text, & ResultPtr) INTEGER*4 PositionCoordSys REAL*8 PosX REAL*8 PosY INTEGER*4 HeightUnits REAL*8 Height CHARACTER*(*) Text POINTER (ResultPtr, Result)
Python Syntax:
Results = TecUtil.TextCreate(PositionCoordSys, PosX, PosY, HeightUnits, Height, Text)
Input:
PositionCoordSys CoordSys_e (defined in TecVals.py)
PosX double
PosY double
HeightUnits Units_e (defined in TecVals.py)
Height double
Text string
Output:
Results[0] ReturnVal long
Create a simple text label:
Text_ID Text; Text = TecUtilTextCreate(CoordSys_Frame, 50.0, 50.0, Units_Point, 30.0, "Hello");
| void TecUtilTextDelete | ( | Text_ID | TID | ) |
Deletes the specified text object.
| TID | Handle to a text object |
SUBROUTINE TecUtilTextDelete(TIDPtr) POINTER(TIDPtr, TID)
Python Syntax:
Results = TecUtil.TextDelete(TID)
Input:
TID long
Output:
Results[0] ReturnVal NONE
Delete the first text object from the list of text objects maintained by the current frame.
Text_ID Text; Text = TecUtilTextGetBase(); if (Text != TECUTILBADID) { TecUtilTextDelete(Text); }
| TextAnchor_e TecUtilTextGetAnchor | ( | Text_ID | TID | ) |
Get the text anchor style.
| TID | Handle to a text object |
INTEGER*4 FUNCTION TecUtilTextGetAnchor(TIDPtr) POINTER(TIDPtr, TID)
Python Syntax:
Results = TecUtil.TextGetAnchor(TID)
Input:
TID long
Output:
Results[0] ReturnVal TextAnchor_e (defined in TecVals.py)
| void TecUtilTextGetAnchorPos | ( | Text_ID | TID, | |
| double * | XOrThetaPos, | |||
| double * | YOrRPos, | |||
| double * | ZPos | |||
| ) |
Get the anchor coordinate position of the text object in the current coordinate system.
| TID | Handle to a text object | |
| XOrThetaPos | Pointer to the text object's X or Theta anchor position. | |
| YOrRPos | Pointer to the text object's Y or R (radius) anchor position | |
| ZPos | Pointer to the text object's anchor Z position. |
SUBROUTINE TecUtilTextGetAnchorPos( & TIDPtr, & XOrThetaPos, & YOrRPos, & ZPos) POINTER (TIDPtr, TID) REAL*8 XOrThetaPos REAL*8 YOrRPos REAL*8 ZPos
Python Syntax:
Results = TecUtil.TextGetAnchorPos(TID)
Input:
TID long
Output:
Results[0] XOrThetaPos double
Results[1] YOrRPos double
Results[2] ZPos double
Text_ID Text;
double XOrThetaPos; double YOrRPos; double ZPos; // use TecUtilTextDelete() when 'Text' is no longer needed Text = TecUtilTextCreate(CoordSys_Frame, 50.0, 50.0, Units_Point,30.0, "Hello"); if (Text != TECUTILBADID) { // do all sorts of things . . . // get the current anchor position of the text TecUtilTextGetAnchorPos(Text, &XOrThetaPos, &YOrRPos, &ZPos); }
| double TecUtilTextGetAngle | ( | Text_ID | TID | ) |
Get the text angle.
| TID | Handle to a text object |
REAL*8 FUNCTION TecUtilTextGetAngle(TIDPtr) POINTER(TIDPtr, TID)
Python Syntax:
Results = TecUtil.TextGetAngle(TID)
Input:
TID long
Output:
Results[0] ReturnVal double
| Text_ID TecUtilTextGetBase | ( | void | ) |
Get the first text object from the list of text objects maintained by the current frame.
SUBROUTINE TecUtilTextGetBase(ResultPtr) POINTER (ResultPtr, Result)
Python Syntax:
Results = TecUtil.TextGetBase()
Output:
Results[0] ReturnVal long
Examine all text labels in the current frame and see if any of them are red.
TextID Text; for (Text = TecUtilTextGetBase(); Text != TECUTILBADID; Text = TecUtilTextGetNext(Text)) { if (TecUtilTextGetColor(Text) == Red_C) { // do something with the red text } }
| Clipping_e TecUtilTextGetClipping | ( | Text_ID | TID | ) |
Get the clipping properties of a text object.
| TID | ID of the text object |
INTEGER*4 FUNCTION TecUtilTextGetClipping(TID) INTEGER*4 TID
Python Syntax:
Results = TecUtil.TextGetClipping(TID)
Input:
TID long
Output:
Results[0] ReturnVal Clipping_e (defined in TecVals.py)
| ColorIndex_t TecUtilTextGetColor | ( | Text_ID | TID | ) |
Get the color of the text object.
| TID | Handle to a text object |
INTEGER*4 FUNCTION TecUtilTextGetColor(TIDPtr) POINTER(TIDPtr, TID)
Python Syntax:
Results = TecUtil.TextGetColor(TID)
Input:
TID long
Output:
Results[0] ReturnVal TecVals color constant
Get the font used for the text object.
| TID | Handle to a text object. |
INTEGER*4 FUNCTION TecUtilTextGetFont(TIDPtr) POINTER(TIDPtr, TID)
Python Syntax:
Results = TecUtil.TextGetFont(TID)
Input:
TID long
Output:
Results[0] ReturnVal Font_e (defined in TecVals.py)
| double TecUtilTextGetHeight | ( | Text_ID | TID | ) |
Get the text height in the currently defined text size units.
| TID | Handle to a text object. |
REAL*8 FUNCTION TecUtilTextGetHeight(TIDPtr) POINTER(TIDPtr, TID)
Python Syntax:
Results = TecUtil.TextGetHeight(TID)
Input:
TID long
Output:
Results[0] ReturnVal double
| double TecUtilTextGetLineSpacing | ( | Text_ID | TID | ) |
Get the spacing between lines of text.
| TID | Handle to a text object. |
REAL*8 FUNCTION TecUtilTextGetLineSpacing(TIDPtr) POINTER(TIDPtr, TID)
Python Syntax:
Results = TecUtil.TextGetLineSpacing(TID)
Input:
TID long
Output:
Results[0] ReturnVal double
Get the macro function command string associated with the text object.
| TID | Handle to a text object. | |
| MacroFunctionCommand | Handle to a macro function command string. The result must be deallocated with TecUtilStringDealloc() when it is no longer needed |
INTEGER*4 FUNCTION TecUtilTextGetMacroFunctionCmd( & TIDPtr, & MacroFunctionCommand, & MacroFunctionCommandLength) POINTER (TIDPtr, TID) CHARACTER*(*) MacroFunctionCommand INTEGER*4 MacroFunctionCommandLength
Python Syntax:
Results = TecUtil.TextGetMacroFunctionCmd(TID)
Input:
TID long
Output:
Results[0] ReturnVal boolean
Results[1] MacroFunctionCommand string
Boolean_t IsOk;
Text_ID Text; char *MacroCommand = NULL; . . . // get the text's associated macro command IsOk = TecUtilTextGetMacroFunctionCmd(Text, &MacroCommand); if (IsOk) { // do something with command . . . // cleanup; macro command no longer needed TecUtilStringDealloc(&MacroCommand); }
Get the next text object, relative to the specified text object, from the list of text objects maintained by the current frame.
| TID | Handle to a text object. |
SUBROUTINE TecUtilTextGetNext( & TIDPtr, & ResultPtr) POINTER (TIDPtr, TID) POINTER (ResultPtr, Result)
Python Syntax:
Results = TecUtil.TextGetNext(TID)
Input:
TID long
Output:
Results[0] ReturnVal long
| CoordSys_e TecUtilTextGetPositionCoordSys | ( | Text_ID | TID | ) |
Get the coordinate system to which the text is associated.
| TID | Handle to a text object. |
INTEGER*4 FUNCTION TecUtilTextGetPositionCoordSys(TIDPtr) POINTER(TIDPtr, TID)
Python Syntax:
Results = TecUtil.TextGetPositionCoordSys(TID)
Input:
TID long
Output:
Results[0] ReturnVal CoordSys_e (defined in TecVals.py)
Get the previous text object, relative to the specified text object, from the list of text objects maintained by the current frame.
| TID | Handle to a text object defined in the current frame. |
SUBROUTINE TecUtilTextGetPrev( & TIDPtr, & ResultPtr) POINTER (TIDPtr, TID) POINTER (ResultPtr, Result)
Python Syntax:
Results = TecUtil.TextGetPrev(TID)
Input:
TID long
Output:
Results[0] ReturnVal long
Get the scope of the text object.
Text with local scope is displayed only in the frame in which it is created. If the text is defined as having global scope it will appear in all "like" frames, that is, those frames using the same data set as the one in which the text was created.
| TID | Handle to a text object. |
INTEGER*4 FUNCTION TecUtilTextGetScope(TIDPtr) POINTER(TIDPtr, TID)
Python Syntax:
Results = TecUtil.TextGetScope(TID)
Input:
TID long
Output:
Results[0] ReturnVal Scope_e (defined in TecVals.py)
Get the size units for the text object.
| TID | Handle to a text object. |
INTEGER*4 FUNCTION TecUtilTextGetSizeUnits(TIDPtr) POINTER(TIDPtr, TID)
Python Syntax:
Results = TecUtil.TextGetSizeUnits(TID)
Input:
TID long
Output:
Results[0] ReturnVal Units_e (defined in TecVals.py)
Get the string associated with the text object.
| TID | Handle to a text object. | |
| TextString | String of the text object. Result must be deallocated with TecUtilStringDealloc() when no longer needed. |
INTEGER*4 FUNCTION TecUtilTextGetString( & TIDPtr, & TextString, & TextStringLength) POINTER (TIDPtr, TID) CHARACTER*(*) TextString INTEGER*4 TextStringLength
Python Syntax:
Results = TecUtil.TextGetString(TID)
Input:
TID long
Output:
Results[0] ReturnVal boolean
Results[1] TextString string
Text_ID Text;
Boolean_t IsOk = FALSE; char *TextString = NULL; Text = TecUtilTextCreate(CoordSys_Frame,50.0, 50.0, Units_Point, 30.0, "Hello"); if (Text != TECUTILBADID) { // do some things with the text . . . // change the string of the text object TecUtilTextSetString(Text, "Hello World"); // do some more things . . . // print the contents of the text // string to standard output IsOk = TecUtilTextGetString(Text, &TextString); if (IsOk) { printf("%s\n", TextString); TecUtilStringDealloc(&TextString); } }
| void TecUtilTextGetXYPos | ( | Text_ID | TID, | |
| double * | XPos, | |||
| double * | YPos | |||
| ) |
| EntIndex_t TecUtilTextGetZoneOrMap | ( | Text_ID | TID | ) |
Get the zone or map with which the text object is associated (if it is attached).
| TID | Handle to a text object. |
INTEGER*4 FUNCTION TecUtilTextGetZoneOrMap(TIDPtr) POINTER(TIDPtr, TID)
Python Syntax:
Results = TecUtil.TextGetZoneOrMap(TID)
Input:
TID long
Output:
Results[0] ReturnVal int
Determine if the text object is attached to a zone or map.
| TID | Handle to a text object. |
INTEGER*4 FUNCTION TecUtilTextIsAttached(TIDPtr) POINTER(TIDPtr, TID)
Python Syntax:
Results = TecUtil.TextIsAttached(TID)
Input:
TID long
Output:
Results[0] ReturnVal boolean
Determine if the text object is valid in the current frame context.
| TID | Handle to a text object. |
INTEGER*4 FUNCTION TecUtilTextIsValid(TIDPtr) POINTER(TIDPtr, TID)
Python Syntax:
Results = TecUtil.TextIsValid(TID)
Input:
TID long
Output:
Results[0] ReturnVal boolean
| void TecUtilTextSetAnchor | ( | Text_ID | TID, | |
| TextAnchor_e | Anchor | |||
| ) |
Set the anchor style for a text object.
| TID | Handle to a text object. | |
| Anchor | Anchor style. The possible values are: TextAnchor_Left, TextAnchor_Center, TextAnchor_Right, TextAnchor_MidLeft, TextAnchor_MidCenter, TextAnchor_MidRight, TextAnchor_HeadLeft, TextAnchor_HeadCenter, TextAnchor_HeadRight, TextAnchor_OnSide |
SUBROUTINE TecUtilTextSetAnchor( & TIDPtr, & Anchor) POINTER (TIDPtr, TID) INTEGER*4 Anchor
Python Syntax:
Results = TecUtil.TextSetAnchor(TID, Anchor)
Input:
TID long
Anchor TextAnchor_e (defined in TecVals.py)
Output:
Results[0] ReturnVal NONE
| void TecUtilTextSetAnchorPos | ( | Text_ID | TID, | |
| double | XOrThetaPos, | |||
| double | YOrRPos, | |||
| double | ZPos | |||
| ) |
Set the XY-position for the text object.
The text is always anchored in the coordinate system specified by TecUtilTextSetCoordSysAndUnits() each time the text object is drawn.
| TID | Handle to a text object. | |
| XOrThetaPos | The text object's X or Theta anchor position. | |
| YOrRPos | The text object's Y or R (radius) anchor position. | |
| ZPos | The text object's Z position. |
SUBROUTINE TecUtilTextSetAnchorPos( & TIDPtr, & XOrThetaPos, & YOrRPos, & ZPos) POINTER (TIDPtr, TID) REAL*8 XOrThetaPos REAL*8 YOrRPos REAL*8 ZPos
Python Syntax:
Results = TecUtil.TextSetAnchorPos(TID, XOrThetaPos, YOrRPos, ZPos)
Input:
TID long
XOrThetaPos double
YOrRPos double
ZPos double
Output:
Results[0] ReturnVal NONE
| void TecUtilTextSetAngle | ( | Text_ID | TID, | |
| double | Angle | |||
| ) |
Set the angle in degrees for a text object.
| TID | Handle to a text object. | |
| Angle | Text angle in degrees that must be between the inclusive angles of -360 and 360. |
SUBROUTINE TecUtilTextSetAngle( & TIDPtr, & Angle) POINTER (TIDPtr, TID) REAL*8 Angle
Python Syntax:
Results = TecUtil.TextSetAngle(TID, Angle)
Input:
TID long
Angle double
Output:
Results[0] ReturnVal NONE
Indicate if the text object should be attached to a zone or map.
| TID | Handle to a text object. | |
| Attached | Set to TRUE to attach, FALSE otherwise. |
SUBROUTINE TecUtilTextSetAttached( & TIDPtr, & Attached) POINTER (TIDPtr, TID) INTEGER*4 Attached
Python Syntax:
Results = TecUtil.TextSetAttached(TID, Attached)
Input:
TID long
Attached boolean
Output:
Results[0] ReturnVal NONE
| void TecUtilTextSetClipping | ( | Text_ID | TID, | |
| Clipping_e | Clipping | |||
| ) |
Set the clipping properties of a text object.
| TID | ID of the text object | |
| Clipping | New clipping property for the text object. The possible values are: Clipping_ClipToViewport and Clipping_ClipToFrame. |
SUBROUTINE TecUtilTextSetClipping( & TIDPtr, & Clipping) POINTER (TIDPtr, TID) INTEGER*4 Clipping
Python Syntax:
Results = TecUtil.TextSetClipping(TID, Clipping)
Input:
TID long
Clipping Clipping_e (defined in TecVals.py)
Output:
Results[0] ReturnVal NONE
Create a texts string "Test Text Object" and set the clipping to "ClipToFrame":
Text_ID TID; TID = TecUtilTextCreate(CoordSys_Frame,20,30, Units_Point, 15,"Test Text Object"); TecUtilTextSetClipping(t, Clipping_ClipToFrame);
| void TecUtilTextSetColor | ( | Text_ID | TID, | |
| ColorIndex_t | Color | |||
| ) |
Set the color of a text object.
| TID | Handle to a text object. | |
| Color | Text color. The possible values are: Black_C, Blue_C, Red_C, Green_C, Cyan_C, Purple_C, Yellow_C, White_C, Custom1_C, Custom2_C, Custom3_C, Custom4_C, Custom5_C, Custom6_C, Custom7_C, Custom8_C. |
SUBROUTINE TecUtilTextSetColor( & TIDPtr, & Color) POINTER (TIDPtr, TID) INTEGER*4 Color
Python Syntax:
Results = TecUtil.TextSetColor(TID, Color)
Input:
TID long
Color TecVals color constant
Output:
Results[0] ReturnVal NONE
| void TecUtilTextSetCoordSysAndUnits | ( | Text_ID | TID, | |
| CoordSys_e | PositionCoordSys, | |||
| Units_e | HeightUnits | |||
| ) |
Set the coordinate system for the position and the units for the character height of a text object.
The text object's position and text height are adjusted so that it remains identical to its visual appearance in the original coordinate and unit system.
| TID | Handle to the text object. | |
| PositionCoordSys | Coordinate system in which the text is positioned. The possible values are: CoordSys_Frame or CoordSys_Grid. | |
| HeightUnits | Units for the character height of the text. If CoordSys is CoordSys_Frame, units must be Units_Frame or Units_Point. If CoordSys is CoordSys_Grid, units must be Units_Frame or Units_Grid. |
SUBROUTINE TecUtilTextSetCoordSysAndUnits( & TIDPtr, & PositionCoordSys, & HeightUnits) POINTER (TIDPtr, TID) INTEGER*4 PositionCoordSys INTEGER*4 HeightUnits
Python Syntax:
Results = TecUtil.TextSetCoordSysAndUnits(TID, PositionCoordSys, HeightUnits)
Input:
TID long
PositionCoordSys CoordSys_e (defined in TecVals.py)
HeightUnits Units_e (defined in TecVals.py)
Output:
Results[0] ReturnVal NONE
Create a text which is positioned and sized in the grid coordinate system that reads "Hello." Then, change the text to be positioned and sized in the frame coordinate system :
Text_ID Text; Text = TecUtilTextCreate(CoordSys_Grid, 0.25, 0.25, Units_Grid, 0.25, "Hello."); if (Text != TECUTILBADID) { . . // Change the text position and size to // be in the frame coordinate system and // set the text position to be the center // of the frame coordinate system TecUtilTextSetCoordSysAndUnits(Text,CoordSys_Frame, Units_Frame); TecUtilTextSetXYPos(Text, 50.0, 50.0); . . TecUtilTextDelete(Text); }
Set the font for a text object.
| TID | Handle to the text object. | |
| Font | Text font. The possible values are: Font_Helvetica, Font_HelveticaBold, Font_Greek, Font_Math, Font_UserDefined, Font_Times, Font_TimesItalic, Font_TimesItalicBold, Font_TimesBold, Font_Courier, Font_CourierBold |
SUBROUTINE TecUtilTextSetFont( & TIDPtr, & Font) POINTER (TIDPtr, TID) INTEGER*4 Font
Python Syntax:
Results = TecUtil.TextSetFont(TID, Font)
Input:
TID long
Font Font_e (defined in TecVals.py)
Output:
Results[0] ReturnVal NONE
| void TecUtilTextSetHeight | ( | Text_ID | TID, | |
| double | Height | |||
| ) |
Set the character height for a text object.
| TID | Handle to the text object. | |
| Height | Character height in the current text size units. |
SUBROUTINE TecUtilTextSetHeight( & TIDPtr, & Height) POINTER (TIDPtr, TID) REAL*8 Height
Python Syntax:
Results = TecUtil.TextSetHeight(TID, Height)
Input:
TID long
Height double
Output:
Results[0] ReturnVal NONE
| void TecUtilTextSetLineSpacing | ( | Text_ID | TID, | |
| double | LineSpacing | |||
| ) |
Set the line spacing for a text object.
Line spacing is dependent on the height of the text and the size unit system in which it is drawn.
| TID | Handle to the text object. | |
| LineSpacing | Vertical spacing between multiple lines of a text object. Multiple lines are achieved by inserting newline (\n) characters within the string of the text object |
SUBROUTINE TecUtilTextSetLineSpacing( & TIDPtr, & LineSpacing) POINTER (TIDPtr, TID) REAL*8 LineSpacing
Python Syntax:
Results = TecUtil.TextSetLineSpacing(TID, LineSpacing)
Input:
TID long
LineSpacing double
Output:
Results[0] ReturnVal NONE
Set the macro function command associated with a text object.
| TID | Handle to the text object. | |
| Command | Macro function command string. |
INTEGER*4 FUNCTION TecUtilTextSetMacroFunctionCmd( & TIDPtr, & Command) POINTER (TIDPtr, TID) CHARACTER*(*) Command
Python Syntax:
Results = TecUtil.TextSetMacroFunctionCmd(TID, Command)
Input:
TID long
Command string
Output:
Results[0] ReturnVal boolean
Set the scope of the text object.
Text with local scope is displayed only in the frame in which it is created. If the text is defined as having global scope it will appear in all "like" frames, that is, those frames using the same data set as the one in which the text was created.
| TID | Handle to the text object. | |
| Scope | Text scope. The possible values are Scope_Local or Scope_Global. |
SUBROUTINE TecUtilTextSetScope( & TIDPtr, & Scope) POINTER (TIDPtr, TID) INTEGER*4 Scope
Python Syntax:
Results = TecUtil.TextSetScope(TID, Scope)
Input:
TID long
Scope Scope_e (defined in TecVals.py)
Output:
Results[0] ReturnVal NONE
Set the text string for a text object.
| TID | Handle to the text object. | |
| TextString | String copied into the text object. |
INTEGER*4 FUNCTION TecUtilTextSetString( & TIDPtr, & TextString) POINTER (TIDPtr, TID) CHARACTER*(*) TextString
Python Syntax:
Results = TecUtil.TextSetString(TID, TextString)
Input:
TID long
TextString string
Output:
Results[0] ReturnVal boolean
| void TecUtilTextSetXYPos | ( | Text_ID | TID, | |
| double | XPos, | |||
| double | YPos | |||
| ) |
| void TecUtilTextSetZoneOrMap | ( | Text_ID | TID, | |
| EntIndex_t | ZoneOrMap | |||
| ) |
Set the zone or map to which the text object is associated (if it is attached).
| TID | Handle to the text object. | |
| ZoneOrMap | Zone or Map. |
SUBROUTINE TecUtilTextSetZoneOrMap( & TIDPtr, & ZoneOrMap) POINTER (TIDPtr, TID) INTEGER*4 ZoneOrMap
Python Syntax:
Results = TecUtil.TextSetZoneOrMap(TID, ZoneOrMap)
Input:
TID long
ZoneOrMap int
Output:
Results[0] ReturnVal NONE
| double TecUtilThreeDViewGetNearZPlane | ( | void | ) |
Returns the Z-value below which you can no longer trust any values of TecUtilConvert3DPositionToGrid().
REAL*8 FUNCTION TecUtilThreeDViewGetNearZPlane()
Python Syntax:
Results = TecUtil.ThreeDViewGetNearZPlane()
Output:
Results[0] ReturnVal double
Convert from 3-D world coordinates to Tecplot's 3-D grid coordinates.
{
double ZPlaneFloor;
double X,Y,Z;
TecUtilLockStart(AddOnID);
TecUtilSetupTransformations();
ZPlaneFloor = TecUtilThreeDViewGetNearZPlane();
TecUtilConvert3DPositionToGrid(1.0,1.0,ZPlaneFloor,&X,&Y,&Z);
TecUtilLockFinish(AddOnID);
}
| void TecUtilThreeDViewGetProjection | ( | double * | FieldOfView, | |
| double * | ViewWidth, | |||
| Boolean_t * | IsInPerspective | |||
| ) |
Queries the 3-D view attributes.
| FieldOfView | Receives the amount of the plot (in terms of spherical arc) in front of the viewer which may be seen. You may pass NULL for this parameter | |
| ViewWidth | Receives the amount of the plot (in X-axis units) in front of the viewer which may be seen. You may pass NULL for this parameter. Zooming in or out of a 3-D orthographic plot changes this number, but not the viewer's position. | |
| IsInPerspective | Receives TRUE if Tecplot is drawing the plot with perspective projection, FALSE otherwise. You may pass NULL for this parameter |
SUBROUTINE TecUtilThreeDViewGetProjection( & FieldOfView, & ViewWidth, & IsInPerspective) REAL*8 FieldOfView REAL*8 ViewWidth INTEGER*4 IsInPerspective
Python Syntax:
Results = TecUtil.ThreeDViewGetProjection()
Output:
Results[0] FieldOfView double
Results[1] ViewWidth double
Results[2] IsInPerspective boolean
Query the 3-D view attributes.
{
double FieldOfView,WidthWidth;
Boolean_t IsInPerspective;
TecUtilLockStart(AddOnID);
TecUtilThreeDViewGetProjection(&FieldOfView,
&ViewWidth,
&IsInPerspective);
TecUtilLockFinish(AddOnID);
}
| void TecUtilThreeDViewGetViewerAngle | ( | double * | PsiAngle, | |
| double * | ThetaAngle, | |||
| double * | AlphaAngle | |||
| ) |
Queries the 3-D viewer angles.
| PsiAngle | Receives the Psi angle. May be NULL | |
| ThetaAngle | Recevies the Theta angle. May be NULL | |
| AlphaAngle | Receives the Alpha angle. May be NULL |
SUBROUTINE TecUtilThreeDViewGetViewerAngle( & PsiAngle, & ThetaAngle, & AlphaAngle) REAL*8 PsiAngle REAL*8 ThetaAngle REAL*8 AlphaAngle
Python Syntax:
Results = TecUtil.ThreeDViewGetViewerAngle()
Output:
Results[0] PsiAngle double
Results[1] ThetaAngle double
Results[2] AlphaAngle double
Query the 3-D view angles.
{
double P,T,A;
TecUtilLockStart(AddOnID);
TecUtilThreeDViewGetAngle(&P,&T,&A);
TecUtilLockFinish(AddOnID);
}
| void TecUtilThreeDViewGetViewerPos | ( | double * | XPos, | |
| double * | YPos, | |||
| double * | ZPos | |||
| ) |
Queries the 3-D viewer angles.
| XPos | Receives the viewer X-location | |
| YPos | Recevies the viewer Y-location | |
| ZPos | Receives the viewer Z-location |
SUBROUTINE TecUtilThreeDViewGetViewerPos( & XPos, & YPos, & ZPos) REAL*8 XPos REAL*8 YPos REAL*8 ZPos
Python Syntax:
Results = TecUtil.ThreeDViewGetViewerPos()
Output:
Results[0] XPos double
Results[1] YPos double
Results[2] ZPos double
Query the 3-D viewer position.
{
double XPos,YPos,ZPos;
TecUtilLockStart(AddOnID);
TecUtilThreeDViewGetViewerPos(&XPos,&YPos,&ZPos);
TecUtilLockFinish(AddOnID);
}
| Boolean_t TecUtilUndoCanUndo | ( | void | ) |
Determine if you can undo the last operation.
Results = TecUtil.UndoCanUndo()
Output:
Results[0] ReturnVal boolean
| Boolean_t TecUtilUndoDoUndo | ( | void | ) |
Undo the last operation.
Results = TecUtil.UndoDoUndo()
Output:
Results[0] ReturnVal boolean
| Boolean_t TecUtilViewAxisFit | ( | char | Axis, | |
| short | AxisNum | |||
| ) |
Reset the range on a specific axis so that it equals the minimum and maximum of the data being plotted.
If the axis dependency is not independent then this action may also affect the range on another axis.
| Axis | Valid values are 'X' or 'Y', or 'Z' | |
| AxisNum | If the frame mode is XY, then this can be a number between one and five. Otherwise, this must be set to one |
INTEGER*4 FUNCTION TecUtilViewAxisFit( & Axis, & AxisNum) CHARACTER*(*) Axis INTEGER*4 AxisNum
Python Syntax:
Results = TecUtil.ViewAxisFit(Axis, AxisNum)
Input:
Axis int
AxisNum int
Output:
Results[0] ReturnVal boolean
Reset the range on the Y-axis to fit the data being plotted:
TecUtilViewAxisFit('Y',1);
| Boolean_t TecUtilViewAxisMakeCurValsNice | ( | char | Axis, | |
| short | AxisNum | |||
| ) |
Makes the curently viewed axis values visually appealing.
| Axis | Valid values are 'X' or 'Y', or 'Z'. | |
| AxisNum | If the frame mode is XY, then this can be a number between one and five. Otherwise, this must be set to one |
INTEGER*4 FUNCTION TecUtilViewAxisMakeCurValsNice( & Axis, & AxisNum) CHARACTER*(*) Axis INTEGER*4 AxisNum
Python Syntax:
Results = TecUtil.ViewAxisMakeCurValsNice(Axis, AxisNum)
Input:
Axis int
AxisNum int
Output:
Results[0] ReturnVal boolean
| Boolean_t TecUtilViewAxisNiceFit | ( | char | Axis, | |
| short | AxisNum | |||
| ) |
Reset the range on a specific axis so that it equals a little more than the minimum and maximum of the data being plotted allowing a small border to enhance visual appeal.
If the axis dependency is not independent then this action may also affect the range on another axis.
| Axis | Valid values are 'X' or 'Y', or 'Z'. | |
| AxisNum | If the frame mode is XY, then this can be a number between one and five. Otherwise, this must be set to one |
INTEGER*4 FUNCTION TecUtilViewAxisNiceFit( & Axis, & AxisNum) CHARACTER*(*) Axis INTEGER*4 AxisNum
Python Syntax:
Results = TecUtil.ViewAxisNiceFit(Axis, AxisNum)
Input:
Axis int
AxisNum int
Output:
Results[0] ReturnVal boolean
| Boolean_t TecUtilViewCenter | ( | void | ) |
Center the data within the axis grid area.
INTEGER*4 FUNCTION TecUtilViewCenter()
Python Syntax:
Results = TecUtil.ViewCenter()
Output:
Results[0] ReturnVal boolean
| Boolean_t TecUtilViewCopy | ( | void | ) |
Copy the view from the current frame to the view paste buffer.
This view can later be pasted into any frame that uses the same frame mode as the current frame.
INTEGER*4 FUNCTION TecUtilViewCopy()
Python Syntax:
Results = TecUtil.ViewCopy()
Output:
Results[0] ReturnVal boolean
| Boolean_t TecUtilViewDataFit | ( | void | ) |
Fit the data being plotted within the axis grid area.
This does not take into consideration text or geometries.
INTEGER*4 FUNCTION TecUtilViewDataFit()
Python Syntax:
Results = TecUtil.ViewDataFit()
Output:
Results[0] ReturnVal boolean
| void TecUtilViewDealloc | ( | ViewState_pa * | ViewState | ) |
Deallocates a saved view returned by TecUtilViewGet and sets the pointer to NULL.
| ViewState | Pointer to the ViewState to be deallocated. |
SUBROUTINE TecUtilViewDealloc(ViewState) POINTER (ViewStatePtr, ViewState)
Python Syntax:
This function is not supported in Python.
// Save the current view ViewState_pa ViewState = TecUtilViewGet(); // ...do some other stuff which changes the view // Verify that the current view is the same type as // the saved view and restore the view if (TecUtilFrameGetPlotType() == TecUtilViewGetPlotType(ViewState) ) TecUtilViewSet(ViewState); TecUtilViewDealloc(&ViewState); // dealloc the object when finished
| Boolean_t TecUtilViewFit | ( | void | ) |
Fit the data being plotted within the axis grid area.
This also takes into consideration text and geometries that are plotted using the grid coordinate system.
INTEGER*4 FUNCTION TecUtilViewFit()
Python Syntax:
Results = TecUtil.ViewFit()
Output:
Results[0] ReturnVal boolean
| ViewState_pa TecUtilViewGet | ( | void | ) |
Saves a view for a plot type (2D, 3D, etc.
). The view can later be restored using the return value. You must call TecUtilViewDealloc() when you are finished with the returned view object. If the plot type is PlotType_Automatic, then the view cannot be restored.
// Save the current view ViewState_pa ViewState = TecUtilViewGet(); // ...do some other stuff which changes the view // Restore the saved view TecUtilViewSet(ViewState); TecUtilViewDealloc(&ViewState); // dealloc the object when finished
Fortran Syntax:
INTEGER*4 FUNCTION TecUtilMouseGetCurrentMode()
Python Syntax:
Results = TecUtil.ViewGet()
Output:
Results[0] ReturnVal opaque pointer
| Boolean_t TecUtilViewGetMagnification | ( | double * | Magnification | ) |
Get the current view magnification.
| Magnification | Returned magnification. |
INTEGER*4 FUNCTION TecUtilViewGetMagnification( & Magnification) REAL*8 Magnification
Python Syntax:
Results = TecUtil.ViewGetMagnification()
Output:
Results[0] ReturnVal boolean
Results[1] Magnification double
Get the current view magnification
double Magnification if (TecUtilViewGetMagnification(&Magnification)) { ... do something with Magnification. }
| PlotType_e TecUtilViewGetPlotType | ( | ViewState_pa | ViewState | ) |
Queries the plot type of a saved view object.
| ViewState | ViewState abstract pointer returned from TecUtilViewGet |
// Save the current view ViewState_pa ViewState = TecUtilViewGet(); // ...do some other stuff which changes the view // Verify that the current view is the same type as // the saved view and restore the view if (TecUtilFrameGetPlotType() == TecUtilViewGetPlotType(ViewState) ) TecUtilViewSet(ViewState); TecUtilViewDealloc(&ViewState); // dealloc the object when finished
Fortran Syntax:
INTEGER*4 FUNCTION TecUtilViewGetPlotType(ViewState) POINTER (ViewStatePtr, ViewState)
Python Syntax:
Results = TecUtil.ViewGetPlotType(ViewState)
Input:
ViewState opaque pointer
Output:
Results[0] ReturnVal PlotType_e (defined in TecVals.py)
| Boolean_t TecUtilViewLast | ( | void | ) |
Retrieve the previous view from the view stack.
Each frame mode within each frame maintains its own view stack.
INTEGER*4 FUNCTION TecUtilViewLast()
Python Syntax:
Results = TecUtil.ViewLast()
Output:
Results[0] ReturnVal boolean
| Boolean_t TecUtilViewMakeCurViewNice | ( | void | ) |
Give a border to the current view.
INTEGER*4 FUNCTION TecUtilViewMakeCurViewNice()
Python Syntax:
Results = TecUtil.ViewMakeCurViewNice()
Output:
Results[0] ReturnVal boolean
| Boolean_t TecUtilViewNiceFit | ( | void | ) |
Fit the data being plotted within the axis grid area leaving a determined border around the edge of the plot to make in more visually appealing.
This also takes into consideration text and geometries that are plotted using the grid coordinate system.
INTEGER*4 FUNCTION TecUtilViewNiceFit()
Python Syntax:
Results = TecUtil.ViewNiceFit()
Output:
Results[0] ReturnVal boolean
| Boolean_t TecUtilViewPaste | ( | void | ) |
Retrieve the view from the view paste buffer and assign it to the current frame.
INTEGER*4 FUNCTION TecUtilViewPaste()
Python Syntax:
Results = TecUtil.ViewPaste()
Output:
Results[0] ReturnVal boolean
| Boolean_t TecUtilViewPush | ( | void | ) |
Instruct Tecplot to push the current view onto the view stack associated with the frame mode for the current frame.
A view will not be pushed if the current view is the same as the top view on the stack. Functions TecUtilViewAxisFit(), TecUtilViewCenter(), TecUtilViewDataFit(), TecUtilViewFit(), and TecUtilViewZoom() automatically push a view onto the stack. Tecplot automatically pushes the current view onto the stack when a $!Redraw command or TecUtilRedraw() is issued and the current view is different from the top view on the view stack.
INTEGER*4 FUNCTION TecUtilViewPush()
Python Syntax:
Results = TecUtil.ViewPush()
Output:
Results[0] ReturnVal boolean
| Boolean_t TecUtilViewRotate | ( | RotateAxis_e | RotateAxis, | |
| double | RotateAmountInDegrees | |||
| ) |
| Boolean_t TecUtilViewRotate3D | ( | RotateAxis_e | RotateAxis, | |
| double | RotateAmountInDegrees, | |||
| double | VectorX, | |||
| double | VectorY, | |||
| double | VectorZ, | |||
| RotateOriginLocation_e | RotateOriginLocation | |||
| ) |
Do a 3-D rotation about a given axis.
| RotateAxis | Axis to rotate about. Valid values are: RotateAxis_X, RotateAxis_Y, RotateAxis_Z, RotateAxis_Psi, RotateAxis_Theta, RotateAxis_Alpha, RotateAxis_Twist, RotateAxis_VertRollerBall, RotateAxis_HorzRollerBall, RotateAxis_AboutVector | |
| RotateAmountInDegrees | Amount to rotate in degrees | |
| VectorX | X-Component for the vector to rotate about when RotateAxis_AboutVector is specified. At least one of VectorX, VectorY, or VectorZ must be non-zero. | |
| VectorY | Y-Component for the vector to rotate about when RotateAxis_AboutVector is specified. | |
| VectorZ | Z-Component for the vector to rotate about when RotateAxis_AboutVector is specified. | |
| RotateOriginLocation | Specifies the location of the rotation origin for the rotation. Valid values are RotateOriginLocation_DefinedOrigin or RotateOriginLocation_Viewer. Use RotateOriginLocation_DefinedOrigin to rotate about the currently defined rotation origin. Use RotateOriginLocation_Viewer to rotate about the currently defined viewer position |
INTEGER*4 FUNCTION TecUtilViewRotate3D( & RotateAxis, & RotateAmountInDegrees, & VectorX, & VectorY, & VectorZ, & RotateOriginLocation) INTEGER*4 RotateAxis REAL*8 RotateAmountInDegrees REAL*8 VectorX REAL*8 VectorY REAL*8 VectorZ INTEGER*4 RotateOriginLocation
Python Syntax:
Results = TecUtil.ViewRotate3D(RotateAxis, RotateAmountInDegrees, VectorX, VectorY, VectorZ, RotateOriginLocation)
Input:
RotateAxis RotateAxis_e (defined in TecVals.py)
RotateAmountInDegrees double
VectorX double
VectorY double
VectorZ double
RotateOriginLocation RotateOriginLocation_e (defined in TecVals.py)
Output:
Results[0] ReturnVal boolean
Rotate about the Psi-Axis by 25 degrees at the currently defined rotation origin.
TecUtilViewRotate3D(RotateAxis_Psi, 25.0, 0.0, 0.0, 0.0, RotateOriginLocation_DefinedOrigin);
| Boolean_t TecUtilViewScale | ( | double | Scale | ) |
| Boolean_t TecUtilViewSet | ( | ViewState_pa | ViewState | ) |
Restores a saved view for a plot type (2D, 3D, etc.
).
| ViewState | ViewState abstract pointer returned from TecUtilViewGet |
// Save the current view ViewState_pa ViewState = TecUtilViewGet(); // ...do some other stuff which changes the view // Restore the saved view TecUtilViewSet(ViewState); TecUtilViewDealloc(&ViewState); // dealloc the object when finished
INTEGER*4 FUNCTION TecUtilViewSet(ViewState) POINTER (ViewStatePtr, ViewState)
Python Syntax:
Results = TecUtil.ViewSet(ViewState)
Input:
ViewState opaque pointer
Output:
Results[0] ReturnVal boolean
| Boolean_t TecUtilViewSetMagnification | ( | double | Magnification | ) |
Scale (magnify) the view by a given value.
Set the magnification factor for the current view relative to a view where the data fit to full frame size.
| Magnification | Set the magnification to this value. |
INTEGER*4 FUNCTION TecUtilViewSetMagnification(Magnification) REAL*8 Magnification
Python Syntax:
Results = TecUtil.ViewSetMagnification(Magnification)
Input:
Magnification double
Output:
Results[0] ReturnVal boolean
Scale the view to ten percent of the size at which the data would fit the full frame:
TecUtilViewSetMagnification(0.10);
| Boolean_t TecUtilViewTranslate | ( | double | X, | |
| double | Y | |||
| ) |
Shift the image in the X- and/or Y-direction.
The amount translated is in frame units.
| X | Amount to shift the data in the X-direction. | |
| Y | Amount to shift the data in the Y-direction. |
INTEGER*4 FUNCTION TecUtilViewTranslate( & X, & Y) REAL*8 X REAL*8 Y
Python Syntax:
Results = TecUtil.ViewTranslate(X, Y)
Input:
X double
Y double
Output:
Results[0] ReturnVal boolean
Translate the view ten percent of the frame width to the right:
TecUtilViewTranslate(10.0,0.0);
| Boolean_t TecUtilViewZoom | ( | double | X1, | |
| double | Y1, | |||
| double | X2, | |||
| double | Y2 | |||
| ) |
Change the view by "zooming" into the image.
Tecplot will adjust the ranges on the axis to view the region defined by the rectangle with corners at (X1, Y1) and (X2, Y2). X1, Y1, X2, and Y2 are defined in the units of the X- and Y-axis (that is, grid coordinates).
| X1 | X min Corner of the rectangle to be viewed. | |
| Y1 | Y min Corner of the rectangle to be viewed. | |
| X2 | X max Corner of the rectangle to be viewed. | |
| Y2 | Y max Corner of the rectangle to be viewed. |
INTEGER*4 FUNCTION TecUtilViewZoom( & X1, & Y1, & X2, & Y2) REAL*8 X1 REAL*8 Y1 REAL*8 X2 REAL*8 Y2
Python Syntax:
Results = TecUtil.ViewZoom(X1, Y1, X2, Y2)
Input:
X1 double
Y1 double
X2 double
Y2 double
Output:
Results[0] ReturnVal boolean
Zoom so the rectangular region with corners at (1, 0) and (7, 9) are in view:
TecUtilViewZoom(1.0,0.0,7.0,9.0);
Get the dimensions of the Tecplot workspace.
| Width | Width of the workspace (in pixels). | |
| Height | Height of the workspace (in pixels). |
SUBROUTINE TecUtilWorkAreaGetDimensions( & Width, & Height) INTEGER*4 Width INTEGER*4 Height
Python Syntax:
Results = TecUtil.WorkAreaGetDimensions()
Output:
Results[0] Width int
Results[1] Height int
Get the workspace size in paper coordinates:
LgIndex_t width_pixels, height_pixels; TecUtilWorkAreaGetDimensions(&width_pixels, &height_pixels); double XPos = TecUtilConvertXPosition(CoordSys_Screen, CoordSys_Paper, 0.0); double YPos = TecUtilConvertYPosition(CoordSys_Screen, CoordSys_Paper, 0.0); double Width = TecUtilConvertXDimension(CoordSys_Screen, CoordSys_Paper, width_pixels); double Height = TecUtilConvertYDimension(CoordSys_Screen, CoordSys_Paper, height_pixels);
| Boolean_t TecUtilWorkViewFitAllFrames | ( | void | ) |
Change the view in the workspace so all frames are fit just inside the edges of the workspace.
INTEGER*4 FUNCTION TecUtilWorkViewFitAllFrames()
Python Syntax:
Results = TecUtil.WorkViewFitAllFrames()
Output:
Results[0] ReturnVal boolean
| Boolean_t TecUtilWorkViewFitPaper | ( | void | ) |
Change the view in the workspace so the entire paper is fit just inside the edges of the workspace.
INTEGER*4 FUNCTION TecUtilWorkViewFitPaper()
Python Syntax:
Results = TecUtil.WorkViewFitPaper()
Output:
Results[0] ReturnVal boolean
| Boolean_t TecUtilWorkViewFitSelectFrames | ( | void | ) |
Change the view in the workspace so the currently selected frames (that is, the frames with picked handles) are fit just inside the edges of the workspace.
INTEGER*4 FUNCTION TecUtilWorkViewFitSelectFrames()
Python Syntax:
Results = TecUtil.WorkViewFitSelectFrames()
Output:
Results[0] ReturnVal boolean
| Boolean_t TecUtilWorkViewLastView | ( | void | ) |
Return to the previous workspace view.
INTEGER*4 FUNCTION TecUtilWorkViewLastView()
Python Syntax:
Results = TecUtil.WorkViewLastView()
Output:
Results[0] ReturnVal boolean
| Boolean_t TecUtilWorkViewMaximize | ( | void | ) |
Temporarily expand the workspace as large as possible.
In the Motif version of Tecplot, the maximized workspace occupies the entire Tecplot process window. In the Windows version, the maximized workspace expands to fill the entire screen.
INTEGER*4 FUNCTION TecUtilWorkViewMaximize()
Python Syntax:
Results = TecUtil.WorkViewMaximize()
Output:
Results[0] ReturnVal boolean
| Boolean_t TecUtilWorkViewTranslate | ( | double | X, | |
| double | Y | |||
| ) |
Shift the view of the workspace.
This has no effect on the local view within any frame in your layout.
| X | Amount to translate in the X-Direction. Value is in inches. | |
| Y | Amount to translate in the Y-Direction. Value is in inches. |
INTEGER*4 FUNCTION TecUtilWorkViewTranslate( & X, & Y) REAL*8 X REAL*8 Y
Python Syntax:
Results = TecUtil.WorkViewTranslate(X, Y)
Input:
X double
Y double
Output:
Results[0] ReturnVal boolean
Shift the workspace view to the left by two inches (as measured by the workspace ruler):
TecUtilWorkViewTranslate(-2.0,0.0);
| Boolean_t TecUtilWorkViewZoom | ( | double | X1, | |
| double | Y1, | |||
| double | X2, | |||
| double | Y2 | |||
| ) |
Change the view into the workspace.
This has no effect on the local view within any frame in your layout.
| X1 | X min Corner of the rectangle on the paper to be viewed. | |
| Y1 | Y min Corner of the rectangle on the paper to be viewed. | |
| X2 | X max Corner of the rectangle on the paper to be viewed. | |
| Y2 | Y max Corner of the rectangle on the paper to be viewed. |
INTEGER*4 FUNCTION TecUtilWorkViewZoom( & X1, & Y1, & X2, & Y2) REAL*8 X1 REAL*8 Y1 REAL*8 X2 REAL*8 Y2
Python Syntax:
Results = TecUtil.WorkViewZoom(X1, Y1, X2, Y2)
Input:
X1 double
Y1 double
X2 double
Y2 double
Output:
Results[0] ReturnVal boolean
Make the region in the lower left corner of an 8.5 by 11 paper viewable in the work area. The paper is in portrait orientation:
TecUtilWorkViewZoom(0.0,5.5,4.25,9.75);
| Boolean_t TecUtilWriteColorMap | ( | const char * | FName | ) |
Write the current color map to a file.
| FName | File name. Must not be NULL |
INTEGER*4 FUNCTION TecUtilWriteColorMap(FName) CHARACTER*(*) FName
Python Syntax:
Results = TecUtil.WriteColorMap(FName)
Input:
FName string
Output:
Results[0] ReturnVal boolean
Write the current color map to a file. Mycolors.map is the file name:
TecUtilWriteColorMap("mycolors.map");
| Boolean_t TecUtilWriteStylesheetX | ( | ArgList_pa | ArgList | ) |
Write the style for the current frame to a file.
| ArgList | Set of Arglist entries. This is built using calls to TecUtilArgListAppendXXXX functions. Arglist Values SV_FNAME
SV_INCLUDECONTOURLEVELS
SV_INCLUDETEXT
SV_INCLUDEAUXDATA
SV_INCLUDEGEOM
SV_INCLUDEPLOTSTYLE
SV_COMPRESS
SV_INCLUDESTREAMPOSITIONS
SV_INCLUDEFACTORYDEFAULTS
SV_USERELITIVEPATHS
|
INTEGER*4 FUNCTION TecUtilWriteStylesheetX(ArgListPtr) POINTER (ArgListPtr, ArgList)
Python Syntax:
Results = TecUtil.WriteStylesheetX(ArgList)
Input:
ArgList dictionary
Output:
Results[0] ReturnVal boolean
Save a stylesheet "temp.sty" with no text objects included:
TecUtilArgListClear(ArgList); TecUtilArgListAppendString(ArgList,SV_FNAME,"temp.sty"); TecUtilArgListAppendString(ArgList,SV_INCLUDETEXT,FALSE); IsOk = TecUtilWriteStyleSheetX(ArgList);
| Boolean_t TecUtilXYMapCopy | ( | EntIndex_t | SourceMap, | |
| EntIndex_t | DestMap | |||
| ) |
| Boolean_t TecUtilXYMapCreate | ( | void | ) |
| void TecUtilXYMapGetAssignment | ( | EntIndex_t | XYMap, | |
| EntIndex_t * | Zone, | |||
| EntIndex_t * | XAxisVar, | |||
| EntIndex_t * | YAxisVar, | |||
| SmInteger_t * | XAxis, | |||
| SmInteger_t * | YAxis, | |||
| FunctionDependency_e * | FunctionDependency | |||
| ) |
| EntIndex_t TecUtilXYMapGetCount | ( | void | ) |
| Boolean_t TecUtilXYMapGetName | ( | EntIndex_t | Map, | |
| char ** | Name | |||
| ) |
| Boolean_t TecUtilXYMapIsActive | ( | EntIndex_t | XYMap | ) |
| SetValueReturnCode_e TecUtilXYMapSetActive | ( | Set_pa | XYMapSet, | |
| AssignOp_e | AssignModifier | |||
| ) |
| SetValueReturnCode_e TecUtilXYMapSetAssignment | ( | const char * | Attribute, | |
| Set_pa | XYMapSet, | |||
| double | DValue, | |||
| ArbParam_t | IValue | |||
| ) |
| SetValueReturnCode_e TecUtilXYMapSetBarChart | ( | const char * | Attribute, | |
| Set_pa | XYMapSet, | |||
| double | DValue, | |||
| ArbParam_t | IValue | |||
| ) |
| SetValueReturnCode_e TecUtilXYMapSetCurve | ( | const char * | Attribute, | |
| Set_pa | XYMapSet, | |||
| double | DValue, | |||
| ArbParam_t | IValue | |||
| ) |
| SetValueReturnCode_e TecUtilXYMapSetErrorBar | ( | const char * | Attribute, | |
| Set_pa | XYMapSet, | |||
| double | DValue, | |||
| ArbParam_t | IValue | |||
| ) |
| SetValueReturnCode_e TecUtilXYMapSetIndices | ( | const char * | Attribute, | |
| const char * | SubAttribute, | |||
| Set_pa | XYMapSet, | |||
| ArbParam_t | IValue | |||
| ) |
| SetValueReturnCode_e TecUtilXYMapSetLine | ( | const char * | Attribute, | |
| Set_pa | XYMapSet, | |||
| double | DValue, | |||
| ArbParam_t | IValue | |||
| ) |
| SetValueReturnCode_e TecUtilXYMapSetName | ( | Set_pa | XYMapSet, | |
| const char * | NewName | |||
| ) |
| SetValueReturnCode_e TecUtilXYMapSetSymbol | ( | const char * | Attribute, | |
| Set_pa | XYMapSet, | |||
| double | DValue, | |||
| ArbParam_t | IValue | |||
| ) |
| SetValueReturnCode_e TecUtilXYMapSetSymbolShape | ( | const char * | Attribute, | |
| Set_pa | XYMapSet, | |||
| ArbParam_t | IValue | |||
| ) |
| ArbParam_t TecUtilXYMapStyleGetArbValue | ( | EntIndex_t | XYMap, | |
| const char * | S1, | |||
| const char * | S2, | |||
| const char * | S3 | |||
| ) |
| double TecUtilXYMapStyleGetDoubleValue | ( | EntIndex_t | XYMap, | |
| const char * | S1, | |||
| const char * | S2, | |||
| const char * | S3 | |||
| ) |
| SetValueReturnCode_e TecUtilXYSetLayer | ( | const char * | LayerShowFlag, | |
| Boolean_t | TurnOnXYLayer | |||
| ) |
| SetValueReturnCode_e TecUtilZoneSetShade | ( | const char * | Attribute, | |
| Set_pa | ZoneSet, | |||
| double | DValue, | |||
| ArbParam_t | IValue | |||
| ) |
Assign values to attributes for shade plots.
| Attribute | Specify the attribute to change from the possible values found below: |
Attribute Assign To Value Notes
---------------------------------------------------------
SV_SHOW IValue TRUE,FALSE
SV_COLOR IValue ColorIndex_t
SV_USELIGHTINGEFFECT IValue TRUE,FALSE
| ZoneSet | Set of zones to operate on. Pass NULL to operate on all zones. | |
| DValue | If the attribute requires a floating point value then put that value in DValue, otherwise DValue is not used. This is reserved for future use. | |
| IValue | If the attribute requires an integer, enumerated value, or a handle to a string then assign it to the IValue parameter. Always typecast the IValueparameter to ArbParam_t. |
INTEGER*4 FUNCTION TecUtilZoneSetShade( & Attribute, & ZoneSetPtr, & DValue, & IValuePtr) CHARACTER*(*) Attribute POINTER (ZoneSetPtr, ZoneSet) REAL*8 DValue POINTER (IValuePtr, IValue)
Python Syntax:
Results = TecUtil.ZoneSetShade(Attribute, ZoneSet, DValue, IValue)
Input:
Attribute string
ZoneSet sequence of ints
DValue double
IValue (depends on attribute)
Output:
Results[0] ReturnVal SetValueReturnCode_e (defined in TecVals.py)
Set the shade color to red:
TecUtilZoneSetShade(SV_COLOR,NULL,0.0,(ArbParam_t)Red_C);
| SetValueReturnCode_e TecUtilZoneSetSolutionTime | ( | EntIndex_t | Zone, | |
| double | SolutionTime | |||
| ) |
Assign a time value to the specified zone.
For this value to be used, the zone must have a valid strand assigned.
| Zone | Zone on which to operate. | |
| SolutionTime | Solution Time to be assigned to the specified zone |
INTEGER*4 FUNCTION TecUtilZoneSetSolutionTime( & Zone, & SolutionTime) INTEGER*4 Zone REAL*8 SolutionTime
Python Syntax:
Results = TecUtil.ZoneSetSolutionTime(Zone, SolutionTime)
Input:
Zone int
SolutionTime double
Output:
Results[0] ReturnVal SetValueReturnCode_e (defined in TecVals.py)
| SetValueReturnCode_e TecUtilZoneSetVector | ( | const char * | Attribute, | |
| Set_pa | ZoneSet, | |||
| double | DValue, | |||
| ArbParam_t | IValue | |||
| ) |
Assign values to attributes for vector plots.
| Attribute | Specify the attribute to change from the possible values found below: |
Attribute Assign To Value Notes
---------------------------------------------------------
SV_SHOW IValue TRUE,FALSE
SV_VECTORTYPE IValue VectorType_e
SV_COLOR IValue ColorIndex_t
SV_LINEPATTERN DValue LinePattern_e
SV_PATTERNLENGTH DValue Valid pattern length
SV_LINETHICKNESS DValue Valid line thickness
SV_ARROWHEADSTYLE IValue ArrowheadStyle_e
SV_ISTANGENT IValue TRUE,FALSE
| ZoneSet | Set of zones to operate on. Pass NULL to operate on all zones | |
| DValue | If the attribute requires a floating point value then put that value in DValue, otherwise DValue is not used. | |
| IValue | If the attribute requires an integer, enumerated value, or a handle to a string then assign it to the IValue parameter. Always typecast the IValue parameter to ArbParam_t. |
INTEGER*4 FUNCTION TecUtilZoneSetVector( & Attribute, & ZoneSetPtr, & DValue, & IValuePtr) CHARACTER*(*) Attribute POINTER (ZoneSetPtr, ZoneSet) REAL*8 DValue POINTER (IValuePtr, IValue)
Python Syntax:
Results = TecUtil.ZoneSetVector(Attribute, ZoneSet, DValue, IValue)
Input:
Attribute string
ZoneSet sequence of ints
DValue double
IValue (depends on attribute)
Output:
Results[0] ReturnVal SetValueReturnCode_e (defined in TecVals.py)
Set the arrowhead style for vector plots to be "plain" for all zones:
TecUtilZoneSetVector(SV_ARROWHEADSTYLE,NULL,0.0, (ArbParam_t)Arrowhead_Plain);
| SetValueReturnCode_e TecUtilZoneSetVectorIJKSkip | ( | const char * | Attribute, | |
| Set_pa | ZoneSet, | |||
| LgIndex_t | Skip | |||
| ) |
Set the vector I-, J-, or K-skipping.
| Attribute | Specify the attribute (in this case, I, J, or K-skip) to change. The possible values are: SV_I, SV_J, or SV_K | |
| ZoneSet | Set of zones to operate on. Pass NULL to operate on all zones | |
| Skip | The vector skip value to assign |
INTEGER*4 FUNCTION TecUtilZoneSetVectorIJKSkip( & Attribute, & ZoneSetPtr, & Skip) CHARACTER*(*) Attribute POINTER (ZoneSetPtr, ZoneSet) INTEGER*4 Skip
Python Syntax:
Results = TecUtil.ZoneSetVectorIJKSkip(Attribute, ZoneSet, Skip)
Input:
Attribute string
ZoneSet sequence of ints
Skip int
Output:
Results[0] ReturnVal SetValueReturnCode_e (defined in TecVals.py)
Set the vector I-skip to two for all zones:
TecUtilZoneSetVectorIJKSkip(SV_I,NULL,(ArbParam_t)2);
| SetValueReturnCode_e TecUtilZoneSetVolumeMode | ( | const char * | Attribute, | |
| const char * | SubAttribute, | |||
| Set_pa | ZoneSet, | |||
| ArbParam_t | IValue | |||
| ) |
Assign the Volume Mode for field plots.
| Attribute | Specify the attribute to change. See SubAttribute for possible value combinations. | |
| SubAttribute | Specify the sub-attribute to change. The table below lists possible Attribute/SubAttribute combinations. |
Attribute SubAttribute IValue -------------------------------------------------------- SV_VOLUMEOBJECTSTOPLOT SV_SHOWISOSURFACES TRUE,FALSE SV_VOLUMEOBJECTSTOPLOT SV_SHOWSTREAMTRACES TRUE,FALSE SV_VOLUMEOBJECTSTOPLOT SV_SHOWSLICES TRUE,FALSE
| ZoneSet | Set of zones to operate on. Pass NULL to operate on all zones. | |
| IValue | If the attribute requires an integer, enumerated value, or a handle to a string then assign it to the IValue parameter. Always typecast the IValue parameter to ArbParam_t. |
INTEGER*4 FUNCTION TecUtilZoneSetVolumeMode( & Attribute, & SubAttribute, & ZoneSetPtr, & IValuePtr) CHARACTER*(*) Attribute CHARACTER*(*) SubAttribute POINTER (ZoneSetPtr, ZoneSet) POINTER (IValuePtr, IValue)
Python Syntax:
Results = TecUtil.ZoneSetVolumeMode(Attribute, SubAttribute, ZoneSet, IValue)
Input:
Attribute string
SubAttribute string
ZoneSet sequence of ints
IValue (depends on attribute)
Output:
Results[0] ReturnVal SetValueReturnCode_e (defined in TecVals.py)
Do not draw volume streamtraces through zone 1.
Set_pa set = TecUtilSetAlloc(FALSE); TecUtilSetAddMember(set,1,FALSE); TecUtilZoneSetVolumeMode(SV_VOLUMEOBJECTSTOPLOT, SV_SHOWSTREAMTRACES, set, (ArbParam_t)FALSE); TecUtilSetDealloc(&set);
1.5.2-20070506