.. _sec-visualizationsettingsmain: ********************** Visualization settings ********************** This section includes hierarchical structures for visualization settings, e.g., drawing of nodes, bodies, connectors, loads and markers and furthermore openGL, window and save image options. For further information, see Section :ref:`sec-overview-basics-visualizationsettings`\ . .. _sec-vsettingsgeneral: VSettingsGeneral ---------------- General settings for visualization. VSettingsGeneral has the following items: * | **autoFitScene** [type = bool, default = True]: | \ ``SC.visualizationSettings.general.autoFitScene``\ | automatically fit scene within startup after StartRenderer() * | **axesTiling** [type = PInt, default = 12]: | \ ``SC.visualizationSettings.general.axesTiling``\ | global number of segments for drawing cylinders for axes and cones for arrows (reduce this number, e.g. to 4, if many axes are drawn) * | **backgroundColor** [type = Float4, default = [1.0,1.0,1.0,1.0], size = 4]: | \ ``SC.visualizationSettings.general.backgroundColor``\ | red, green, blue and alpha values for background color of render window (white=[1,1,1,1]; black = [0,0,0,1]) * | **backgroundColorBottom** [type = Float4, default = [0.8,0.8,1.0,1.0], size = 4]: | \ ``SC.visualizationSettings.general.backgroundColorBottom``\ | red, green, blue and alpha values for bottom background color in case that useGradientBackground = True * | **circleTiling** [type = PInt, default = 16]: | \ ``SC.visualizationSettings.general.circleTiling``\ | global number of segments for circles; if smaller than 2, 2 segments are used (flat) * | **coordinateSystemSize** [type = float, default = 5.]: | \ ``SC.visualizationSettings.general.coordinateSystemSize``\ | size of coordinate system relative to font size * | **cylinderTiling** [type = PInt, default = 16]: | \ ``SC.visualizationSettings.general.cylinderTiling``\ | global number of segments for cylinders; if smaller than 2, 2 segments are used (flat) * | **drawCoordinateSystem** [type = bool, default = True]: | \ ``SC.visualizationSettings.general.drawCoordinateSystem``\ | false = no coordinate system shown * | **drawWorldBasis** [type = bool, default = False]: | \ ``SC.visualizationSettings.general.drawWorldBasis``\ | true = draw world basis coordinate system at (0,0,0) * | **graphicsUpdateInterval** [type = float, default = 0.1]: | \ ``SC.visualizationSettings.general.graphicsUpdateInterval``\ | interval of graphics update during simulation in seconds; 0.1 = 10 frames per second; low numbers might slow down computation speed * | **linuxDisplayScaleFactor** [type = PFloat, default = 1.]: | \ ``SC.visualizationSettings.general.linuxDisplayScaleFactor``\ | Scaling factor for linux, which cannot determined from system by now; adjust this value to scale dialog fonts and renderer fonts * | **minSceneSize** [type = float, default = 0.1]: | \ ``SC.visualizationSettings.general.minSceneSize``\ | minimum scene size for initial scene size and for autoFitScene, to avoid division by zero; SET GREATER THAN ZERO * | **pointSize** [type = float, default = 0.01]: | \ ``SC.visualizationSettings.general.pointSize``\ | global point size (absolute) * | **rendererPrecision** [type = PInt, default = 4]: | \ ``SC.visualizationSettings.general.rendererPrecision``\ | precision of general floating point numbers shown in render window: total number of digits used (max. 16) * | **renderWindowString** [type = String, default = '']: | \ ``SC.visualizationSettings.general.renderWindowString``\ | string shown in render window (use this, e.g., for debugging, etc.; written below EXUDYN, similar to solutionInformation in SimulationSettings.solutionSettings) * | **showComputationInfo** [type = bool, default = True]: | \ ``SC.visualizationSettings.general.showComputationInfo``\ | true = show (hide) all computation information including Exudyn and version * | **showHelpOnStartup** [type = PInt, default = 5]: | \ ``SC.visualizationSettings.general.showHelpOnStartup``\ | seconds to show help message on startup (0=deactivate) * | **showSolutionInformation** [type = bool, default = True]: | \ ``SC.visualizationSettings.general.showSolutionInformation``\ | true = show solution information (from simulationSettings.solution) * | **showSolverInformation** [type = bool, default = True]: | \ ``SC.visualizationSettings.general.showSolverInformation``\ | true = solver name and further information shown in render window * | **showSolverTime** [type = bool, default = True]: | \ ``SC.visualizationSettings.general.showSolverTime``\ | true = solver current time shown in render window * | **sphereTiling** [type = PInt, default = 6]: | \ ``SC.visualizationSettings.general.sphereTiling``\ | global number of segments for spheres; if smaller than 2, 2 segments are used (flat) * | **textAlwaysInFront** [type = bool, default = True]: | \ ``SC.visualizationSettings.general.textAlwaysInFront``\ | if true, text for item numbers and other item-related text is drawn in front; this may be unwanted in case that you only with to see numbers of objects in front; currently does not work with perspective * | **textColor** [type = Float4, default = [0.,0.,0.,1.0], size = 4]: | \ ``SC.visualizationSettings.general.textColor``\ | general text color (default); used for system texts in render window * | **textHasBackground** [type = bool, default = False]: | \ ``SC.visualizationSettings.general.textHasBackground``\ | if true, text for item numbers and other item-related text have a background (depending on text color), allowing for better visibility if many numbers are shown; the text itself is black; therefore, dark background colors are ignored and shown as white * | **textOffsetFactor** [type = UFloat, default = 0.005]: | \ ``SC.visualizationSettings.general.textOffsetFactor``\ | This is an additional out of plane offset for item texts (node number, etc.); the factor is relative to the maximum scene size and is only used, if textAlwaysInFront=False; this factor allows to draw text, e.g., in front of nodes * | **textSize** [type = float, default = 12.]: | \ ``SC.visualizationSettings.general.textSize``\ | general text size (font size) in pixels if not overwritten; if useWindowsDisplayScaleFactor=True, the the textSize is multplied with the windows display scaling (monitor scaling; content scaling) factor for larger texts on on high resolution displays; for bitmap fonts, the maximum size of any font (standard/large/huge) is limited to 256 (which is not recommended, especially if you do not have a powerful graphics card) * | **threadSafeGraphicsUpdate** [type = bool, default = True]: | \ ``SC.visualizationSettings.general.threadSafeGraphicsUpdate``\ | true = updating of visualization is threadsafe, but slower for complicated models; deactivate this to speed up computation, but activate for generation of animations; may be improved in future by adding a safe visualizationUpdate state * | **useBitmapText** [type = bool, default = True]: | \ ``SC.visualizationSettings.general.useBitmapText``\ | if true, texts are displayed using pre-defined bitmaps for the text; may increase the complexity of your scene, e.g., if many (>10000) node numbers shown * | **useGradientBackground** [type = bool, default = False]: | \ ``SC.visualizationSettings.general.useGradientBackground``\ | true = use vertical gradient for background; * | **useMultiThreadedRendering** [type = bool, default = True]: | \ ``SC.visualizationSettings.general.useMultiThreadedRendering``\ | true = rendering is done in separate thread; false = no separate thread, which may be more stable but has lagging interaction for large models (do not interact with models during simulation); set this parameter before call to exudyn.StartRenderer(); MAC OS: uses always false, because MAC OS does not support multi threaded GLFW * | **useWindowsDisplayScaleFactor** [type = bool, default = True]: | \ ``SC.visualizationSettings.general.useWindowsDisplayScaleFactor``\ | the Windows display scaling (monitor scaling; content scaling) factor is used for increased visibility of texts on high resolution displays; based on GLFW glfwGetWindowContentScale; deactivated on linux compilation as it leads to crashes (adjust textSize manually!) * | **worldBasisSize** [type = float, default = 1.0]: | \ ``SC.visualizationSettings.general.worldBasisSize``\ | size of world basis coordinate system .. _sec-vsettingscontour: VSettingsContour ---------------- Settings for contour plots; use these options to visualize field data, such as displacements, stresses, strains, etc. for bodies, nodes and finite elements. VSettingsContour has the following items: * | **automaticRange** [type = bool, default = True]: | \ ``SC.visualizationSettings.contour.automaticRange``\ | if true, the contour plot value range is chosen automatically to the maximum range * | **colorBarPrecision** [type = PInt, default = 4]: | \ ``SC.visualizationSettings.contour.colorBarPrecision``\ | precision of floating point values shown in color bar; total number of digits used (max. 16) * | **colorBarTiling** [type = PInt, default = 12, size = 1]: | \ ``SC.visualizationSettings.contour.colorBarTiling``\ | number of tiles (segements) shown in the colorbar for the contour plot * | **maxValue** [type = float, default = 1, size = 1]: | \ ``SC.visualizationSettings.contour.maxValue``\ | maximum value for contour plot; set manually, if automaticRange == False * | **minValue** [type = float, default = 0, size = 1]: | \ ``SC.visualizationSettings.contour.minValue``\ | minimum value for contour plot; set manually, if automaticRange == False * | **nodesColored** [type = bool, default = True]: | \ ``SC.visualizationSettings.contour.nodesColored``\ | if true, the contour color is also applied to nodes (except mesh nodes), otherwise node drawing is not influenced by contour settings * | **outputVariable** [type = OutputVariableType, default = OutputVariableType::\_None]: | \ ``SC.visualizationSettings.contour.outputVariable``\ | selected contour plot output variable type; select OutputVariableType._None to deactivate contour plotting. * | **outputVariableComponent** [type = Int, default = 0, size = 1]: | \ ``SC.visualizationSettings.contour.outputVariableComponent``\ | select the component of the chosen output variable; e.g., for displacements, 3 components are available: 0 == x, 1 == y, 2 == z component; for stresses, 6 components are available, see OutputVariableType description; to draw the norm of a outputVariable, set component to -1; if a certain component is not available by certain objects or nodes, no value is drawn (using default color) * | **reduceRange** [type = bool, default = True]: | \ ``SC.visualizationSettings.contour.reduceRange``\ | if true, the contour plot value range is also reduced; better for static computation; in dynamic computation set this option to false, it can reduce visualization artifacts; you should also set minVal to max(float) and maxVal to min(float) * | **rigidBodiesColored** [type = bool, default = True]: | \ ``SC.visualizationSettings.contour.rigidBodiesColored``\ | if true, the contour color is also applied to triangular faces of rigid bodies and mass points, otherwise the rigid body drawing are not influenced by contour settings; for general rigid bodies (except for ObjectGround), Position, Displacement, DisplacementLocal(=0), Velocity, VelocityLocal, AngularVelocity, and AngularVelocityLocal are available; may slow down visualization! * | **showColorBar** [type = bool, default = True]: | \ ``SC.visualizationSettings.contour.showColorBar``\ | show the colour bar with minimum and maximum values for the contour plot .. _sec-vsettingsnodes: VSettingsNodes -------------- Visualization settings for nodes. VSettingsNodes has the following items: * | **basisSize** [type = float, default = 0.2]: | \ ``SC.visualizationSettings.nodes.basisSize``\ | size of basis for nodes * | **defaultColor** [type = Float4, default = [0.2,0.2,1.,1.], size = 4]: | \ ``SC.visualizationSettings.nodes.defaultColor``\ | default RGBA color for nodes; 4th value is alpha-transparency * | **defaultSize** [type = float, default = -1.]: | \ ``SC.visualizationSettings.nodes.defaultSize``\ | global node size; if -1.f, node size is relative to openGL.initialMaxSceneSize * | **drawNodesAsPoint** [type = bool, default = True]: | \ ``SC.visualizationSettings.nodes.drawNodesAsPoint``\ | simplified/faster drawing of nodes; uses general->pointSize as drawing size; if drawNodesAsPoint==True, the basis of the node will be drawn with lines * | **show** [type = bool, default = True]: | \ ``SC.visualizationSettings.nodes.show``\ | flag to decide, whether the nodes are shown * | **showBasis** [type = bool, default = False]: | \ ``SC.visualizationSettings.nodes.showBasis``\ | show basis (three axes) of coordinate system in 3D nodes * | **showNodalSlopes** [type = UInt, default = False]: | \ ``SC.visualizationSettings.nodes.showNodalSlopes``\ | draw nodal slope vectors, e.g. in ANCF beam finite elements * | **showNumbers** [type = bool, default = False]: | \ ``SC.visualizationSettings.nodes.showNumbers``\ | flag to decide, whether the node number is shown * | **tiling** [type = PInt, default = 4]: | \ ``SC.visualizationSettings.nodes.tiling``\ | tiling for node if drawn as sphere; used to lower the amount of triangles to draw each node; if drawn as circle, this value is multiplied with 4 .. _sec-vsettingsbeams: VSettingsBeams -------------- Visualization settings for beam finite elements. VSettingsBeams has the following items: * | **axialTiling** [type = PInt, default = 8]: | \ ``SC.visualizationSettings.bodies.beams.axialTiling``\ | number of segments to discretise the beams axis * | **crossSectionFilled** [type = bool, default = True]: | \ ``SC.visualizationSettings.bodies.beams.crossSectionFilled``\ | if implemented for element, cross section is drawn as solid (filled) instead of wire-frame; NOTE: some quantities may not be interpolated correctly over cross section in visualization * | **crossSectionTiling** [type = PInt, default = 4]: | \ ``SC.visualizationSettings.bodies.beams.crossSectionTiling``\ | number of quads drawn over height of beam, if drawn as flat objects; leads to higher accuracy of components drawn over beam height or with, but also to larger CPU costs for drawing * | **drawVertical** [type = bool, default = False]: | \ ``SC.visualizationSettings.bodies.beams.drawVertical``\ | draw contour plot outputVariables 'vertical' along beam height; contour.outputVariable must be set accordingly * | **drawVerticalColor** [type = Float4, default = [0.2,0.2,0.2,1.], size = 4]: | \ ``SC.visualizationSettings.bodies.beams.drawVerticalColor``\ | color for outputVariable to be drawn along cross section (vertically) * | **drawVerticalFactor** [type = float, default = 1.]: | \ ``SC.visualizationSettings.bodies.beams.drawVerticalFactor``\ | factor for outputVariable to be drawn along cross section (vertically) * | **drawVerticalLines** [type = bool, default = True]: | \ ``SC.visualizationSettings.bodies.beams.drawVerticalLines``\ | draw additional vertical lines for better visibility * | **drawVerticalOffset** [type = float, default = 0.]: | \ ``SC.visualizationSettings.bodies.beams.drawVerticalOffset``\ | offset for vertical drawn lines; offset is added before multiplication with drawVerticalFactor * | **drawVerticalValues** [type = bool, default = False]: | \ ``SC.visualizationSettings.bodies.beams.drawVerticalValues``\ | show values at vertical lines; note that these numbers are interpolated values and may be different from values evaluated directly at this point! * | **reducedAxialInterploation** [type = bool, default = True]: | \ ``SC.visualizationSettings.bodies.beams.reducedAxialInterploation``\ | if True, the interpolation along the beam axis may be lower than the beam element order; this may be, however, show more consistent values than a full interpolation, e.g. for strains or forces .. _sec-vsettingskinematictree: VSettingsKinematicTree ---------------------- Visualization settings for kinematic trees. VSettingsKinematicTree has the following items: * | **frameSize** [type = float, default = 0.2]: | \ ``SC.visualizationSettings.bodies.kinematicTree.frameSize``\ | size of COM and joint frames * | **showCOMframes** [type = bool, default = False]: | \ ``SC.visualizationSettings.bodies.kinematicTree.showCOMframes``\ | if True, a frame is attached to every center of mass * | **showFramesNumbers** [type = bool, default = False]: | \ ``SC.visualizationSettings.bodies.kinematicTree.showFramesNumbers``\ | if True, numbers are drawn for joint frames (O[i]J[j]) and COM frames (O[i]COM[j]) for object [i] and local joint [j] * | **showJointFrames** [type = bool, default = True]: | \ ``SC.visualizationSettings.bodies.kinematicTree.showJointFrames``\ | if True, a frame is attached to the origin of every joint frame .. _sec-vsettingsbodies: VSettingsBodies --------------- Visualization settings for bodies. VSettingsBodies has the following items: * | **beams** [type = VSettingsBeams]: | \ ``SC.visualizationSettings.bodies.beams``\ | visualization settings for beams (e.g. ANCFCable or other beam elements) * | **kinematicTree** [type = VSettingsKinematicTree]: | \ ``SC.visualizationSettings.bodies.kinematicTree``\ | visualization settings for kinematic tree * | **defaultColor** [type = Float4, default = [0.3,0.3,1.,1.], size = 4]: | \ ``SC.visualizationSettings.bodies.defaultColor``\ | default RGBA color for bodies; 4th value is * | **defaultSize** [type = Float3, default = [1.,1.,1.], size = 3]: | \ ``SC.visualizationSettings.bodies.defaultSize``\ | global body size of xyz-cube * | **deformationScaleFactor** [type = float, default = 1]: | \ ``SC.visualizationSettings.bodies.deformationScaleFactor``\ | global deformation scale factor; also applies to nodes, if drawn; currently only used for scaled drawing of (linear) finite elements in FFRF and FFRFreducedOrder objects * | **show** [type = bool, default = True]: | \ ``SC.visualizationSettings.bodies.show``\ | flag to decide, whether the bodies are shown * | **showNumbers** [type = bool, default = False]: | \ ``SC.visualizationSettings.bodies.showNumbers``\ | flag to decide, whether the body(=object) number is shown .. _sec-vsettingsconnectors: VSettingsConnectors ------------------- Visualization settings for connectors. VSettingsConnectors has the following items: * | **contactPointsDefaultSize** [type = float, default = 0.02]: | \ ``SC.visualizationSettings.connectors.contactPointsDefaultSize``\ | DEPRECATED: do not use! global contact points size; if -1.f, connector size is relative to maxSceneSize * | **defaultColor** [type = Float4, default = [0.2,0.2,1.,1.], size = 4]: | \ ``SC.visualizationSettings.connectors.defaultColor``\ | default RGBA color for connectors; 4th value is alpha-transparency * | **defaultSize** [type = float, default = 0.1]: | \ ``SC.visualizationSettings.connectors.defaultSize``\ | global connector size; if -1.f, connector size is relative to maxSceneSize * | **jointAxesLength** [type = float, default = 0.2]: | \ ``SC.visualizationSettings.connectors.jointAxesLength``\ | global joint axes length * | **jointAxesRadius** [type = float, default = 0.02]: | \ ``SC.visualizationSettings.connectors.jointAxesRadius``\ | global joint axes radius * | **show** [type = bool, default = True]: | \ ``SC.visualizationSettings.connectors.show``\ | flag to decide, whether the connectors are shown * | **showContact** [type = bool, default = False]: | \ ``SC.visualizationSettings.connectors.showContact``\ | flag to decide, whether contact points, lines, etc. are shown * | **showJointAxes** [type = bool, default = False]: | \ ``SC.visualizationSettings.connectors.showJointAxes``\ | flag to decide, whether contact joint axes of 3D joints are shown * | **showNumbers** [type = bool, default = False]: | \ ``SC.visualizationSettings.connectors.showNumbers``\ | flag to decide, whether the connector(=object) number is shown * | **springNumberOfWindings** [type = PInt, default = 8]: | \ ``SC.visualizationSettings.connectors.springNumberOfWindings``\ | number of windings for springs drawn as helical spring .. _sec-vsettingsmarkers: VSettingsMarkers ---------------- Visualization settings for markers. VSettingsMarkers has the following items: * | **defaultColor** [type = Float4, default = [0.1,0.5,0.1,1.], size = 4]: | \ ``SC.visualizationSettings.markers.defaultColor``\ | default RGBA color for markers; 4th value is alpha-transparency * | **defaultSize** [type = float, default = -1.]: | \ ``SC.visualizationSettings.markers.defaultSize``\ | global marker size; if -1.f, marker size is relative to maxSceneSize * | **drawSimplified** [type = bool, default = True]: | \ ``SC.visualizationSettings.markers.drawSimplified``\ | draw markers with simplified symbols * | **show** [type = bool, default = True]: | \ ``SC.visualizationSettings.markers.show``\ | flag to decide, whether the markers are shown * | **showNumbers** [type = bool, default = False]: | \ ``SC.visualizationSettings.markers.showNumbers``\ | flag to decide, whether the marker numbers are shown .. _sec-vsettingsloads: VSettingsLoads -------------- Visualization settings for loads. VSettingsLoads has the following items: * | **defaultColor** [type = Float4, default = [0.7,0.1,0.1,1.], size = 4]: | \ ``SC.visualizationSettings.loads.defaultColor``\ | default RGBA color for loads; 4th value is alpha-transparency * | **defaultRadius** [type = float, default = 0.005]: | \ ``SC.visualizationSettings.loads.defaultRadius``\ | global radius of load axis if drawn in 3D * | **defaultSize** [type = float, default = 0.2]: | \ ``SC.visualizationSettings.loads.defaultSize``\ | global load size; if -1.f, load size is relative to maxSceneSize * | **drawSimplified** [type = bool, default = True]: | \ ``SC.visualizationSettings.loads.drawSimplified``\ | draw markers with simplified symbols * | **drawWithUserFunction** [type = bool, default = True]: | \ ``SC.visualizationSettings.loads.drawWithUserFunction``\ | draw loads like force vectors time dependent; make sure that fixedLoadSize=false, while otherwise only the direction will change; user functions can only be drawn, if they are either symbolic or for Python user functions if useMultiThreadedRendering=False * | **fixedLoadSize** [type = bool, default = True]: | \ ``SC.visualizationSettings.loads.fixedLoadSize``\ | if true, the load is drawn with a fixed vector length in direction of the load vector, independently of the load size * | **loadSizeFactor** [type = float, default = 0.1]: | \ ``SC.visualizationSettings.loads.loadSizeFactor``\ | if fixedLoadSize=false, then this scaling factor is used to draw the load vector * | **show** [type = bool, default = True]: | \ ``SC.visualizationSettings.loads.show``\ | flag to decide, whether the loads are shown * | **showNumbers** [type = bool, default = False]: | \ ``SC.visualizationSettings.loads.showNumbers``\ | flag to decide, whether the load numbers are shown .. _sec-vsettingssensortraces: VSettingsSensorTraces --------------------- Visualization settings for traces of sensors. Note that a large number of time points (influenced by simulationSettings.solutionSettings.sensorsWritePeriod) may lead to slow graphics. VSettingsSensorTraces has the following items: * | **lineWidth** [type = UFloat, default = 2.]: | \ ``SC.visualizationSettings.sensorTraces.lineWidth``\ | line width for traces * | **listOfPositionSensors** [type = ArrayIndex, default = [], size = -1]: | \ ``SC.visualizationSettings.sensorTraces.listOfPositionSensors``\ | list of position sensors which can be shown as trace inside render window if sensors have storeInternal=True; if this list is empty and showPositionTrace=True, then all available sensors are shown * | **listOfTriadSensors** [type = ArrayIndex, default = [], size = -1]: | \ ``SC.visualizationSettings.sensorTraces.listOfTriadSensors``\ | list of sensors of with OutputVariableType RotationMatrix; this non-empty list needs to coincide in length with the listOfPositionSensors to be shown if showTriads=True; the triad is drawn at the related position * | **listOfVectorSensors** [type = ArrayIndex, default = [], size = -1]: | \ ``SC.visualizationSettings.sensorTraces.listOfVectorSensors``\ | list of sensors with 3D vector quantities; this non-empty list needs to coincide in length with the listOfPositionSensors to be shown if showVectors=True; the vector quantity is drawn relative to the related position * | **positionsShowEvery** [type = PInt, default = 1]: | \ ``SC.visualizationSettings.sensorTraces.positionsShowEvery``\ | integer value i; out of available sensor data, show every i-th position * | **sensorsMbsNumber** [type = Index, default = 0]: | \ ``SC.visualizationSettings.sensorTraces.sensorsMbsNumber``\ | number of main system which is used to for sensor lists; if only 1 mbs is in the SystemContainer, use 0; if there are several mbs, it needs to specify the number * | **showCurrent** [type = bool, default = True]: | \ ``SC.visualizationSettings.sensorTraces.showCurrent``\ | show current trace position (and especially vector quantity) related to current visualization state; this only works in solution viewer if sensor values are stored at time grid points of the solution file (up to a precision of 1e-10) and may therefore be temporarily unavailable * | **showFuture** [type = bool, default = False]: | \ ``SC.visualizationSettings.sensorTraces.showFuture``\ | show trace future to current visualization state if already computed (e.g. in SolutionViewer) * | **showPast** [type = bool, default = True]: | \ ``SC.visualizationSettings.sensorTraces.showPast``\ | show trace previous to current visualization state * | **showPositionTrace** [type = bool, default = False]: | \ ``SC.visualizationSettings.sensorTraces.showPositionTrace``\ | show position trace of all position sensors if listOfPositionSensors=[] or of specified sensors; sensors need to activate storeInternal=True * | **showTriads** [type = bool, default = False]: | \ ``SC.visualizationSettings.sensorTraces.showTriads``\ | if True, show basis vectors from rotation matrices provided by sensors * | **showVectors** [type = bool, default = False]: | \ ``SC.visualizationSettings.sensorTraces.showVectors``\ | if True, show vector quantities according to description in showPositionTrace * | **traceColors** [type = ArrayFloat, default = [0.2,0.2,0.2,1., 0.8,0.2,0.2,1., 0.2,0.8,0.2,1., 0.2,0.2,0.8,1., 0.2,0.8,0.8,1., 0.8,0.2,0.8,1., 0.8,0.4,0.1,1.], size = -1]: | \ ``SC.visualizationSettings.sensorTraces.traceColors``\ | RGBA float values for traces in one array; using 6x4 values gives different colors for 6 traces; in case of triads, the 0/1/2-axes are drawn in red, green, and blue * | **triadSize** [type = float, default = 0.1 ]: | \ ``SC.visualizationSettings.sensorTraces.triadSize``\ | length of triad axes if shown * | **triadsShowEvery** [type = PInt, default = 1]: | \ ``SC.visualizationSettings.sensorTraces.triadsShowEvery``\ | integer value i; out of available sensor data, show every i-th triad * | **vectorScaling** [type = float, default = 0.01]: | \ ``SC.visualizationSettings.sensorTraces.vectorScaling``\ | scaling of vector quantities; if, e.g., loads, this factor has to be adjusted significantly * | **vectorsShowEvery** [type = PInt, default = 1]: | \ ``SC.visualizationSettings.sensorTraces.vectorsShowEvery``\ | integer value i; out of available sensor data, show every i-th vector .. _sec-vsettingssensors: VSettingsSensors ---------------- Visualization settings for sensors. VSettingsSensors has the following items: * | **traces** [type = VSettingsSensorTraces]: | \ ``SC.visualizationSettings.sensors.traces``\ | settings for showing (position) sensor traces and vector plots in the render window * | **defaultColor** [type = Float4, default = [0.6,0.6,0.1,1.], size = 4]: | \ ``SC.visualizationSettings.sensors.defaultColor``\ | default RGBA color for sensors; 4th value is alpha-transparency * | **defaultSize** [type = float, default = -1.]: | \ ``SC.visualizationSettings.sensors.defaultSize``\ | global sensor size; if -1.f, sensor size is relative to maxSceneSize * | **drawSimplified** [type = bool, default = True]: | \ ``SC.visualizationSettings.sensors.drawSimplified``\ | draw sensors with simplified symbols * | **show** [type = bool, default = True]: | \ ``SC.visualizationSettings.sensors.show``\ | flag to decide, whether the sensors are shown * | **showNumbers** [type = bool, default = False]: | \ ``SC.visualizationSettings.sensors.showNumbers``\ | flag to decide, whether the sensor numbers are shown .. _sec-vsettingscontact: VSettingsContact ---------------- Global visualization settings for GeneralContact. This allows to easily switch on/off during visualization. VSettingsContact has the following items: * | **colorBoundingBoxes** [type = Float4, default = [0.9,0.1,0.1,1.], size = 4]: | \ ``SC.visualizationSettings.contact.colorBoundingBoxes``\ | RGBA color for boudnding boxes, see showBoundingBoxes * | **colorSearchTree** [type = Float4, default = [0.1,0.1,0.9,1.], size = 4]: | \ ``SC.visualizationSettings.contact.colorSearchTree``\ | RGBA color for search tree, see showSearchTree * | **colorSpheres** [type = Float4, default = [0.8,0.8,0.2,1.], size = 4]: | \ ``SC.visualizationSettings.contact.colorSpheres``\ | RGBA color for contact spheres, see showSpheres * | **colorTriangles** [type = Float4, default = [0.5,0.5,0.5,1.], size = 4]: | \ ``SC.visualizationSettings.contact.colorTriangles``\ | RGBA color for contact triangles, see showTriangles * | **contactForcesFactor** [type = float, default = 0.001]: | \ ``SC.visualizationSettings.contact.contactForcesFactor``\ | factor used for scaling of contact forces is showContactForces=True * | **contactPointsDefaultSize** [type = float, default = 0.001]: | \ ``SC.visualizationSettings.contact.contactPointsDefaultSize``\ | global contact points size; if -1.f, connector size is relative to maxSceneSize; used for some contacts, e.g., in ContactFrictionCircle * | **showBoundingBoxes** [type = bool, default = False]: | \ ``SC.visualizationSettings.contact.showBoundingBoxes``\ | show computed bounding boxes of all GeneralContacts; Warning: avoid for large number of contact objects! * | **showContactForces** [type = bool, default = False]: | \ ``SC.visualizationSettings.contact.showContactForces``\ | if True, contact forces are drawn for certain contact models * | **showContactForcesValues** [type = bool, default = False]: | \ ``SC.visualizationSettings.contact.showContactForcesValues``\ | if True and showContactForces=True, numerical values for contact forces are shown at certain points * | **showSearchTree** [type = bool, default = False]: | \ ``SC.visualizationSettings.contact.showSearchTree``\ | show outer box of search tree for all GeneralContacts * | **showSearchTreeCells** [type = bool, default = False]: | \ ``SC.visualizationSettings.contact.showSearchTreeCells``\ | show all cells of search tree; empty cells have colorSearchTree, cells with contact objects have higher red value; Warning: avoid for large number of search tree cells! * | **showSpheres** [type = bool, default = False]: | \ ``SC.visualizationSettings.contact.showSpheres``\ | show contact spheres (SpheresWithMarker, ...) * | **showTriangles** [type = bool, default = False]: | \ ``SC.visualizationSettings.contact.showTriangles``\ | show contact triangles (TrianglesRigidBodyBased, ...) * | **tilingSpheres** [type = PInt, default = 4]: | \ ``SC.visualizationSettings.contact.tilingSpheres``\ | tiling for spheres; higher values give smoother spheres, but may lead to lower frame rates .. _sec-vsettingswindow: VSettingsWindow --------------- OpenGL Window and interaction settings for visualization; handle changes with care, as they might lead to unexpected results or crashes. VSettingsWindow has the following items: * | **alwaysOnTop** [type = bool, default = False]: | \ ``SC.visualizationSettings.window.alwaysOnTop``\ | True: OpenGL render window will be always on top of all other windows * | **ignoreKeys** [type = bool, default = False]: | \ ``SC.visualizationSettings.window.ignoreKeys``\ | True: ignore keyboard input except escape and 'F2' keys; used for interactive mode, e.g., to perform kinematic analysis; This flag can be switched with key 'F2' * | **keyPressUserFunction** [type = KeyPressUserFunction, default = 0]: | \ ``SC.visualizationSettings.window.keyPressUserFunction``\ | add a Python function f(key, action, mods) here, which is called every time a key is pressed; function shall return true, if key has been processed; Example: def f(key, action, mods): \phantom{XXX} print('key=',key); use chr(key) to convert key codes [32 ...96] to ascii; special key codes (>256) are provided in the exudyn.KeyCode enumeration type; key action needs to be checked (0=released, 1=pressed, 2=repeated); mods provide information (binary) for SHIFT (1), CTRL (2), ALT (4), Super keys (8), CAPSLOCK (16) * | **limitWindowToScreenSize** [type = bool, default = True]: | \ ``SC.visualizationSettings.window.limitWindowToScreenSize``\ | True: render window size is limited to screen size; False: larger window sizes (e.g. for rendering) allowed according to renderWindowSize * | **maximize** [type = bool, default = False]: | \ ``SC.visualizationSettings.window.maximize``\ | True: OpenGL render window will be maximized at startup * | **reallyQuitTimeLimit** [type = UReal, default = 900]: | \ ``SC.visualizationSettings.window.reallyQuitTimeLimit``\ | number of seconds after which user is asked a security question before stopping simulation and closing renderer; set to 0 in order to always get asked; set to 1e10 to (nearly) never get asked * | **renderWindowSize** [type = Index2, default = [1024,768], size = 2]: | \ ``SC.visualizationSettings.window.renderWindowSize``\ | initial size of OpenGL render window in pixel * | **ResetKeyPressUserFunction()** [return type = void]: | set keyPressUserFunction to zero (no function); because this cannot be assign to the variable itself * | **showMouseCoordinates** [type = bool, default = False]: | \ ``SC.visualizationSettings.window.showMouseCoordinates``\ | True: show OpenGL coordinates and distance to last left mouse button pressed position; switched on/off with key 'F3' * | **showWindow** [type = bool, default = True]: | \ ``SC.visualizationSettings.window.showWindow``\ | True: OpenGL render window is shown on startup; False: window will be iconified at startup (e.g. if you are starting multiple computations automatically) * | **startupTimeout** [type = PInt, default = 2500]: | \ ``SC.visualizationSettings.window.startupTimeout``\ | OpenGL render window startup timeout in ms (change might be necessary if CPU is very slow) .. _sec-vsettingsdialogs: VSettingsDialogs ---------------- Settings related to dialogs (e.g., visualization settings dialog). VSettingsDialogs has the following items: * | **alphaTransparency** [type = UFloat, default = 0.94]: | \ ``SC.visualizationSettings.dialogs.alphaTransparency``\ | alpha-transparency of dialogs; recommended range 0.7 (very transparent) - 1 (not transparent at all) * | **alwaysTopmost** [type = bool, default = True]: | \ ``SC.visualizationSettings.dialogs.alwaysTopmost``\ | True: dialogs are always topmost (otherwise, they are sometimes hidden) * | **fontScalingMacOS** [type = UFloat, default = 1.35]: | \ ``SC.visualizationSettings.dialogs.fontScalingMacOS``\ | font scaling value for MacOS systems (on Windows, system display scaling is used) * | **multiThreadedDialogs** [type = bool, default = True]: | \ ``SC.visualizationSettings.dialogs.multiThreadedDialogs``\ | True: During dialogs, the OpenGL render window will still get updates of changes in dialogs, etc., which may cause problems on some platforms or for some (complicated) models; False: changes of dialogs will take effect when dialogs are closed * | **openTreeView** [type = bool, default = False]: | \ ``SC.visualizationSettings.dialogs.openTreeView``\ | True: all sub-trees of the visusalization dialog are opened when opening the dialog; False: only some sub-trees are opened .. _sec-vsettingsopengl: VSettingsOpenGL --------------- OpenGL settings for 2D and 2D rendering. For further details, see the OpenGL functionality. VSettingsOpenGL has the following items: * | **clippingPlaneDistance** [type = float, default = 0.]: | \ ``SC.visualizationSettings.openGL.clippingPlaneDistance``\ | distance of clipping plane on normal vector; see also clippingPlaneNormal * | **clippingPlaneNormal** [type = Float3, default = [0.,0.,0.], size = 3]: | \ ``SC.visualizationSettings.openGL.clippingPlaneNormal``\ | normal vector of clipping plane, e.g. [0,0,1] to set a xy-clipping plane; use [0,0,0] to deactivate clipping plane; Note that clipping is mainly made for triangles in order to visualize hidden objects and currently it only fully clips triangles, but does not exactly cut them; see also clippingPlaneDistance * | **drawFaceNormals** [type = bool, default = False, size = 1]: | \ ``SC.visualizationSettings.openGL.drawFaceNormals``\ | draws triangle normals, e.g. at center of triangles; used for debugging of faces * | **drawNormalsLength** [type = PFloat, default = 0.1, size = 1]: | \ ``SC.visualizationSettings.openGL.drawNormalsLength``\ | length of normals; used for debugging * | **drawVertexNormals** [type = bool, default = False, size = 1]: | \ ``SC.visualizationSettings.openGL.drawVertexNormals``\ | draws vertex normals; used for debugging * | **enableLight0** [type = bool, default = True, size = 1]: | \ ``SC.visualizationSettings.openGL.enableLight0``\ | turn on/off light0 * | **enableLight1** [type = bool, default = True, size = 1]: | \ ``SC.visualizationSettings.openGL.enableLight1``\ | turn on/off light1 * | **enableLighting** [type = bool, default = True, size = 1]: | \ ``SC.visualizationSettings.openGL.enableLighting``\ | generally enable lighting (otherwise, colors of objects are used); OpenGL: glEnable(GL_LIGHTING) * | **faceEdgesColor** [type = Float4, default = [0.2,0.2,0.2,1.], size = 4]: | \ ``SC.visualizationSettings.openGL.faceEdgesColor``\ | global RGBA color for face edges * | **facesTransparent** [type = bool, default = False, size = 1]: | \ ``SC.visualizationSettings.openGL.facesTransparent``\ | True: show faces transparent independent of transparency (A)-value in color of objects; allow to show otherwise hidden node/marker/object numbers * | **initialCenterPoint** [type = Float3, default = [0.,0.,0.], size = 3]: | \ ``SC.visualizationSettings.openGL.initialCenterPoint``\ | centerpoint of scene (3D) at renderer startup; overwritten if autoFitScene = True * | **initialMaxSceneSize** [type = PFloat, default = 1.]: | \ ``SC.visualizationSettings.openGL.initialMaxSceneSize``\ | initial maximum scene size (auto: diagonal of cube with maximum scene coordinates); used for 'zoom all' functionality and for visibility of objects; overwritten if autoFitScene = True * | **initialModelRotation** [type = StdArray33F, default = [Matrix3DF[3,3,1.,0.,0., 0.,1.,0., 0.,0.,1.]], size = 3x3]: | \ ``SC.visualizationSettings.openGL.initialModelRotation``\ | initial model rotation matrix for OpenGl; in python use e.g.: initialModelRotation=[[1,0,0],[0,1,0],[0,0,1]] * | **initialZoom** [type = UFloat, default = 1.]: | \ ``SC.visualizationSettings.openGL.initialZoom``\ | initial zoom of scene; overwritten/ignored if autoFitScene = True * | **light0ambient** [type = float, default = 0.3, size = 1]: | \ ``SC.visualizationSettings.openGL.light0ambient``\ | ambient value of GL_LIGHT0 * | **light0constantAttenuation** [type = float, default = 1.0, size = 1]: | \ ``SC.visualizationSettings.openGL.light0constantAttenuation``\ | constant attenuation coefficient of GL_LIGHT0, this is a constant factor that attenuates the light source; attenuation factor = 1/(kx +kl*d + kq*d*d); (kc,kl,kq)=(1,0,0) means no attenuation; only used for lights, where last component of light position is 1 * | **light0diffuse** [type = float, default = 0.6, size = 1]: | \ ``SC.visualizationSettings.openGL.light0diffuse``\ | diffuse value of GL_LIGHT0 * | **light0linearAttenuation** [type = float, default = 0.0, size = 1]: | \ ``SC.visualizationSettings.openGL.light0linearAttenuation``\ | linear attenuation coefficient of GL_LIGHT0, this is a linear factor for attenuation of the light source with distance * | **light0position** [type = Float4, default = [0.2,0.2,10.,0.], size = 4]: | \ ``SC.visualizationSettings.openGL.light0position``\ | 4f position vector of GL_LIGHT0; 4th value should be 0 for lights like sun, but 1 for directional lights (and for attenuation factor being calculated); light0 is also used for shadows, so you need to adjust this position; see opengl manuals * | **light0quadraticAttenuation** [type = float, default = 0.0, size = 1]: | \ ``SC.visualizationSettings.openGL.light0quadraticAttenuation``\ | quadratic attenuation coefficient of GL_LIGHT0, this is a quadratic factor for attenuation of the light source with distance * | **light0specular** [type = float, default = 0.5, size = 1]: | \ ``SC.visualizationSettings.openGL.light0specular``\ | specular value of GL_LIGHT0 * | **light1ambient** [type = float, default = 0.0 , size = 1]: | \ ``SC.visualizationSettings.openGL.light1ambient``\ | ambient value of GL_LIGHT1 * | **light1constantAttenuation** [type = float, default = 1.0, size = 1]: | \ ``SC.visualizationSettings.openGL.light1constantAttenuation``\ | constant attenuation coefficient of GL_LIGHT1, this is a constant factor that attenuates the light source; attenuation factor = 1/(kx +kl*d + kq*d*d); only used for lights, where last component of light position is 1 * | **light1diffuse** [type = float, default = 0.5, size = 1]: | \ ``SC.visualizationSettings.openGL.light1diffuse``\ | diffuse value of GL_LIGHT1 * | **light1linearAttenuation** [type = float, default = 0.0, size = 1]: | \ ``SC.visualizationSettings.openGL.light1linearAttenuation``\ | linear attenuation coefficient of GL_LIGHT1, this is a linear factor for attenuation of the light source with distance * | **light1position** [type = Float4, default = [1.,1.,-10.,0.], size = 4]: | \ ``SC.visualizationSettings.openGL.light1position``\ | 4f position vector of GL_LIGHT0; 4th value should be 0 for lights like sun, but 1 for directional lights (and for attenuation factor being calculated); see opengl manuals * | **light1quadraticAttenuation** [type = float, default = 0.0, size = 1]: | \ ``SC.visualizationSettings.openGL.light1quadraticAttenuation``\ | quadratic attenuation coefficient of GL_LIGHT1, this is a quadratic factor for attenuation of the light source with distance * | **light1specular** [type = float, default = 0.6, size = 1]: | \ ``SC.visualizationSettings.openGL.light1specular``\ | specular value of GL_LIGHT1 * | **lightModelAmbient** [type = Float4, default = [0.,0.,0.,1.], size = 4]: | \ ``SC.visualizationSettings.openGL.lightModelAmbient``\ | global ambient light; maps to OpenGL glLightModeli(GL_LIGHT_MODEL_AMBIENT,[r,g,b,a]) * | **lightModelLocalViewer** [type = bool, default = False, size = 1]: | \ ``SC.visualizationSettings.openGL.lightModelLocalViewer``\ | select local viewer for light; maps to OpenGL glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER,...) * | **lightModelTwoSide** [type = bool, default = False, size = 1]: | \ ``SC.visualizationSettings.openGL.lightModelTwoSide``\ | enlighten also backside of object; may cause problems on some graphics cards and lead to slower performance; maps to OpenGL glLightModeli(GL_LIGHT_MODEL_TWO_SIDE,...) * | **lineSmooth** [type = bool, default = True, size = 1]: | \ ``SC.visualizationSettings.openGL.lineSmooth``\ | draw lines smooth * | **lineWidth** [type = UFloat, default = 1., size = 1]: | \ ``SC.visualizationSettings.openGL.lineWidth``\ | width of lines used for representation of lines, circles, points, etc. * | **materialAmbientAndDiffuse** [type = Float4, default = [0.6,0.6,0.6,1.], size = 4]: | \ ``SC.visualizationSettings.openGL.materialAmbientAndDiffuse``\ | 4f ambient color of material * | **materialShininess** [type = float, default = 32., size = 1]: | \ ``SC.visualizationSettings.openGL.materialShininess``\ | shininess of material * | **materialSpecular** [type = Float4, default = [0.6,0.6,0.6,1.], size = 4]: | \ ``SC.visualizationSettings.openGL.materialSpecular``\ | 4f specular color of material * | **multiSampling** [type = PInt, default = 1, size = 1]: | \ ``SC.visualizationSettings.openGL.multiSampling``\ | NOTE: this parameter must be set before starting renderer; later changes are not affecting visualization; multi sampling turned off (<=1) or turned on to given values (2, 4, 8 or 16); increases the graphics buffers and might crash due to graphics card memory limitations; only works if supported by hardware; if it does not work, try to change 3D graphics hardware settings! * | **perspective** [type = UFloat, default = 0.]: | \ ``SC.visualizationSettings.openGL.perspective``\ | parameter prescribes amount of perspective (0=no perspective=orthographic projection; positive values increase perspective; feasible values are 0.001 (little perspective) ... 0.5 (large amount of perspective); mouse coordinates will not work with perspective * | **polygonOffset** [type = float, default = 0.01]: | \ ``SC.visualizationSettings.openGL.polygonOffset``\ | general polygon offset for polygons, except for shadows; use this parameter to draw polygons behind lines to reduce artifacts for very large or small models * | **shadeModelSmooth** [type = bool, default = True, size = 1]: | \ ``SC.visualizationSettings.openGL.shadeModelSmooth``\ | True: turn on smoothing for shaders, which uses vertex normals to smooth surfaces * | **shadow** [type = UFloat, default = 0.]: | \ ``SC.visualizationSettings.openGL.shadow``\ | parameter \ :math:`\in [0 ... 1]`\ prescribes amount of shadow for light0 (using light0position, etc.); if this parameter is different from 1, rendering of triangles becomes approx.\ 5 times more expensive, so take care in case of complex scenes; for complex object, such as spheres with fine resolution or for particle systems, the present approach has limitations and leads to artifacts and unrealistic shadows * | **shadowPolygonOffset** [type = PFloat, default = 0.1]: | \ ``SC.visualizationSettings.openGL.shadowPolygonOffset``\ | some special drawing parameter for shadows which should be handled with care; defines some offset needed by openGL to avoid aritfacts for shadows and depends on maxSceneSize; this value may need to be reduced for larger models in order to achieve more accurate shadows, it may be needed to be increased for thin bodies * | **showFaceEdges** [type = bool, default = False, size = 1]: | \ ``SC.visualizationSettings.openGL.showFaceEdges``\ | show edges of faces; using the options showFaces=false and showFaceEdges=true gives are wire frame representation * | **showFaces** [type = bool, default = True, size = 1]: | \ ``SC.visualizationSettings.openGL.showFaces``\ | show faces of triangles, etc.; using the options showFaces=false and showFaceEdges=true gives are wire frame representation * | **showLines** [type = bool, default = True, size = 1]: | \ ``SC.visualizationSettings.openGL.showLines``\ | show lines (different from edges of faces) * | **showMeshEdges** [type = bool, default = True, size = 1]: | \ ``SC.visualizationSettings.openGL.showMeshEdges``\ | show edges of finite elements; independent of showFaceEdges * | **showMeshFaces** [type = bool, default = True, size = 1]: | \ ``SC.visualizationSettings.openGL.showMeshFaces``\ | show faces of finite elements; independent of showFaces * | **textLineSmooth** [type = bool, default = False, size = 1]: | \ ``SC.visualizationSettings.openGL.textLineSmooth``\ | draw lines for representation of text smooth * | **textLineWidth** [type = UFloat, default = 1., size = 1]: | \ ``SC.visualizationSettings.openGL.textLineWidth``\ | width of lines used for representation of text .. _sec-vsettingsexportimages: VSettingsExportImages --------------------- Functionality to export images to files (PNG or TGA format) which can be used to create animations; to activate image recording during the solution process, set SolutionSettings.recordImagesInterval accordingly. VSettingsExportImages has the following items: * | **heightAlignment** [type = PInt, default = 2]: | \ ``SC.visualizationSettings.exportImages.heightAlignment``\ | alignment of exported image height; using a value of 2 helps to reduce problems with video conversion (additional horizontal lines are lost) * | **saveImageAsTextCircles** [type = bool, default = True]: | \ ``SC.visualizationSettings.exportImages.saveImageAsTextCircles``\ | export circles in save image (only in TXT format) * | **saveImageAsTextLines** [type = bool, default = True]: | \ ``SC.visualizationSettings.exportImages.saveImageAsTextLines``\ | export lines in save image (only in TXT format) * | **saveImageAsTextTexts** [type = bool, default = False]: | \ ``SC.visualizationSettings.exportImages.saveImageAsTextTexts``\ | export text in save image (only in TXT format) * | **saveImageAsTextTriangles** [type = bool, default = False]: | \ ``SC.visualizationSettings.exportImages.saveImageAsTextTriangles``\ | export triangles in save image (only in TXT format) * | **saveImageFileCounter** [type = UInt, default = 0]: | \ ``SC.visualizationSettings.exportImages.saveImageFileCounter``\ | current value of the counter which is used to consecutively save frames (images) with consecutive numbers * | **saveImageFileName** [type = FileName, default = 'images/frame']: | \ ``SC.visualizationSettings.exportImages.saveImageFileName``\ | filename (without extension!) and (relative) path for image file(s) with consecutive numbering (e.g., frame0000.png, frame0001.png,...); ; directory will be created if it does not exist * | **saveImageFormat** [type = String, default = 'PNG']: | \ ``SC.visualizationSettings.exportImages.saveImageFormat``\ | format for exporting figures: currently only PNG, TGA and TXT available; while PNG and TGA represent the according image file formats, the TXT format results in a text file containing the 3D graphics data information as lists of lines, triangles, etc; PNG is not available for Ubuntu18.04 (check use TGA has highest compatibility with all platforms * | **saveImageSingleFile** [type = bool, default = False]: | \ ``SC.visualizationSettings.exportImages.saveImageSingleFile``\ | True: only save single files with given filename, not adding numbering; False: add numbering to files, see saveImageFileName * | **saveImageTimeOut** [type = PInt, default = 5000]: | \ ``SC.visualizationSettings.exportImages.saveImageTimeOut``\ | timeout in milliseconds for saving a frame as image to disk; this is the amount of time waited for redrawing; increase for very complex scenes * | **widthAlignment** [type = PInt, default = 4]: | \ ``SC.visualizationSettings.exportImages.widthAlignment``\ | alignment of exported image width; using a value of 4 helps to reduce problems with video conversion (additional vertical lines are lost) .. _sec-vsettingsopenvr: VSettingsOpenVR --------------- Functionality to interact openVR; requires special hardware or software emulator, see steam / openVR descriptions. VSettingsOpenVR has the following items: * | **actionManifestFileName** [type = FileName, default = 'C:/openVRactionsManifest.json']: | \ ``SC.visualizationSettings.interactive.openVR.actionManifestFileName``\ | This string must contain a string representing a valid absolute path to a vr_actions.json manifest, which describes all HMD, tracker, etc. devices as given by openVR * | **enable** [type = bool, default = False]: | \ ``SC.visualizationSettings.interactive.openVR.enable``\ | True: openVR enabled (if compiled with according flag and installed openVR) * | **logLevel** [type = Int, default = 1]: | \ ``SC.visualizationSettings.interactive.openVR.logLevel``\ | integer value setting log level of openVR: -1 (no output), 0 (error), 1 (warning), 2 (info), 3 (debug); increase log level to get more output * | **showCompanionWindow** [type = bool, default = True]: | \ ``SC.visualizationSettings.interactive.openVR.showCompanionWindow``\ | True: openVR will show companion window containing left and right eye view .. _sec-vsettingsinteractive: VSettingsInteractive -------------------- Functionality to interact with render window; will include left and right mouse press actions and others in future. VSettingsInteractive has the following items: * | **openVR** [type = VSettingsOpenVR]: | \ ``SC.visualizationSettings.interactive.openVR``\ | openVR visualization settings * | **highlightColor** [type = Float4, default = [0.8,0.05,0.05,0.75], size = 4]: | \ ``SC.visualizationSettings.interactive.highlightColor``\ | RGBA color for highlighted item; 4th value is alpha-transparency * | **highlightItemIndex** [type = Int, default = -1]: | \ ``SC.visualizationSettings.interactive.highlightItemIndex``\ | index of item that shall be highlighted (e.g., need to find item due to errors); if set -1, no item is highlighted * | **highlightItemType** [type = ItemType, default = ItemType::\_None]: | \ ``SC.visualizationSettings.interactive.highlightItemType``\ | item type (Node, Object, ...) that shall be highlighted (e.g., need to find item due to errors) * | **highlightMbsNumber** [type = UInt, default = 0]: | \ ``SC.visualizationSettings.interactive.highlightMbsNumber``\ | index of main system (mbs) for which the item shall be highlighted; number is related to the ID in SystemContainer (first mbs = 0, second = 1, ...) * | **highlightOtherColor** [type = Float4, default = [0.5,0.5,0.5,0.4], size = 4]: | \ ``SC.visualizationSettings.interactive.highlightOtherColor``\ | RGBA color for other items (which are not highlighted); 4th value is alpha-transparency * | **joystickScaleRotation** [type = float, default = 200.]: | \ ``SC.visualizationSettings.interactive.joystickScaleRotation``\ | rotation scaling factor for joystick input * | **joystickScaleTranslation** [type = float, default = 6.]: | \ ``SC.visualizationSettings.interactive.joystickScaleTranslation``\ | translation scaling factor for joystick input * | **keypressRotationStep** [type = float, default = 5.]: | \ ``SC.visualizationSettings.interactive.keypressRotationStep``\ | rotation increment per keypress in degree (full rotation = 360 degree) * | **keypressTranslationStep** [type = float, default = 0.1]: | \ ``SC.visualizationSettings.interactive.keypressTranslationStep``\ | translation increment per keypress relative to window size * | **lockModelView** [type = bool, default = False]: | \ ``SC.visualizationSettings.interactive.lockModelView``\ | True: all movements (with mouse/keys), rotations, zoom are disabled; initial values are considered ==> initial zoom, rotation and center point need to be adjusted, approx. 0.4*maxSceneSize is a good value * | **mouseMoveRotationFactor** [type = float, default = 1.]: | \ ``SC.visualizationSettings.interactive.mouseMoveRotationFactor``\ | rotation increment per 1 pixel mouse movement in degree * | **pauseWithSpacebar** [type = bool, default = True]: | \ ``SC.visualizationSettings.interactive.pauseWithSpacebar``\ | True: during simulation, space bar can be pressed to pause simulation * | **selectionHighlights** [type = bool, default = True]: | \ ``SC.visualizationSettings.interactive.selectionHighlights``\ | True: mouse click highlights item (default: red) * | **selectionLeftMouse** [type = bool, default = True]: | \ ``SC.visualizationSettings.interactive.selectionLeftMouse``\ | True: left mouse click on items and show basic information * | **selectionRightMouse** [type = bool, default = True]: | \ ``SC.visualizationSettings.interactive.selectionRightMouse``\ | True: right mouse click on items and show dictionary (read only!) * | **selectionRightMouseGraphicsData** [type = bool, default = False]: | \ ``SC.visualizationSettings.interactive.selectionRightMouseGraphicsData``\ | True: right mouse click on items also shows GraphicsData information for inspectation (may sometimes be very large and may not fit into dialog for large graphics objects!) * | **trackMarker** [type = Int, default = -1]: | \ ``SC.visualizationSettings.interactive.trackMarker``\ | if valid marker index is provided and marker provides position (and orientation), the centerpoint of the scene follows the marker (and orientation); depends on trackMarkerPosition and trackMarkerOrientation; by default, only position is tracked * | **trackMarkerMbsNumber** [type = Index, default = 0]: | \ ``SC.visualizationSettings.interactive.trackMarkerMbsNumber``\ | number of main system which is used to track marker; if only 1 mbs is in the SystemContainer, use 0; if there are several mbs, it needs to specify the number * | **trackMarkerOrientation** [type = Float3, default = [0.,0.,0.], size = 3]: | \ ``SC.visualizationSettings.interactive.trackMarkerOrientation``\ | choose which orientation axes (x,y,z) are tracked; currently can only be all zero or all one * | **trackMarkerPosition** [type = Float3, default = [1.,1.,1.], size = 3]: | \ ``SC.visualizationSettings.interactive.trackMarkerPosition``\ | choose which coordinates or marker are tracked (x,y,z) * | **useJoystickInput** [type = bool, default = True]: | \ ``SC.visualizationSettings.interactive.useJoystickInput``\ | True: read joystick input (use 6-axis joystick with lowest ID found when starting renderer window) and interpret as (x,y,z) position and (rotx, roty, rotz) rotation: as available from 3Dconnexion space mouse and maybe others as well; set to False, if external joystick makes problems ... * | **zoomStepFactor** [type = float, default = 1.15]: | \ ``SC.visualizationSettings.interactive.zoomStepFactor``\ | change of zoom per keypress (keypad +/-) or mouse wheel increment .. _sec-visualizationsettings: VisualizationSettings --------------------- Settings for visualization. VisualizationSettings has the following items: * | **bodies** [type = VSettingsBodies]: | \ ``.visualizationSettings.bodies``\ | body visualization settings * | **connectors** [type = VSettingsConnectors]: | \ ``.visualizationSettings.connectors``\ | connector visualization settings * | **contact** [type = VSettingsContact]: | \ ``.visualizationSettings.contact``\ | contact visualization settings * | **contour** [type = VSettingsContour]: | \ ``.visualizationSettings.contour``\ | contour plot visualization settings * | **dialogs** [type = VSettingsDialogs]: | \ ``.visualizationSettings.dialogs``\ | dialogs settings * | **exportImages** [type = VSettingsExportImages]: | \ ``.visualizationSettings.exportImages``\ | settings for exporting (saving) images to files in order to create animations * | **general** [type = VSettingsGeneral]: | \ ``.visualizationSettings.general``\ | general visualization settings * | **interactive** [type = VSettingsInteractive]: | \ ``.visualizationSettings.interactive``\ | Settings for interaction with renderer * | **loads** [type = VSettingsLoads]: | \ ``.visualizationSettings.loads``\ | load visualization settings * | **markers** [type = VSettingsMarkers]: | \ ``.visualizationSettings.markers``\ | marker visualization settings * | **nodes** [type = VSettingsNodes]: | \ ``.visualizationSettings.nodes``\ | node visualization settings * | **openGL** [type = VSettingsOpenGL]: | \ ``.visualizationSettings.openGL``\ | OpenGL rendering settings * | **sensors** [type = VSettingsSensors]: | \ ``.visualizationSettings.sensors``\ | sensor visualization settings * | **window** [type = VSettingsWindow]: | \ ``.visualizationSettings.window``\ | visualization window and interaction settings