Scene PTΒΆ

scene.spad line 4016

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: (%, Record(mins: PT, maxs: PT)) -> %
deprecated: this has been superseded by version with SBoundary(PT) do not use, may be removed in the future.
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, Record(mins: PT, maxs: PT)) -> %
deprecated: this has been superseded by version with SBoundary(PT) do not use, may be removed in the future.
addSceneGrid: (%, DoubleFloat, SBoundary PT) -> %
addSceneGrid(n, stepSize, bb) is a convenience function which combines createSceneGrid with addChild!
addSceneGrid: (%, Record(mins: PT, maxs: PT)) -> %
deprecated: this has been superseded by version with SBoundary(PT) do not use, may be removed in the future.
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, Record(mins: PT, maxs: PT)) -> %
deprecated: this has been superseded by version with SBoundary(PT) do not use, may be removed in the future.
addScenePattern: (%, Symbol, NonNegativeInteger, SBoundary PT) -> %
addScenePattern(n, ptype, step, bb) is a convenience function which combines createScenePattern with addChild!
addSceneRuler: (%, Symbol, PT, Record(mins: PT, maxs: PT)) -> %
deprecated: this has been superseded by version with SBoundary(PT) do not use, may be removed in the future.
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: Record(mins: PT, maxs: PT) -> %
deprecated: this has been superseded by version with SBoundary(PT) do not use, may be removed in the future.
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, Record(mins: PT, maxs: PT)) -> %
deprecated: this has been superseded by version with SBoundary(PT) do not use, may be removed in the future.
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: Record(mins: PT, maxs: PT) -> %
deprecated: this has been superseded by version with SBoundary(PT) do not use, may be removed in the future.
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) 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, Record(mins: PT, maxs: PT)) -> %
deprecated: this has been superseded by version with SBoundary(PT) do not use, may be removed in the future.
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: Record(mins: PT, maxs: PT) -> %
deprecated: this has been superseded by version with SBoundary(PT) do not use, may be removed in the future.
createSceneRoot: SBoundary PT -> %
createSceneRoot(bb) constructs the root node, all other nodes are contained in a tree structure under this node
createSceneRuler: (Symbol, PT, Record(mins: PT, maxs: PT)) -> %
deprecated: this has been superseded by version with SBoundary(PT) do not use, may be removed in the future.
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, Record(mins: PT, maxs: PT)) -> Void
deprecated: this has been superseded by version with SBoundary(PT) do not use, may be removed in the future.
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, Record(mins: PT, maxs: PT), DoubleFloat, Boolean, Boolean, SceneNamedPoints PT) -> XmlElement
deprecated: this has been superseded by version with SBoundary(PT) do not use, may be removed in the future.
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, Record(mins: PT, maxs: PT)) -> XmlElement
deprecated: this has been superseded by version with SBoundary(PT) do not use, may be removed in the future.
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.