Scene PT

scene.spad line 3994 [edit on github]

these are the parameters that can be set for nodes of various types

addArrows2Din2D: (%, PT -> PT, Segment DoubleFloat, Segment DoubleFloat, NonNegativeInteger) -> %

addArrows2Din2D(n, ptFun, uSeg, vSeg, numPts) is a convenience function which combines createArrows2Din2D with addChild!

addChild!: (%, %) -> Void

addChild!(n, c) adds the specified child node 'c' below node 'n'

addPlot1Din2D: (%, DoubleFloat -> DoubleFloat, Segment DoubleFloat, NonNegativeInteger) -> %

addPlot1Din2D(n, f, tRange, numPts) is a convenience function which combines createPlot1Din2D with addChild!

addPlot1Din2D: (%, DoubleFloat -> PT, Segment DoubleFloat, NonNegativeInteger) -> %

addPlot1Din2D(n, f, tRange, numPts) is a convenience function which combines createPlot1Din2D with addChild!

addPlot1Din2Dparametric: (%, ParametricPlaneCurve(DoubleFloat -> DoubleFloat), Segment DoubleFloat, NonNegativeInteger) -> %

addPlot1Din2Dparametric(n, ppc, tRange, numPts) is a convenience function which combines createPlot1Din2Dparametric with addChild!

addPlot1Din3Dparametric: (%, DoubleFloat -> PT, Segment DoubleFloat, NonNegativeInteger) -> %

addPlot1Din3Dparametric(n, pcfun, tRange, numPts) is a convenience function which combines createPlot1Din3Dparametric with addChild!

addPlot1Din3Dparametric: (%, ParametricSpaceCurve(DoubleFloat -> DoubleFloat), Segment DoubleFloat, NonNegativeInteger) -> %

addPlot1Din3Dparametric(n, psc, tRange, numPts) is a convenience function which combines createPlot1Din3Dparametric with addChild!

addPlot2Din3D: (%, (DoubleFloat, DoubleFloat) -> DoubleFloat, Segment DoubleFloat, Segment DoubleFloat, NonNegativeInteger) -> %

addPlot2Din3D(n, f, uSeg, vSeg, numPts) is a convenience function which combines createPlot2Din3D with addChild!

addPlot2Din3Dparametric: (%, (DoubleFloat, DoubleFloat) -> PT, Segment DoubleFloat, Segment DoubleFloat, NonNegativeInteger) -> %

addPlot2Din3Dparametric(n, f, uSeg, vSeg, numPts) is a convenience function which combines createPlot2Din3Dparametric with addChild!

addPlot2Din3Dparametric: (%, ParametricSurface((DoubleFloat, DoubleFloat) -> DoubleFloat), Segment DoubleFloat, Segment DoubleFloat, NonNegativeInteger) -> %

addPlot2Din3Dparametric(n, f, uSeg, vSeg, numPts) is a convenience function which combines createPlot2Din3Dparametric with addChild!

addSceneArrow: (%, %, %, PT, Symbol, DoubleFloat, DoubleFloat) -> %

addSceneArrow(n, st, en, offset, mode, size, fontScale) is a convenience function which combines createSceneArrow with addChild!

addSceneArrow: (%, String, String, PT, Symbol, DoubleFloat) -> %

addSceneArrow(n, st, en, offset, mode, size) is a convenience function which combines createSceneArrow with addChild!

addSceneArrows: (%, List List PT, Symbol, DoubleFloat) -> %

addSceneArrows(n, line, mode, size) is a convenience function which combines createSceneArrows with addChild!

addSceneBox: (%, DoubleFloat) -> %

addSceneBox(n, size) is a convenience function which combines createSceneBox with addChild!

addSceneClip: (%, SBoundary PT) -> %

addSceneClip(n, bb) is a convenience function which combines createSceneClip with addChild!

addSceneDef: (%, String, %) -> %

addSceneDef(n, nam, nde) is a convenience function which combines createSceneDef with addChild!

addSceneGraph: (%, DirectedGraph String, NonNegativeInteger, NonNegativeInteger, Boolean) -> %

addSceneGraph(n, g, x, y, dispArrowName) is a convenience function which combines createSceneGraph with addChild!

addSceneGrid: (%, DoubleFloat, SBoundary PT) -> %

addSceneGrid(n, stepSize, bb) is a convenience function which combines createSceneGrid with addChild!

addSceneGrid: (%, SBoundary PT) -> %

addSceneGrid(n, bb) is a convenience function which combines createSceneGrid with addChild!

addSceneGroup: % -> %

addSceneGroup(n) is a convenience function which combines createSceneGroup with addChild!

addSceneIFS: (%, List List NonNegativeInteger, List PT) -> %

addSceneIFS(n, inx, pts) is a convenience function which combines createSceneIFS with addChild!

addSceneIFS: (%, SceneIFS PT) -> %

addSceneIFS(n, in1) is a convenience function which combines createSceneIFS with addChild!

addSceneLine: (%, %, %, DoubleFloat) -> %

addSceneLine(n, st, en, fontScale) is a convenience function which combines createSceneLine with addChild!

addSceneLine: (%, %, %, DoubleFloat, Boolean) -> %

addSceneLine(n, st, en, fontScale) is a convenience function which combines createSceneLine with addChild!

addSceneLine: (%, List PT) -> %

addSceneLine(n, line) is a convenience function which combines createSceneLine with addChild!

addSceneLines: (%, List List PT) -> %

addSceneLines(n, line) is a convenience function which combines createSceneLines with addChild!

addSceneMaterial: (%, DoubleFloat, String, String) -> %

addSceneMaterial(n, lineW, lineC, fillC) is a convenience function which combines createSceneMaterial with addChild!

addSceneMaterial: (%, Record(lineWidth: DoubleFloat, lineCol: String, fillCol: String, matOpacity: DoubleFloat)) -> %

addSceneMaterial(n, mat) is a convenience function which combines createSceneMaterial with addChild!

addSceneNamedPoints: (%, SceneNamedPoints PT) -> %

addSceneNamedPoints(n, np) is a convenience function which combines createSceneNamedPoints with addChild!

addScenePattern: (%, Symbol, NonNegativeInteger, SBoundary PT) -> %

addScenePattern(n, ptype, step, bb) is a convenience function which combines createScenePattern with addChild!

addSceneRuler: (%, Symbol, PT, SBoundary PT) -> %

addSceneRuler(n, ptype, offset, bb) is a convenience function which combines createSceneRuler with addChild!

addSceneShape: (%, Record(shptype: Symbol, centre: PT, size: PT, fill: Boolean)) -> %

addSceneShape(n, shape) is a convenience function which combines createSceneShape with addChild!

addSceneShape: (%, SBoundary PT) -> %

addSceneShape(n, shape) is a convenience function which combines createSceneShape with addChild!

addSceneText: (%, List String, NonNegativeInteger, PT) -> %

addSceneText(n, str, sz, pz) is a convenience function which combines createSceneText with addChild!

addSceneText: (%, Record(txt: String, siz: NonNegativeInteger, pos: PT, np: List String)) -> %

addSceneText(n, text) is a convenience function which combines createSceneText with addChild!

addSceneText: (%, String, NonNegativeInteger, PT) -> %

addSceneText(n, str, sz, pz) is a convenience function which combines createSceneText with addChild!

addSceneTransform: (%, STransform PT) -> %

addSceneTransform(n, tran) is a convenience function which combines createSceneTransform with addChild!

addSceneUse: (%, String) -> %

addSceneUse(n, nam) is a convenience function which combines createSceneUse with addChild!

boundary: (%, DoubleFloat) -> SBoundary PT

boundary(n, fontScale) returns the boundary of a given node, so if this is called on the root node, it will return the boundary of the whole scene. There is a difficulty involving text nodes, that is they have a fixed font size. But we want to calculate the boundary in local coordinates, to do this conversion we need to know the total boundary size but that is what we are trying to calculate! To get round this contradiction the parameter fontScale is required since fonts are rendered at a fixed size we need a scaling factor so that we can give the boundary in our coordinate system. fontScale should be set to the full width of the diagram (not just the width of this node). If this is not known then choose an approximate value. This only affects text nodes, if this node, or its subnodes, do not contain a text node then its value is not significant.

coerce: % -> OutputForm

output a full scenegraph could contain a lot of data and so we have to be careful to restrict the output to what is reasonable on the command line. Therefore we do not display all subnodes or the full information from nodes such as IFS.

createArrows2Din2D: (PT -> PT, Segment DoubleFloat, Segment DoubleFloat, NonNegativeInteger) -> %

createArrows2Din2D(ptFun, uSeg, vSeg, numPts) creates arrows to represent output for each input point in other words this represents a two dimensional force field with the arrows showing the direction of the field

createPlot1Din2D: (DoubleFloat -> DoubleFloat, Segment DoubleFloat, NonNegativeInteger) -> %

createPlot1Din2D(f, tRange, numPts) creates two dimensional function plot. Draws the graph of y = f(x) as x ranges from min(a, b) to max(a, b). tRange is a..b

createPlot1Din2D: (DoubleFloat -> PT, Segment DoubleFloat, NonNegativeInteger) -> %

createPlot1Din2D(f, tRange, numPts) creates a two dimensional function plot draws the graph from a mapping of float to point as x ranges from min(a, b) to max(a, b). tRange is a..b

createPlot1Din2Dparametric: (ParametricPlaneCurve(DoubleFloat -> DoubleFloat), Segment DoubleFloat, NonNegativeInteger) -> %

createPlot1Din2Dparametric(ppc, tRange, numPts) creates a node from plot using Parametric Plane Curve. This represents 1 dimension (line - possibly curved) in 2 dimensions (plane) In theory a line has no width but in that case we would not see it so we give it a width given by the material node that is applicable in this part of the scene graph PPC is ParametricPlaneCurve(DF -> DF) which is created with curve(f1, f2) where f1 and f2 are functions of type ComponentFunction, in this case DF -> DF

createPlot1Din3Dparametric: (DoubleFloat -> PT, Segment DoubleFloat, NonNegativeInteger) -> %

createPlot1Din3Dparametric(pcfun, tRange, numPts) create a line (1D subspace) in 3D space. This represents 1 dimension (line - possibly curved) in 3 dimensions In theory a line has no width but in that case we would not see it so we give it a width given by the material node that is applicable in this part of the scene graph PCFUN is a function from float to point: DF -> PT

createPlot1Din3Dparametric: (ParametricSpaceCurve(DoubleFloat -> DoubleFloat), Segment DoubleFloat, NonNegativeInteger) -> %

createPlot1Din3Dparametric(psc, tRange, numPts) create a line (1D subspace) in 3D space. This represents 1 dimension (line - possibly curved) in 3 dimensions In theory a line has no width but in that case we would not see it so we give it a width given by the material node that is applicable in this part of the scene graph PSC ParametricSpaceCurve(DF -> DF) is created with curve(f1, f2, f3) where f1, f2 and f3 are functions of type ComponentFunction, in this case DF -> DF

createPlot2Din3D: ((DoubleFloat, DoubleFloat) -> DoubleFloat, Segment DoubleFloat, Segment DoubleFloat, NonNegativeInteger) -> %

createPlot2Din3D(f, a..b, c..d) returns a scene node which contains the graph of z = f(x, y) as x ranges from min(a, b) to max(a, b) and y ranges from min(c, d) to max(c, d). create a surface (2D subspace) in 3D space The surface is approximated by polygons which are represented by in indexed face set (IFS) node

createPlot2Din3D: ((DoubleFloat, DoubleFloat) -> PT, Segment DoubleFloat, Segment DoubleFloat, NonNegativeInteger) -> %

createPlot2Din3D(ptFun, uSeg, vSeg, numPts) create a surface (2D subspace) in 3D space. The surface is approximated by polygons which are represented by in indexed face set (IFS) node

createPlot2Din3Dparametric: ((DoubleFloat, DoubleFloat) -> PT, Segment DoubleFloat, Segment DoubleFloat, NonNegativeInteger) -> %

createPlot2Din3Dparametric(f, a..b, c..d, l) returns a scene node which contains the graph of the parametric surface f(u, v) as u ranges from min(a, b) to max(a, b) and v ranges from min(c, d) to max(c, d). This creates a surface (2D subspace) in 3D space The surface is approximated by polygons which are represented by in indexed face set (IFS) node

createPlot2Din3Dparametric: (ParametricSurface((DoubleFloat, DoubleFloat) -> DoubleFloat), Segment DoubleFloat, Segment DoubleFloat, NonNegativeInteger) -> %

createPlot2Din3Dparametric(surface(f, g, h), a..b, c..d, l) returns a scene node which contains the graph of the parametric surface x = f(u, v), y = g(u, v), z = h(u, v) as u ranges from min(a, b) to max(a, b) and v ranges from min(c, d) to max(c, d). This creates a surface (2D subspace) in 3D space The surface is approximated by polygons which are represented by in indexed face set (IFS) node

createSceneArrow: (%, %, PT, Symbol, DoubleFloat, DoubleFloat) -> %

createSceneArrow(st, en, offset, mode, size, fontScale) constructs an arrow node, in n-dimensional space, going from st to en. ‘st’ and ‘en’ are nodes in the scene and the arrows will be drawn upto their boundary. st is the node at the start of the arrow en is the node at the end of the arrow ‘mode’ and ‘size’ parameters determine the size of the arrowhead. mode can have the following values: “fixed”::Symbol -- fixed size line width given by ‘size’ parameter “proportional”::Symbol -- size as a proportion of the overall bounds “variable”::Symbol -- size as a proportion of the arrow length So “proportional” would typically be used when drawing a graph (in graph theory) where it looks better if each arrow head is the same. “variable” would typically be used when drawing a force field where a bigger arrow head might indicate a stronger force. fontScale should be set to the full width of the diagram (not just the width of this node). If this is not known then choose an approximate value. This only affects text nodes, if st or en, or its subnodes, do not contain a text node then its value is not significant.

createSceneArrow: (String, String, PT, Symbol, DoubleFloat) -> %

createSceneArrow(st, en, offset, mode, size) constructs an arrow node, in n-dimensional space, going from st to en. ‘st’ and ‘en’ are determined from a list of points from named points node. st is the start of the arrow en is the end of the arrow ‘mode’ and ‘size’ parameters determine the size of the arrowhead. mode can have the following values: “fixed”::Symbol -- fixed size line width given by ‘size’ parameter “proportional”::Symbol -- size as a proportion of the overall bounds “variable”::Symbol -- size as a proportion of the arrow length So “proportional” would typically be used when drawing a graph (in graph theory) where it looks better if each arrow head is the same. “variable” would typically be used when drawing a force field where a bigger arrow head might indicate a stronger force.

createSceneArrows: (List List PT, Symbol, DoubleFloat) -> %

createSceneArrows(line, mode, size) constructs an arrow node, this contains arrows (represented by a list of points) in n-dimensional space. The space is implicit in the PT and TR parameters supplied when this Scene was created. ‘mode’ and ‘size’ parameters determine the size of the arrowhead. mode can have the following values: “fixed”::Symbol -- fixed size line width given by ‘size’ parameter “proportional”::Symbol -- size as a proportion of the overall bounds “variable”::Symbol -- size as a proportion of the arrow length So “proportional” would typically be used when drawing a graph (in graph theory) where it looks better if each arrow head is the same. “variable” would typically be used when drawing a force field where a bigger arrow head might indicate a stronger force.

createSceneBox: DoubleFloat -> %

createSceneBox(size) constructs an indexed face set node which is a 3D box of a given size

createSceneClip: SBoundary PT -> %

createSceneClip(bb) constructs a clip node, clips its sub nodes in the coordinate system in force at the clip node.

createSceneDef: (String, %) -> %

createSceneDef(nam, nde) defines a point in the scenegraph so that it can be used elsewhere.

createSceneGraph: (DirectedGraph String, NonNegativeInteger, NonNegativeInteger, Boolean) -> %

createSceneGraph(g, x, y, dispArrowName) creates a graph theory diagram

createSceneGrid: (DoubleFloat, SBoundary PT) -> %

createSceneGrid(stepSize, bb) constructs a grid, consists of a group, under which are vertical and horizontal lines. The spacing between lines is given by step.

createSceneGrid: SBoundary PT -> %

createSceneGrid(bb) constructs a grid with narrow blue lines every 20 units wide blue lines every 100 units wide red lines every 200 units

createSceneGroup: () -> %

createSceneGroup() constructs a group node, this node does not do anything itself but contains other nodes

createSceneIFS: (List List NonNegativeInteger, List PT) -> %

createSceneIFS(inx, pts) constructs an indexed face set node, this defines a surface represented by a set of polygons in n-dimensional space.

createSceneIFS: SceneIFS PT -> %

createSceneIFS(in1) constructs an indexed face set node, this defines a surface represented by a set of polygons in n-dimensional space.

createSceneLine: (%, %, DoubleFloat) -> %

createSceneLine(st, en, fontScale) constructs a line node, that contains a line, in n-dimensions, from st to en. ‘st’ and ‘en’ are nodes in the scene and the line will be drawn upto their boundary. st is the node at the start of the line en is the node at the end of the line fontScale should be set to the full width of the diagram (not just the width of this node). If this is not known then choose an approximate value. This only affects text nodes, if st or en, or its subnodes, do not contain a text node then its value is not significant.

createSceneLine: (%, %, DoubleFloat, Boolean) -> %

createSceneLine(st, en, fontScale, shortenLine) constructs a line node, that contains a line, in n-dimensions, from st to en. ‘st’ and ‘en’ are nodes in the scene and the line will be drawn upto their boundary. st is the node at the start of the line en is the node at the end of the line fontScale should be set to the full width of the diagram (not just the width of this node). If this is not known then choose an approximate value. This only affects text nodes, if st or en, or its subnodes, do not contain a text node then its value is not significant. shortenLine if true line drawn upto boundary rather than centre of destination.

createSceneLine: List PT -> %

createSceneLine(line) constructs a line node, this contains a line (represented by a list of points) in n-dimensional space. The space is implicit in the PT and TR parameters supplied when this Scene was created.

createSceneLines: List List PT -> %

createSceneLines(line) constructs a line node, this contains lines (represented by a list of points) in n-dimensional space. The space is implicit in the PT and TR parameters supplied when this Scene was created.

createSceneMaterial: (DoubleFloat, String, String) -> %

createSceneMaterial(lineW, lineC, fillC) constructs a material node This sets the lineWidth, lineCol and fillCol for all nodes under this, unless overridden by another material node. That is the material parameters that apply to a given node are those of the closest material node above it in the hierarchy

createSceneMaterial: Record(lineWidth: DoubleFloat, lineCol: String, fillCol: String, matOpacity: DoubleFloat) -> %

createSceneMaterial(mat) constructs a material node This sets the lineWidth, lineCol and fillCol for all nodes under this, unless overridden by another material node. That is the material parameters that apply to a given node are those of the closest material node above it in the hierarchy line width is expressed relative to the width of current boundary

createSceneNamedPoints: SceneNamedPoints PT -> %

createSceneNamedPoints(np) constructs a named points node, this allows us to define a set of points which can be used multiple times in the scenegraph.

createScenePattern: (Symbol, NonNegativeInteger, SBoundary PT) -> %

createScenePattern(ptype, step, bb) creates a test pattern suitable for showing the effect of transforms. The pattern depends on ptype parameter as follows: ptype=”GRID”::Symbol : construct a set of horizontal and vertical lines in the current clip boundary and current material with a spacing between lines given by the step parameter. ptype=”SIERPINSKI”::Symbol: constructs a Sierpinski fractal. step parameter gives the level of subdivision. ptype=”HOUSE”::Symbol: constructs a house shape.

createSceneRoot: () -> %

createSceneRoot() constructs the root node, all other nodes are contained in a tree structure under this node

createSceneRoot: (Integer, Integer, Integer, Integer) -> %

createSceneRoot(minx, miny, maxx, maxy) constructs the root node, all other nodes are contained in a tree structure under this node

createSceneRoot: SBoundary PT -> %

createSceneRoot(bb) constructs the root node, all other nodes are contained in a tree structure under this node

createSceneRuler: (Symbol, PT, SBoundary PT) -> %

createSceneRuler(ptype, offset, bb) creates a scale that can be used to provide numeric values for an axis: ptype= “HORIZONTAL”::Symbol : horizontal axis. ptype= “VERTICAL”::Symbol: vertical axis. ptype= “DEBTH”::Symbol: depth axis.

createSceneShape: Record(shptype: Symbol, centre: PT, size: PT, fill: Boolean) -> %

createSceneShape(shape) constructs a shape node, this contains a shape such as a rectangle or an ellipse.

createSceneShape: SBoundary PT -> %

createSceneShape(shape) constructs a shape node from a boundary, this contains a shape such as a rectangle or an ellipse.

createSceneText: (List String, NonNegativeInteger, PT) -> %

createSceneText(str, sz, pz) constructs a text node using information from named points node.

createSceneText: (String, NonNegativeInteger, PT) -> %

createSceneText(str, sz, pz) constructs a text node, text can be used for labelling anything such as graphs, axes and so on.

createSceneText: Record(txt: String, siz: NonNegativeInteger, pos: PT, np: List String) -> %

createSceneText(text) constructs a text node, text can be used for labelling anything such as graphs, axes and so on.

createSceneTransform: STransform PT -> %

createSceneTransform(tran) constructs a transform node This transforms the points and vectors below this node If a given node has more than one transform node above it in the hierarchy then the transforms are compound

createSceneUse: String -> %

createSceneUse(nam) uses another point in the scenegraph.

removeChild!: (%, %) -> Void

removeChild!(n, c) removes the specified child node 'c' below node 'n'

setTransform!: (%, STransform PT) -> Void

setTransform!(n, tran) changes the transform without altering the scene hierarchy

toObj: (%, Reference List PT, Reference List List NonNegativeInteger, Reference NonNegativeInteger, STransform PT, SBoundary PT) -> Void

toObj(n, ptLst, indexLst, indexNxt, tran, bb) creates an .OBJ (Wavefront) file from scenegraph tree structure called recursively for each node, so when called on root node in scenegraph all other nodes in the scenegraph will get called. n is the scene to be output to ptLst and indexLst ptLst is the points. This will be set to ref([]) at the start and will be built up as this function is called recursively indexLst is list of faces, where faces are list of points indexed by ptLst This will be set to ref([]) at the start and will be built up as this function is called recursively tran is the default transform which may be overridden by subnodes bb is the default boundary which may be overridden by subnodes

toSVG: (%, Record(lineWidth: DoubleFloat, lineCol: String, fillCol: String, matOpacity: DoubleFloat), STransform PT, SBoundary PT, DoubleFloat, Boolean, Boolean, SceneNamedPoints PT) -> XmlElement

toSVG(n, mat, tran, bb, scale, clipEn, useInteger, npt) creates an XmlElement containing a ‘SVG’ representation of node 'n' and the nodes below it. n is the scene to be output to XML elements mat is the default material which may be overridden by subnodes tran is the default transform which may be overridden by subnodes bb is the default boundary which may be overridden by subnodes scale is the scale used to scale into canvas, it would be better to merge this into trans. clipEn if true this clips the output to the boundary useInteger if true truncate to integer values. npt names points can be provided. If not required then set to namedBranch([], [])

toX3D: (%, Record(lineWidth: DoubleFloat, lineCol: String, fillCol: String, matOpacity: DoubleFloat), STransform PT, SBoundary PT) -> XmlElement

toX3D(n, mat, tran, bb) creates an XmlElement containing a ‘X3D’ representation of node 'n' and the nodes below it. n is the scene to be output to XML elements mat is the default material which may be overridden by subnodes tran is the default transform which may be overridden by subnodes bb is the default boundary which may be overridden by subnodes

writeObj: (%, String) -> Void

writeObj(n, filename) writes an ‘OBJ’ (Wavefront) representation of node 'n' to the filename supplied.

writeSvg: (%, String) -> Void

writeSvg(n, filename) writes an ‘SVG’ representation of node 'n' to the filename supplied.

writeSvgQuantised: (%, String) -> Void

writeSvgQuantised(n, filename) writes an ‘SVG’ representation of node 'n' to the filename supplied.

writeVRML: (%, String) -> Void

writeVRML(n, filename) writes an ‘VRML’ representation of node 'n' to the filename supplied.

writeX3d: (%, String) -> Void

writeX3d: (n, filename) writes an ‘X3D’ representation of node 'n' to the filename supplied.