| |
- addLegendLine(line, n)
- Add a line to a DISLIN legend.
- autoAxisScaling(vlist, axes='XYZ')
- Tries to determine reasonable axis scaling based on passed in values.
Use with caution.
- axis2D(xlow, xhigh, xfirst, xstep, ylow, yhigh, yfirst, ystep)
- Set up 2D axis.
Arguments:
* xlow, xhigh: min and max values of x-axis.
* xfirst, xstep: start/step values for ticks on x-axis.
* ylow, yhigh, yfirst, ystep: see above for x-axis.
- axis3D(xlow, xhigh, xfirst, xstep, ylow, yhigh, yfirst, ystep, zlow, zhigh, zfirst, zstep)
- Set up 3D axis.
- calcArrowHead(ratio=1, size=3, form='empty', position='end')
- Calculates arrow head code for vectors.
Arguments:
- ratio: ratio of width to length (1..9)
- size: size of arrowhead (1..9)
- form: form of arrowhead ('filled', 'empty', 'open', 'closed')
- position: where arrow heads will be drawn ('none', 'end',
'opposite', 'same')
-- 'none' means no arrowheads drawn
-- 'end' means arrow heads draw at end points only
-- 'opposite' means arrowheads drawn at start and end points
with arrowheads pointing in opposite direction
-- 'same' means arrowheads drawn at start and end points
with arrowhead pointing in same direction
- calculateLighting(x, y, z, xnormal, ynormal, znormal)
- Calculates colr values for given point and the point normal.
See DISLIN manual (GETLIT)
- centerAxis()
- Centers an axis system on the page.
- clearScreen()
- Erase the DISLIN plot.
- colorAxis3D(xlow, xhigh, xfirst, xstep, ylow, yhigh, yfirst, ystep, zlow, zhigh, zfirst, zstep)
- Setup 3D-color axes.
- disableAxisClipping()
- Disables clipping of objects outside axes(and pages?)
- drawBar(xlist, ylist0, ylist1)
- Creates bars for bar graphs.
Arguments:
* xlist: the positions along x-axis for drawing bars
* ylist0, ylist1: start/end points along y-axis
- drawCircle(x, y, radius, ucoords=1)
- Draws circle at x,y with given radius.
- drawColorColumn(x, yseq, zseq)
- See DISLIN docs CURVY3.
- drawColorCurve(xseq, yseq, zseq)
- See DISLIN docs CURVE3.
- drawColorMatrix(matrix, nrows, ncols, xinterp=1, yinterp=1)
- Draw matrix as 3D-color graph.
Arguments:
* matrix -- array or list containing values
* nrows, ncols -- dimensions of matrix
* xinterp, yinterp -- the number of interpolations between grid lines
- drawColorRow(xseq, y, zseq)
- See DISLIN docs CURVX3.
- drawContour(xlist, ylist, zmatrix, level)
- Draws contour for f(x,y) where f(x,y) values are given by zmatrix.
- drawContourLine(xlist, ylist, level)
- Draw contour line at given xlist, ylist coordiantes. Label given by level.
- drawCurve(xlist, ylist)
- Draws curve which goes through points specified by xlist,ylist.
- drawCurve3D(xlist, ylist, zlist)
- Draws curve in user 3D coordinates.
- drawEllipse(x, y, a, b, ucoords=1)
- Draws ellipse at x,y with given radii (a,b).
- drawEllipticArc(x, y, a, b, alpha, beta, theta, ucoords=1)
- Draw elliptical arc centered at x,y.
Arguments:
* x,y: coordinates of center
* a,b: radii of major/minor axes
* alpha, beta: starting/ending angles (degrees, counter-clockwise)
* theta: angle of rotation of whole figure (degrees, counter-clockwise)
- drawErrorBars(xlist, ylist, elow, ehigh, symbol='square', symbolsize=30, horizontal=0)
- Draws error bars.
Arguments:
* xlist, ylist: the x,y values of center of each error bar
* elow, ehigh: the high/low values of the errors at each point
* symbol: the symbol used to indicate center of error bar
* symbolsize: size of symbol drawn at center of error bar
* horizontal: whether error bars should be drawn horizontal rather than
vertical
- drawFunctionSurface(function, xgrid, ygrid, xinterp, yinterp)
- Draw 3D surface grid, calculated from a given function.
Arguments:
* function: a python function object representing the function to be
visualized
* xgridx, ygrid: the distance in user coordinates between grid lines
plotted on the fsuface.
* xinterp, yinterp: the number of points between grid lines used
to interpolate the surface. More points means longer plot times.
- drawIrregularSurface(xlist, ylist, zmatrix)
- Draws 3D surface from arbitrary x,y,z lists. z can be a matrix.
- drawIsoSurface(xlist, ylist, zlist, values, levels)
- Draws isosurfaces of form f(x,y,z)=constant.
- drawLegend(pos='pageUR')
- Draw DISLIN legend at given position.
valid positions: pageLL, pageLR, pageUR, pageUL, axisLL, axisLR, axisUR, axisUL
* where page/axis refers to axis system or page system and LL, LR, UR, UL
correspond to lower-left, lower-right, upper-right, and upper-left
- drawLine(x0, y0, x1, y1, ucoords=1)
- Draws a Line from (x0,y0) to (x1,y1), either page or user coords.
- drawLine3D(x0, y0, z0, x1, y1, z1)
- Draws 3D line in absolute 3D coordinates.
- drawMatrixContour(zmatrix, nrows, ncols, level)
- Draw contour over current x,y axis values.
See CONMAT function in DISLIN manual for more info.
- drawMessage(txt, x, y, ucoords=1)
- Draws a text message at (x,y).
Arguments:
* txt: the text message to draw
* x,y: coordinates at which text is drawn
* ucoords: if true then draw, using user coordinates, else drawn
using page coordinates
- drawNumber(n, ndig, x, y, ucoords=1, fmt='float')
- Draws a number at (x,y).
Arguments:
* n: the number to draw
* ndig: number of digits following decimal point (-1 = Integer)
* ucoords: if true then draw, using user coordinates, else drawn
using page coordinates
- drawPageHeader(pre='', post='', corner=3, direction=0)
- Draws a header at a corner of the page.
Arguments:
* pre: character string preceding the header line
* post: character string following header line
* corner: 1: lower left, 2: lower right, 3: upper right, 4: upper left
* direction: 0: horizontal, 1: vertical
- drawParametricSurface(function, umin, umax, ustep, tmin, tmax, tstep)
- Draws surface from parametric function: x=f(u,t), y=g(u,t), z=h(u,t)
Function should take two values, and an axis indicator:
e.g. def func(u,t,axis):
....
If axis = 1, should return x values, axis = 2 should return y values,
axis = 3 should return z values
- drawPie(x, y, radius, alpha, beta, ucoords=1)
- Draw pie slice at x,y with given radius and angles.
Arguments:
* x,y: coordinates of center
* radius: radius of pie
* alpha, beta: starting/ending angles (degrees, counter-clockwise)
- drawPieChart(xlist, labels=[])
- Draws a Pie chart with slice sizes defined by values of xlist.
See DISLIN docs on PIEGRF function.
- drawPolygon(xlist, ylist, ucoords=1)
- Draw polygon with coordinates given by xlist, ylist.
- drawRectangle(x, y, width, height, rounding=0, ucoords=1)
- Draw rectangle with upper left corner at x,y.
Arguments:
* x,y: coordinates of upper left corner
* width, height: width and height of rectangle
* rounding: the amount of rounding of corners (0...9)
* ucoords: whether user or page coords should be used
- drawRegularSurface(matrix, nx, ny, xinterp, yinterp)
- Draws 3D surface from a 2D array. Assumes linear grid in X,Y-plane.
Arguments:
* nx, ny -- number of rows and columns of matrix
* xdensity, ydensity : the number of points between grid lines used
to interpolate the surface. More points means longer plot times.
- drawShadedContours(xlist, ylist, zmatrix, levels)
- Draws contours with colors between contour lines.
- drawShadedCurve(x0list, y0list, x1list, y1list)
- Draws a shaded region between two curves.
- drawShadedSurface(xlist, ylist, zmatrix)
- Draws a 3D surface with shaded colors.
- drawSphere3D(x0, y0, z0, radius, hres, vres)
- Draws sphere in absolute 3D coordinates.
- drawSymbol(x, y, nsymb='circle', ucoords=1)
- Draws a symbol at (x,y), either page or user coords.
- drawText(txt, x, y, ucoords=1, TeX=0)
- Draw text message at x,y. Uses TeX fonts if TeX is true.
- drawVector(x0, y0, x1, y1, vtype='normal fill', ucoords=1)
- Draws a vector from (x0,y0) to (x1,y1), either page or user coords.
- drawVector3D(x0, y0, z0, x1, y1, z1, vtype='normal')
- Draws 3D vector in absolute 3D coordinates.
Arguments:
* x0,y0,z0,x1,y1,z1 : the starting an ending 3D coordinates of the vector
* vtype -- the type of head drawn on the vector
- drawVectorField(x0list, y0list, x1list, y1list, vtype='normal')
- Draws a vector field based on list of starting/ending x,y values.
- end_axis()
- Terminate axis system.
- expandColorBarScaling(direction='none')
- Expands the numbering of log scaled Z-axis to next order of magnitude up/down.
From DISLIN docs:
The routine EXPZLB expands the numbering of a logarithmically scaled Z-axis
to the next order of magnitude that lies up or down the axis limits.
The scaling of the colour bar will not be changed. This routine is useful
if the range of the Z-axis scaling is smaller than 1 order of magnitude.
- generateFunctionMatrix(xlist, ylist, zlist, nx, ny, defaultz=0, gridx=2, gridy=2, gridweight=2.0)
- For a set of x,y,z values generate a function matrix of dim(nx,ny).
Used in conjunction with drawRegularSurface.
See DISLIN documentation, GETMAT function for detailed discussion.
- getAxisData(axis)
- getAxisLengths()
- getAxisOrigin()
- getAxisPosition()
- getAxisScaling()
- getColorBarRange()
- getColorIndex()
- getColorRGB()
- getContourPoints(xlist, ylist, zmatrix, level, maxpts, maxcurves)
- Generates contour points.
- getFileFormat()
- getFileName()
- getLineStyle()
- getLineWidth()
- getMouseClick(plotcoords=0)
- Returns the coordinates of a single mouse click.
If plotcoords != 0, returns values in "plot coordinates", otherwise
returns values in user coordinates.
- getMouseClicks(plotcoords=0)
- Returns the coordinates of multiple mouse clicks. Finishes when mouse button 2 is pressed.
If plotcoords != 0, return values in "plot coordinates", otherwise
returns values in user coordinates
- getPageSize()
- getRGBFromIndex(idx)
- getScreenSize()
- getShadingPattern()
- getTerminalType()
- getTextAngle()
- getTextHeight()
- getWindowGeometry()
- getWindowID()
- include_metafile(filename)
- Draws a metafile on the page. See also fillbox.
- initialize()
- Initialize DISLIN drawing. Set to DISLIN level 1.
- initializeLegend(nlines, maxlen)
- Initialize a DISLIN legend.
- initializePlane3D(ll=(-1, -1, 0), lr=(1, -1, 0), ur=(1, 1, 0))
- Setup 2D Plane in 3D space.
Arguments:
* ll, lr, ur -- absolute 3D coordinates of lower-left, lower-right,
and upper-right corners of plane (the default coordinates
give a xy-plane, perpendicular to the z-axis at absolute
z-coordinate zero)
- isPostscript(fmt)
- Returns true if passed format is a postscript or PDF format.
- isScreen(fmt)
- Returns true if passed format is a screen or console format.
- isWMF(fmt)
- Returns true if format is a windows metafile format.
- noAxisLines(axes='XYZ')
- Suppresses the plotting of axis lines.
- noAxisSystem()
- Suppresses the plotting of an axis system.
- noCheck()
- Suppresses listing of points outside of axis.
- plotToUser(x=0, y=0)
- Converts plot x,y coordinates to user coordinates.
- qbar(xlist)
- interface to dislin quick bar plot function.
- qcolor3D(zmatrix, nx, ny)
- interface to dislin quick 3d color plot function.
- qcontour(zmatrix, nx, ny, nlevels)
- interface to dislin quick contour plot function.
- qline(xlist, ylist)
- Interface to dislin quick line plot function
- qpie(xlist)
- interface to dislin quick pie plot function.
- qscatter(xlist, ylist)
- Interface to dislin quick scatter function.
- qsetup(format='screen', filename='dis.out')
- Performs useful setup calls for 'quick' functions.
- qsurface(zmatrix, nx, ny)
- interface to dislin quick surface plot function.
- resetParameter(pname)
- Reset given DISLIN parameter.
- resetTransformations()
- Resets all base transformations of plot vectors.
- secondaryXaxis(low, high, first, step, length, name, direction, x, y, log=0)
- Plots a secondary X axis. See XAXIS in DISLIN docs.
- secondaryYaxis(low, high, first, step, length, name, direction, x, y, log=0)
- Plots a secondary Y axis. See YAXIS in DISLIN docs.
- sendBuffer()
- Send's the DISLIN buffer to the screen.
- setAutoColorResolution(nx, ny)
- Given # of pts in x,y directions, automatically sets color-plot resolution.
- setAxisAllColor(idx=-1, axes='XYZ')
- Sets the color(index) for all axis parts.
- setAxisBackground(idx=-1)
- Sets the color(index) of the background for axis systems.
- setAxisColors(line=-1, tick=-1, label=-1, name=-1, axes='XYZ')
- Sets color for indicated elements of an axis.
- setAxisLabelColor(idx=-1, axes='XYZ')
- Sets the color(index) for axis labels.
- setAxisLengths3D(x=2.0, y=2.0, z=2.0)
- Sets the lengths of axes in absolute 3D coordinates. See DISLIN manual.
- setAxisLineColor(idx=-1, axes='XYZ')
- Sets the color(index) for axis lines.
- setAxisName(name, axes='XYZ')
- Sets the name (title) drawn next to an axis.
- setAxisNameColor(idx=-1, axes='XYZ')
- Sets the color(index) for axis names.
- setAxisNameDistance(dist, axes='XYZ')
- Sets the distance (in plot coordinates) between axis labels and axis names.
- setAxisNameHeight(h)
- Sets the height (in plot coordinates) of axis names.
- setAxisNameJustification(jus, axes='XYZ')
- Sets justification of axis names.
- setAxisPageOrigin(x, y)
- Sets the position (in plot coordinates) of origin of crossed-axis system.
- setAxisPagePosition(x, y)
- Sets the plot coordinates of the lower left corner of an axis system.
- setAxisPageSize(width, height)
- Defines the size (in plot coordinates) of an axis system.
- setAxisParts(lowx='all', lefty='all', upx='ticks', righty='ticks')
- Determines the parts of an axis system which will be drawn.
valid arguments: none, lines, ticks, labels, all
* none: complete axes suppressed
* lines: only axis lines drawn
* ticks: lines and ticks drawn
* labels: lines, ticks, and labels drawn
* all: lines, ticks, labels, and axis names drawn
- setAxisScaling(scalingtype='linear', axes='XYZ')
- Determines the type of the axis system.
valid scalingtypes: linear, log
Arguments:
* scalingtype:
* axes: determines which axis to apply the operation to.
- setAxisTickColor(idx=-1, axes='XYZ')
- Sets the color(index) for axis ticks.
- setAxisType(axistype='rectangular')
- Sets the type of axis system drawn.
Valid: 'rectangular', 'crossed'
- setBar3DLook(depth=-1, ang=45)
- Sets appearance of 3D bars.
Arguments:
* depth: floating point number defining depth of bar
* ang: angle (in degrees) between front and side panels
- setBarBorderColor(clr=-1)
- Set color(index) of bar borders. -1 indicates current color.
- setBarColor(front=-1, side=-1, top=-1)
- Sets colors(index) for front, side, and top of bars. -1 indicates current color.
- setBarGroups(ngroups, gap)
- Puts bars with same axis position into groups.
- setBarLabelStyle(mode='none', position='auto', digits=1, color=-1)
- Sets various label options for bar graphs.
Arguments:
* mode : defines what kind of labels will be used
- valid modes: none, second, first, delta -- see DISLIN docs.
* position : defines position of labels
- valid positions: inside, outside, left, right, center, auto
* digits : number of digits used in labels
* color : label color (index)
- setBarPosition(pos='none')
- Defines how bars will be drawn relative to axes/ticks.
valid positions: none, ticks, axis, both
* none: positions defined by drawBar
* ticks: centered on major ticks
* axis: vertical bars start at x-axis, horizontal at y-axis
* both: combines ticks and axis
- setBarType(bartype='vertical')
- Sets direction and appearance of bars.
valid bartypes: vertical, horizontal, vertical3D, horizontal3D
- setBarWidth(w=0.75)
- Sets width of bars for bar graphs.
- setBarWidthMode(mode='fixed')
- Set width mode for bar graphs.
valid modes: fixed, variable
- setBorder()
- Plots a border around the page.
- setBorder3D()
- Enables a box to be drawn around 3D axis systems.
- setCameraRotation3D(ang)
- Defines camera rotation around viewing axis in degrees clockwise.
- setClipping3D(system='world', eyevalues=(1, -1))
- Defines whether clipping is done in world or eye coordinate system.
Arguments:
* system: 'world' or 'eye'
* eyevalues: if system='eye', the distances in absolute coordinates
to clip front and back planes. Negative value means infinity.
- setColor(clr)
- Sets the color used to draw DISLIN object.
Works with strings (basic color name), integers (color index), and 3-tuples (RGB).
- setColorAxisLengths(x, y, z)
- Sets lengths (in plot coordinates) of 3-D color axes.
- setColorBarPositionHoriz(pos)
- Sets horizontal position of color bar relative to axis system.
Default is 85 plot coordinates to the right of axis system.
Positive values move bar further to right (away from axis system),
while negative values move bar closer to axis system.
- setColorBarPositionVert(pos)
- setColorBarRange(start=1, end=254)
- Sets range of colors used in 3D-color plot color bar.
- setColorBarWidth(width)
- Sets width (in plot coordinates) of colobar.
- setColorIndex(idx)
- Sets color using integer in range 0 to 255
- setColorMode(mode='full')
- Defines the color mode (low, none) for X11 output.
Valid: 'low' or 'full'
- setColorRGB(r, g, b)
- Sets color using RGB values
Dislin uses values between (0,1). I assume you'll want to use standard
values in range (0,255) so I do an automatic conversion.
Dislin only supports 256 colors
- setColorResolution(width=1, height=1)
- Defines the dimensions of rectangles used in color plots.
- setColorString(clr)
- Sets color using simple string
- setColorTable(table='rainbow')
- Sets a standard DISLIN supplied color table.
valid tables: small, vga, grescale, rainbow, violet, reverse grey,
reverse rainbow, reverse violet
- setContourFilling(mode='cell')
- Sets the filling mode for shaded contours.
valid modes: cell, polygon.
- setContourLabelColor(clrindex)
- Sets color of contour labels.
- setContourLabelDistance(distance=500)
- Sets distance between contour labels in plot coordinates.
- setContourLabelGap(gap)
- Defines distance between contour lines and labels.
- setContourLabelString(text='')
- Defines a character string used for contour labels.
- setContourLabels(mode='none', ndigits=1)
- Determines the manner in which contour labels are drawn.
valid modes: none, float, string
* none: no contour labels plotted.
* float: level values used for labels
* string: labels defined by setContourLabelString used.
- setContourMode(interval, quotient)
- See CONMOD in DISLIN docs.
- setCurveInterpolation(mode)
- Sets interpolation mode for curve drawing.
valid modes: linear, step, stairs, bars, stem, spline, pspline
See DISLIN docs for POLCRV for more info.
- setCurveSymbols(step=0, shape='circle', size=30)
- Sets the symbols used to mark points on curves.
Arguments:
* step: if step=0, no symbols are drawn, only lines. If step is negative,
only every n-th symbols is drawn, without lines. If step is positive
lines are drawn, and every n-th symbol is drawn.
* symbolshape: the shape of the symbols to use (see symboldict)
* size: size of the symbols
- setCurveWidth(w)
- Sets the thickness of DISLIN curves.
- setDislinFont(font='default')
- Sets font type to DISLIN build in font.
- setErrorDevice(device='file')
- Specifies whether DISLIN errors are written to the error file or screen.
valid: file, screen
- setErrorFile(fname='dis.err')
- Sets the name of the file to which DISLIN errors are written.
- setFilename(filename='dis.out', overwrite=0)
- Set filename used for output.
Arguments:
* filename: name of file.
* overwrite: whether files with same filename should be overwritten.
- setFocus3D(x, y, z, focustype='absolute')
- Sets position of the 3D focus.
valid focustypes: absolute, user
- setFont(font='default', hardware=1)
- Sets a font depending on current DISLIN file format.
- setFormat(format='screen')
- The DISLIN output format.
Specifies the filetype or screen type on which the plot will be drawn.
Valid: cgm, color postscript, console, png, postscript, pdf, screen,
tiff, virtual, window1, wmf
- setFrameThickness(n=1)
- Determines thickness of frame drawn around axis systems.
- setGrid(nx, ny, gridtype='square')
- Sets grid (of gridtype) with spacing given by nx, ny.
valid gridtypes: square, polar
- setGrid3D(nlinesx, nlinesy, planetype='all')
- Adds grids to 3D axes.
Valid planetypes: all, back, bottom
* all: grids in xy,xz,yz planes
* back: grids in xz and yz planes
* bottom: grid only in xy plane
- setHardwareFont()
- Sets sensible default fonts depending on the file type.
- setIntegerLabels()
- Causes axes labels to be drawn using integer values.
- setLabelDigits(digits=1, axes='XYZ')
- Sets number of digits after the decimal point for axis labels.
- setLabelDistance(dist=24, axes='XYZ')
- Determines the distance (in plot coordinates) between axis ticks and labels.
- setLabelJustification(justify='auto', axes='XYZ')
- Defines justification of axis labels.
valid justify: auto, left, right, outward, inward
* auto: automatically determined by DISLIN
* left: left-justified
* right: right-justified
* outward: left justified on left and lower axes, right-justified on
right and upper axes.
* inward: opposite of outward.
- setLabelOrientation(orientation='horizontal', axes='XYZ')
- Defines the orientation of axis labels.
valid orientations: horizontal, vertical
- setLabelPosition(position='ticks', axes='XYZ')
- Defines how axis labels are drawn relative to ticks.
valid positions: ticks, center, shift
* ticks: labels drawn at major ticks
* center: labels drawn between major ticks
* shift: starting/ending labels shifted
- setLabelType(ltype='float', axes='XYZ')
- Sets the type of labels which will be plotted on an axis.
See DISLIN docs on LABELS for more info.
- setLegendFrameWidth(w=1)
- Sets width of frame drawn around legend boxes.
- setLegendPattern(nline, lwidth=1, lstyle=None, symbol=None, color=-1, pattern=None)
- Sets aspect of the given legend line.
Arguments:
* nline: integer value corresponding to the legend item to be set.
* lwidth: width of line drawn for legend item
* lstyle: style of line drawn for legend item (see linedict)
* symbol: shape of symbol draw for legend item (see symboldict)
* color: color(index) for legend item
* pattern: shading pattern for legend item
- setLegendTitle(title)
- Sets text of title drawn for legend.
- setLightPosition(lightID, x, y, z, coordmode='absolute')
- Sets position of individual light.
Arguments:
* lightID: ID of light (1..8).
* x,y,z: 3D coordinates of light.
* coordmode:
- valid coordmodes: absolure, user, angle
- setLightingOptions(lightID, val, otype)
- Sets various lighting options.
Modifies the ambient, diffuse and specular intensities and the constant,
linear and quadratic attentuation factors of light sources. See DISLIN
manual (LITOPT).
- setLineStyle(style='solid')
- Sets style with which lines are drawn.
valid styles: solid, dot, dash, chain dash, chain dot, medium dash,
large dot, large dash
- setLineWidth(w=1)
- Sets width of DISLIN lines.
- setMaterialParameters(val, ptype)
- Defines material parameters for ambient, diffuse, and specular lighting.
See DISLIN manual (MATOPT).
- setMyColorTable(lr, lg, lb)
- Defines a custom color table.
- setNoHiddenLines()
- Causes hidden lines to be drawn for surface plots.
- setNoZeroColor()
- Suppresses 3D-color plotting of points with zero value.
- setOriginLines(val='xy')
- Draws vertical and horizontal lines through the origin of axis system.
Specify: "x" -- for x=0 only
"y" -- for y=0 only
"xy" -- for x=0 and y=0
"cross" -- for x=0,y=0 plus ticks
- setPSFont(font='default')
- Sets font type to postscript fonts.
- setPageFill(ncolor)
- Fills the entire page with a single color.
Valid: int [0,255]
- setPageSize(x, y)
- Sets the page size for DISLIN plots (in plot coordinates).
Valid: (int, int)
- setPieAppearance(cycle='pattern', ptype='2D')
- Defines how Pie colors/patterns change, and whether to use 2D/3D look.
- setPieArrowType(linetype='broken', head=2301)
- Sets aspect of the arrows drawn from labels to pie slices.
- setPieAutoOffset()
- Offsets pie slices.
- setPieBorderColor(colorindex)
- Set the color(index) of the borders on pie graphs.
- setPieLabelStyle(mode='percent', position='internal', justify='center', digits=1, color=-1)
- Sets label style for Pie slice labels.
valid modes: none, percent, data, both (see DISLIN docs)
valid positions: internal, external, aligned (see DISLIN docs)
valids justify: center, left, right, outwards, inwards (see DISLIN docs)
- setPieLabels(label, position)
- Sets Labels drawn on left or right of data values in pie graphs
valid positions: left, right
- setPieOptions3D(thickness=0.20000000000000001, angle=45.0)
- Sets thickness and viewing angle for 3D pie graphs.
- setPieSliceColors(topcolors, sidecolors)
- Sets colors(index) of top/side of pie slices.
- setPlotRotation(ang, x, y)
- Affects rotation of plot vectors.
- setPlotScaling(x, y)
- Affects scaling of plot vectors.
- setPlotShift(x, y)
- Shifts plot vector given amount in x,y direction.
- setPolarGrid(nc, nl)
- Overlay polar grid on axis system, with nc circles and nl sector lines.
- setProtectSurfaces()
- Protects surface from being overwritten.
Applies to routines derived from SURFUN, SURMAT and SURFCE
- setScaling(factor=1.0)
- Sets the scaling factor for an entire DISLIN plot.
Valid: float (0,inf]
- setScalingMode(mode='down')
- Sets the method by which graphics are scaled to hardware devices.
valid modes:
* down: graphics larger than hardware page size are scaled down.
* full: graphics scaled up/down depending on hardware page size.
- setScreenMode(mode='normal')
- Set the foreground/background color for DISLIN plots.
valid modes:
* normal: white background with black default foreground color
* black: black background with white default foreground color
- setShadingPattern(pattern, outline=1)
- Sets the shading pattern for DISLIN objects.
- setSplineMode(order=3, npts=200)
- Defines the order of polynomial and number of points for splined curves.
- setSquareGrid(nx, ny)
- Overlay grid on axis system, with nx and ny grid lines between labels.
- setSurfaceColorScale(low, high)
- Sets color scale for 3D surface plots.
- setSurfaceColors(topcolor=-1, bottomcolor=-1)
- Determines color of top and bottom of surfaces. Color = index.
Applies to routines derived from SURFUN, SURMAT and SURFCE
- setSurfaceMeshColor(clr=-1)
- Defines color(index) for surface mesh/grid lines.
- setSurfaceMeshing(state='off', shading=1)
- Sets additional mesh/grid lines for surfaces.
- setSurfaceShadingMode(mode='flat')
- Determines the type of shading applied to colored surfaces.
valid modes: flat, smooth
* smooth: can only be applied to raster output formats (screens, TIFF, png, etc).
- setSurfaceSize(xmin, xmax, ymin, ymax)
- Alternate way to set surface size for drawRegularSurface function.
- setSurfaceVisibility(visible='both')
- Determines whether top, bottom, or both parts of surface are visible.
Applies to routines derived from SURFUN, SURMAT and SURFCE
- setSymbolRotation(deg=0)
- Sets rotation angle of symbol (in degrees).
- setSymbolSize(x=30)
- Sets symbol size (in plot coordinates).
- setTTFont(font='default')
- Sets font type to true type fonts.
- setTeXMode(mode)
- Sets TeXMode for font drawing.
- setTextAngle(deg=0)
- Sets the angle (in degrees) at which text is drawn.
- setTextHeight(h=36)
- Sets the character height of text.
- setTextJustification(justify='left')
- Sets the justification of text.
- setTickLength(major=24, minor=16)
- Sets lengths (in plot coordinates) of major/minor ticks.
- setTickNumber(n=2, axes='XYZ')
- Sets number of ticks between labels on axes.
- setTickPosition(position='sameaslabels', axes='XYZ')
- Sets position of ticks on given axis.
Valid:
* sameaslabels: ticks plotted on same side as labels.
* inside: ticks plotted on inside of axis line.
* center: ticks centered on axis line.
- setTitle(title, height=48, justify='center', pos='above', offset=0)
- Draws title for an axis system.
Arguments:
* title: text of title (can contain line ends)
* height: height of title text
* justify: justification of title text
* pos: position of title text relative to axis system (above, below)
* offset: spacing of title relative to axis system. Negative values
move title closer to axis system. Positive values move title
further away from axis system.
- setUserColorBar(low, high, start, step, length, plotx, ploty, axisname='', tickoption='clockwise', direction='horizontal', log=0)
- Allows user to setup a customized color bar. see ZAXIS in DISLIN docs.
Arguments:
* low,high -- upper and lower limits of color bar.
* start, stop -- start/step values for labels
* length -- length of the color bar in plot coordinates
* plotx, ploty -- posiition, in plot coordinates, of lower left corner of bar.
* axisname -- title displayed for the color bar
* tickoption -- determines direction for plotting ticks/labels ('clockwise', 'ctrclockwise').
* direction -- direction of the color bar ('vertical','horizontal')
* log -- whether axis should be logarithmic
- setView3D(x, y, z, viewtype='absolute')
- Sets position of the 3D viewpoint.
valid viewtypes: absolute, users, angle
Arugments:
* x,y,z -- the coordinates of the view point. Default
setting is to use two angles (x, y) and a distance (Z), but
other settings are available using viewtype attribute (see DISLIN
documentation). In default setting x represents rotation in the
XY-plane, y represents rotation in the YZ-plane, and z
represents distance of viewpoint from the axis system.
- setViewAngle3D(ang)
- Defines the field of view angle for 3D plots in degrees.
- setWindowApp(w=0)
- Makes DISLIN windows act like a console or window app with respect to errors.
Specifies DISLIN's error behavior - acting either like a windows
application (popping up annoying dialogs) or like a console app (writing
the mistake to stdout).
Valid: 0 (console) or 1 (window)
- setWindowGeometry(x, y, width, height)
- Sets the screen geometry (x,y,width,height) of DISLIN windows.
Valid: (int, int, int, int)
- setWindowHold(mode='hold')
- Sets the windows termination handling.
Valid:
* hold: DISFIN waits for mouse button 2
* nohold: no waiting for mouse button, after DISFIN all windows are closed
* noerase: program blocked but windows not deleted after program continuation
* none: program not blocked and windows not deleted
- setWindowID(wid=0, wtype='none')
- Makes DISLIN draw to window with given ID (handle)
- setWindowKey(key='return')
- Determines what mouse clicks and keys enable program continuation.
valid:
* click: only a click of mouse button two enables continuation
* return: return key or mouse button two enable continuation
* escape: escape key or mouse button two enable continuation
- setWindowSize(width, height)
- Sets the width, height of DISLIN windows.
- setWindowStore(s=0)
- Whether X11 backing store will be used when windows are drawn.
Valid: 0 (no store), 1 (store)
- setX11Font(font='default', ending='STANDARD')
- Sets font type to X11 fonts.
- setup()
- Convenience function for setting up screen for interactive use.
- suppressColorBar()
- Suppresses plotting of color bars for 3D-color plots.
- suppressLabels(mode='none', axes='XYZ')
- Suppresses particular labels on axes.
valid modes: none, first, nofirst, last, nolast, ends, noends
* none: all labels displayed.
* first: only starting label displayed
* nofirst: starting label NOT displayed
* ends: only ending label displayed
* noends: ending label NOT displayed
- suppressMessages()
- Suppresses DISLIN error messages.
- terminate()
- Terminate DISLIN drawing. Set to DISLIN level 0.
- terminatePlane3D()
- Terminate 2D Plane in 3D space.
- turnLightOff(ID)
- Turns individual light off (1...8).
- turnLightOn(ID)
- Turns individual light on (1...8).
- turnLightingSystemOff()
- Disables lighting values for surface plots.
- turnLightingSystemOn()
- Enables lighting values for surface plots.
- userToPlot(x=0, y=0, z=0)
- Converts user coordinates to plot coordinates.
- userToPlotX(x)
- Converts user x coordinates to plot x coordinates.
- userToPlotY(y)
- Converts user y coordinates to plot x coordinates.
- userToPlotZ(z)
- Converts user z coordinates to plot x coordinates.
|