diff --git a/CHANGELOG.md b/CHANGELOG.md index 637d4c1..9d049e7 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -9,10 +9,35 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 ### Added +* Added envelope creation from parametric vaults, middle meshes, and bound meshes, with dedicated Rhino scene layers and drawing controls. +* Added TNO analysis for minimum and maximum thrust, minimum thickness, best fit, maximum applied load, and support displacement objectives. +* Added objective-specific optimisation constraints and variables, with SLSQP and IPOPT solver selection. +* Added assessment load workflows for envelope self-weight, external point loads, fill weight, and clearing all loads. +* Added 3D thrust-network drawing, editing, and explicit form/thrust vertex and edge selection on the `FormDiagram` scene object. +* Added envelope bounds and crack visualisation, force and reaction labels, load vectors, support displacement vectors, and configurable thrust faces, edges, vertices, and pipes. +* Added outward, inward, downward, and manual support displacement presets. +* Added direct template-pattern creation through `compas_tna`, including pattern-specific discretisation options. +* Added toolbar commands and icons for envelope creation, load assignment, TNO analysis, block export, thrust inspection, and session export. + ### Changed +* Changed the 3D thrust network to use the existing `FormDiagram` as the single source of equilibrium geometry and force data, while retaining compatibility with existing RhinoVAULT save files. +* Changed TNA vertical equilibrium, thrust editing, diagram export, and DEM block export to operate directly on the `FormDiagram`. +* Changed envelope-based analysis loads to remain fixed during equilibrium updates and added an explicit RV/TNO sign-convention bridge. +* Changed successful TNO analyses to update an existing `ForceDiagram` from the optimised form forces. +* Changed maximum-load analysis to collect initial loads on selected thrust-network vertices and display the optimised load vectors. +* Changed support-displacement analysis to collect and display displacement vectors on selected 3D supports. +* Changed thrust-load drawing to display the sum of `pz` and the optimised `pzext` contribution. +* Changed pointed-vault input validation so the rise is at least half of the larger span, and changed dome envelopes to use a fixed dense discretisation. +* Changed the minimum `compas_tno` requirement to `0.4.0`. +* Changed the Rhino 8 toolbar order and icons to expose the TNA, TNO, modification, and session workflows. + ### Removed +* Removed the separate `ThrustDiagram` data structure and `RhinoThrustObject` scene object. +* Removed the obsolete `RV_form_solve` command. +* Removed the local pattern-template implementations superseded by the `compas_tna` factories. + ## [0.9.5] 2025-07-04 diff --git a/commands/RV_dem_blocks.py b/commands/RV_dem_blocks.py index 08c3337..32906dd 100644 --- a/commands/RV_dem_blocks.py +++ b/commands/RV_dem_blocks.py @@ -15,14 +15,14 @@ def RunCommand(): session = RVSession() - thrust = session.find_thrustdiagram() - if not thrust: - print("There is no ThrustDiagram in the scene.") + form = session.find_formdiagram() + if not form: + print("There is no FormDiagram in the scene.") return option = rs.GetString(message="DEM Blocks From", strings=["Dual", "MeshPattern"]) - mesh: Mesh = thrust.diagram.copy() + mesh: Mesh = form.diagram.copy() for face in list(mesh.faces_where(_is_loaded=False)): mesh.delete_face(face) diff --git a/commands/RV_envelope.py b/commands/RV_envelope.py new file mode 100644 index 0000000..9d8e4f5 --- /dev/null +++ b/commands/RV_envelope.py @@ -0,0 +1,262 @@ +#! python3 +# venv: brg-csd +# r: compas_rv>=0.9.5 + +import rhinoscriptsyntax as rs # type: ignore + +import compas_rhino +import compas_rhino.conversions +import compas_rhino.objects +from compas.datastructures import Mesh +from compas_rv.session import RVSession +from compas_tna.envelope import BarrelVaultEnvelope +from compas_tna.envelope import CrossVaultEnvelope +from compas_tna.envelope import DomeEnvelope +from compas_tna.envelope import MeshEnvelope +from compas_tna.envelope import PavillionVaultEnvelope +from compas_tna.envelope import PointedVaultEnvelope + + +ENVELOPE_LAYER = "RhinoVAULT::Envelope" + + +def get_location(): + option = rs.GetString("Envelope location", "Origin", ["Origin", "Coordinates", "Point"]) + if not option: + return + if option == "Origin": + return 0.0, 0.0 + if option == "Coordinates": + x = rs.GetReal("X", 0.0) + if x is None: + return + y = rs.GetReal("Y", 0.0) + if y is None: + return + return x, y + point = rs.GetPoint("Point") + if not point: + return + return point[0], point[1] + + +def get_size(default_x=10.0, default_y=10.0): + x_size = rs.GetReal("X size", default_x, minimum=0.0) + if x_size is None: + return + y_size = rs.GetReal("Y size", default_y, minimum=0.0) + if y_size is None: + return + return x_size, y_size + + +def get_thickness(default=0.5): + return rs.GetReal("Thickness", default, minimum=0.0) + + +def get_crossvault(): + point = get_location() + if point is None: + return + size = get_size() + if size is None: + return + thickness = get_thickness() + if thickness is None: + return + return CrossVaultEnvelope(x_span=(point[0], point[0] + size[0]), y_span=(point[1], point[1] + size[1]), thickness=thickness) + + +def get_barrelvault(): + point = get_location() + if point is None: + return + span = rs.GetReal("Span", 10.0, minimum=0.0) + if span is None: + return + depth = rs.GetReal("Depth", 10.0, minimum=0.0) + if depth is None: + return + rise = rs.GetReal("Rise", 3.0, minimum=0.0) + if rise is None: + return + thickness = get_thickness() + if thickness is None: + return + return BarrelVaultEnvelope(rise=rise, span=span, x0=point[0], y_span=(point[1], point[1] + depth), thickness=thickness) + + +def get_pointedvault(): + point = get_location() + if point is None: + return + size = get_size() + if size is None: + return + minimum_rise = 0.5 * max(size) + message = "Rise must be greater than or equal to {0:.3f}".format(minimum_rise) + rise = rs.GetReal(message, minimum_rise, minimum=minimum_rise) + if rise is None: + return + thickness = get_thickness() + if thickness is None: + return + return PointedVaultEnvelope(x_span=(point[0], point[0] + size[0]), y_span=(point[1], point[1] + size[1]), thickness=thickness, hc=rise) + + +def get_pavilionvault(): + point = get_location() + if point is None: + return + size = get_size() + if size is None: + return + thickness = get_thickness() + if thickness is None: + return + angle = rs.GetReal("Springing angle", 45.0, minimum=0.0, maximum=90.0) + if angle is None: + return + return PavillionVaultEnvelope(x_span=(point[0], point[0] + size[0]), y_span=(point[1], point[1] + size[1]), thickness=thickness, spr_angle=angle) + + +def get_dome(): + center = get_location() + if center is None: + return + radius = rs.GetReal("Radius", 5.0, minimum=0.0) + if radius is None: + return + thickness = get_thickness() + if thickness is None: + return + r_oculus = rs.GetReal("Oculus radius", 0.5, minimum=0.0) + if r_oculus is None or r_oculus >= radius: + return + return DomeEnvelope(center=center, radius=radius, thickness=thickness, n_hoops=40, n_parallels=40, r_oculus=r_oculus) + + +def get_from_middle(): + guid = compas_rhino.objects.select_mesh("Select middle mesh") + if not guid: + return + obj = compas_rhino.objects.find_object(guid) + mesh = compas_rhino.conversions.mesh_to_compas(obj.Geometry, cls=Mesh) + thickness = get_thickness() + if thickness is None: + return + rs.HideObject(guid) + return MeshEnvelope.from_middle_mesh(mesh, thickness) + + +def get_from_bounds(): + guids = [] + + guid = compas_rhino.objects.select_mesh("Select intrados") + rs.UnselectAllObjects() + if not guid: + return + guids.append(guid) + obj = compas_rhino.objects.find_object(guid) + intrados = compas_rhino.conversions.mesh_to_compas(obj.Geometry, cls=Mesh) + + guid = compas_rhino.objects.select_mesh("Select extrados") + rs.UnselectAllObjects() + if not guid: + return + guids.append(guid) + obj = compas_rhino.objects.find_object(guid) + extrados = compas_rhino.conversions.mesh_to_compas(obj.Geometry, cls=Mesh) + + guid = compas_rhino.objects.select_mesh("Select middle (optional)") + rs.UnselectAllObjects() + if guid: + guids.append(guid) + obj = compas_rhino.objects.find_object(guid) + middle = compas_rhino.conversions.mesh_to_compas(obj.Geometry, cls=Mesh) + else: + middle = None + + guid = compas_rhino.objects.select_mesh("Select fill mesh (optional)") + rs.UnselectAllObjects() + if guid: + guids.append(guid) + obj = compas_rhino.objects.find_object(guid) + fill = compas_rhino.conversions.mesh_to_compas(obj.Geometry, cls=Mesh) + else: + fill = None + + rs.HideObjects(guids) + + envelope = MeshEnvelope.from_meshes(intrados, extrados, middle) + if fill: + envelope.fill = fill + return envelope + + +LIBRARY = { + "BarrelVault": get_barrelvault, + "CrossVault": get_crossvault, + "PointedVault": get_pointedvault, + "PavilionVault": get_pavilionvault, + "Dome": get_dome, +} + + +def RunCommand(): + session = RVSession() + + option = rs.GetString("Envelope from", "FromLibrary", ["FromLibrary", "FromMiddle", "FromBounds"]) + if not option: + return + + if option == "FromLibrary": + pattern = rs.GetString("Envelope pattern", "BarrelVault", list(LIBRARY.keys())) + if not pattern: + return + envelope = LIBRARY[pattern]() + elif option == "FromMiddle": + envelope = get_from_middle() + elif option == "FromBounds": + envelope = get_from_bounds() + else: + return + + if not envelope: + return session.warn("Error creating Envelope. Try again.") + + rho = rs.GetInteger("Density masonry (rho)", int(envelope.rho), minimum=0, maximum=200) + if rho is None: + return + envelope.rho = rho + + if envelope.fill: + rho_fill = rs.GetInteger("Density masonry fill (rho_fill)", int(envelope.rho_fill), minimum=0, maximum=200) + if rho_fill is None: + return + envelope.rho_fill = rho_fill + + session.clear_envelope(redraw=False) + session["envelope"] = envelope + + settings = session.settings.envelope + if envelope.intrados: + session.scene.add(envelope.intrados, disjoint=True, show=settings.show_intrados, name="Intrados", layer=ENVELOPE_LAYER) + if envelope.middle: + session.scene.add(envelope.middle, disjoint=True, show=settings.show_middle, name="Middle", layer=ENVELOPE_LAYER) + if envelope.extrados: + session.scene.add(envelope.extrados, disjoint=True, show=settings.show_extrados, name="Extrados", layer=ENVELOPE_LAYER) + if envelope.fill: + session.scene.add(envelope.fill, disjoint=True, show=settings.show_fill, name="Fill", layer=ENVELOPE_LAYER) + + session.scene.redraw() + rs.Redraw() + + print("Envelope successfully created.") + + if session.settings.autosave: + session.record(name="TNO Envelope") + + +if __name__ == "__main__": + RunCommand() diff --git a/commands/RV_form.py b/commands/RV_form.py index 643a268..e78752a 100644 --- a/commands/RV_form.py +++ b/commands/RV_form.py @@ -5,7 +5,6 @@ import rhinoscriptsyntax as rs # type: ignore from compas_rv.datastructures import FormDiagram -from compas_rv.datastructures import ThrustDiagram from compas_rv.session import RVSession @@ -40,11 +39,8 @@ def RunCommand(): formdiagram.vertices_attribute(name="z", value=0) formdiagram.flip_cycles_if_normal_down() - thrustdiagram: ThrustDiagram = formdiagram.copy(cls=ThrustDiagram) - thrustdiagram.name = "ThrustDiagram" - - # set an initial value for zmax - session.settings.tna.vertical_zmax = thrustdiagram.compute_zmax() + # set an initial value for zmax using the form diagram + session.settings.tna.vertical_zmax = formdiagram.compute_zmax() # ============================================================================= # Update scene @@ -55,7 +51,6 @@ def RunCommand(): pattern.show = False session.scene.add(formdiagram, name=formdiagram.name, layer="RhinoVAULT::FormDiagram") # type: ignore - session.scene.add(thrustdiagram, name=thrustdiagram.name, show=False, layer="RhinoVAULT::ThrustDiagram") # type: ignore session.scene.redraw() rs.Redraw() diff --git a/commands/RV_form_modify.py b/commands/RV_form_modify.py index 3e30dae..4f16cd5 100644 --- a/commands/RV_form_modify.py +++ b/commands/RV_form_modify.py @@ -17,7 +17,6 @@ def RunCommand(): return force = session.find_forcediagram(warn=False) - thrust = session.find_thrustdiagram(warn=False) RECREATE_FORCE = False @@ -42,14 +41,9 @@ def RunCommand(): if not action: return - if thrust: - thrust.show_vertices = False # type: ignore - thrust.redraw_vertices() - if action == "Add": - form.show_vertices = list(form.diagram.vertices_where(is_support=False, is_vertex_internal=True)) - form.redraw_vertices() - selected = form.select_vertices() + vertices = list(form.diagram.vertices_where(is_support=False, is_vertex_internal=True)) + selected = form.select_form_vertices(vertices=vertices) if selected: form.diagram.vertices_attribute(name="is_support", value=True, keys=selected) @@ -60,9 +54,7 @@ def RunCommand(): if not selectable: return session.warn("There are no internal supports.") - form.show_vertices = selectable - form.redraw_vertices() - selected = form.select_vertices() + selected = form.select_form_vertices(vertices=selectable) if selected: form.diagram.vertices_attribute(name="is_support", value=False, keys=selected) @@ -72,14 +64,9 @@ def RunCommand(): # they can't be removed or added # movement on the formdiagram is only permitted in XY - elif option == "BoundarySupports": - if thrust: - thrust.show_vertices = False # type: ignore - thrust.redraw_vertices() - - form.show_vertices = list(form.diagram.vertices_where(is_support=True, is_vertex_internal=False)) - form.redraw_vertices() - selected = form.select_vertices() + elif option == "Supports": + vertices = list(form.diagram.vertices_where(is_support=True, is_vertex_internal=False)) + selected = form.select_form_vertices(vertices=vertices) if selected: directions = ["X", "Y", "XY"] @@ -93,9 +80,10 @@ def RunCommand(): # positive values are in the negative z-direction elif option == "Loads": - form.show_vertices = list(form.diagram.vertices_where(is_support=False)) - form.redraw_vertices() - selected = form.select_vertices() + vertices = list(form.diagram.vertices_where(is_support=False)) + selected = form.select_form_vertices(vertices=vertices) + + print("Selected vertices: {}".format(selected)) if selected: form.update_vertex_attributes(selected, names=["pz", "t"]) @@ -112,16 +100,12 @@ def RunCommand(): return if action == "DeleteFaces": - form.show_faces = list(form.diagram.faces_where(_is_loaded=True)) - form.redraw_faces() - selected = form.select_faces_manual() + faces = list(form.diagram.faces_where(_is_loaded=True)) + selected = form.select_form_faces(faces=faces) if selected: for face in selected: if form.diagram.has_face(face): form.diagram.delete_face(face) - if thrust: - if thrust.diagram.has_face(face): - thrust.diagram.delete_face(face) if force: RECREATE_FORCE = True @@ -133,9 +117,8 @@ def RunCommand(): # min/max dual length elif option == "EdgeConstraints": - form.show_edges = list(form.diagram.edges_where(_is_edge=True)) - form.redraw_edges() - selected = form.select_edges() + edges = list(form.diagram.edges_where(_is_edge=True)) + selected = form.select_form_edges(edges=edges) if selected: form.update_edge_attributes(selected, names=["lmin", "lmax", "hmin", "hmax"]) @@ -152,9 +135,6 @@ def RunCommand(): if RECREATE_FORCE: form.diagram.update_boundaries() - if thrust: - thrust.diagram.update_boundaries() - forcediagram: ForceDiagram = ForceDiagram.from_formdiagram(form.diagram) forcediagram.update_position() diff --git a/commands/RV_form_solve.py b/commands/RV_form_solve.py deleted file mode 100644 index f77ac18..0000000 --- a/commands/RV_form_solve.py +++ /dev/null @@ -1,48 +0,0 @@ -#! python3 -# venv: brg-csd -# r: compas_rv>=0.9.5 - -import rhinoscriptsyntax as rs # type: ignore - -from compas_rv.session import RVSession - - -def RunCommand(): - session = RVSession() - - form = session.find_formdiagram() - if not form: - return - - # ============================================================================= - # Pattern relax - # ============================================================================= - - rs.UnselectAllObjects() - - form.diagram.solve_fd() - - # ============================================================================= - # Update scene - # ============================================================================= - - rs.UnselectAllObjects() - - form.show_vertices = True - form.show_free = False - form.show_fixed = True - form.show_supports = True - form.show_edges = True - - form.redraw() - - if session.settings.autosave: - session.record(name="Relax the FormDiagram") - - -# ============================================================================= -# Run as main -# ============================================================================= - -if __name__ == "__main__": - RunCommand() diff --git a/commands/RV_loads.py b/commands/RV_loads.py new file mode 100644 index 0000000..6818592 --- /dev/null +++ b/commands/RV_loads.py @@ -0,0 +1,109 @@ +#! python3 +# venv: brg-csd +# r: compas_rv>=0.9.5 + +import rhinoscriptsyntax as rs # type: ignore + +from compas_rv.session import RVSession + + +def invert_vertical_loads(formdiagram): + for vertex in formdiagram.vertices(): + pz = formdiagram.vertex_attribute(vertex, "pz") + formdiagram.vertex_attribute(vertex, "pz", -pz if pz is not None else 0.0) + + +def clear_optimised_loads(formdiagram): + for vertex in formdiagram.vertices(): + formdiagram.unset_vertex_attribute(vertex, "pzext") + + +def select_loaded_vertices(formobject): + candidates = list(formobject.diagram.vertices_where(is_support=False)) + return formobject.select_thrust_vertices( + vertices=candidates, + message="Select vertices for external loads", + use_edges=False, + ) + + +def RunCommand(): + session = RVSession() + + formobject = session.find_formdiagram() + if not formobject: + return + + option = rs.GetString("Load source", "FromEnvelope", ["FromEnvelope", "External", "FromFill", "ClearAll"]) + if not option: + return + + formdiagram = formobject.diagram + envelope = None + + if option in ("FromEnvelope", "FromFill"): + envelope = session.find_envelope() + if not envelope: + return + + if option == "FromEnvelope": + normalize = rs.GetString("Normalize loads to envelope self-weight", "Yes", ["Yes", "No"]) + if not normalize: + return + + envelope.apply_selfweight_to_formdiagram(formdiagram, normalize=normalize == "Yes") + invert_vertical_loads(formdiagram) + clear_optimised_loads(formdiagram) + print("Self-weight from the envelope applied to the FormDiagram.") + + elif option == "External": + vertices = select_loaded_vertices(formobject) + if not vertices: + return session.warn("Select at least one non-support vertex.") + + load = rs.GetReal("External vertical load (positive downward)", 1.0, minimum=0.0) + if load is None: + return + + for vertex in vertices: + pz = formdiagram.vertex_attribute(vertex, "pz") or 0.0 + formdiagram.vertex_attribute(vertex, "pz", pz + load) + print("Load at vertex {0} updated from {1:.2f} to {2:.2f}".format(vertex, pz, pz + load)) + clear_optimised_loads(formdiagram) + + elif option == "FromFill": + if not envelope.fill: + return session.warn("There is no Fill mesh. Re-create the envelope with a fill mesh.") + + invert_vertical_loads(formdiagram) + try: + envelope.apply_fill_weight_to_formdiagram(formdiagram) + finally: + invert_vertical_loads(formdiagram) + clear_optimised_loads(formdiagram) + print("Fill weight applied to the FormDiagram.") + + elif option == "ClearAll": + formdiagram.vertices_attribute(name="pz", value=0.0) + clear_optimised_loads(formdiagram) + formdiagram.attributes["loads_from_envelope"] = False + print("All vertical loads cleared from the FormDiagram.") + + else: + raise NotImplementedError + + if option != "ClearAll": + formdiagram.attributes["loads_from_envelope"] = True + formobject.show_thrust = True + session.settings.drawing.show_loads = True + + rs.UnselectAllObjects() + formobject.redraw() + rs.Redraw() + + if session.settings.autosave: + session.record(name="Update Loads") + + +if __name__ == "__main__": + RunCommand() diff --git a/commands/RV_pattern.py b/commands/RV_pattern.py index ca17462..8be3777 100644 --- a/commands/RV_pattern.py +++ b/commands/RV_pattern.py @@ -10,12 +10,150 @@ from compas_rv.commands import make_pattern_from_rhinosurface from compas_rv.commands import make_pattern_from_skeleton from compas_rv.commands import make_pattern_from_triangulation -from compas_rv.patterns.circular import create_circular_radial_pattern -from compas_rv.patterns.circular import create_circular_radial_spaced_pattern -from compas_rv.patterns.circular import create_circular_spiral_pattern -from compas_rv.patterns.rectangular import create_cross_pattern -from compas_rv.patterns.rectangular import create_fan_pattern +from compas_rv.datastructures import Pattern from compas_rv.session import RVSession +from compas_tna.diagrams.diagram_circular import create_circular_radial_mesh +from compas_tna.diagrams.diagram_circular import create_circular_radial_spaced_mesh +from compas_tna.diagrams.diagram_circular import create_circular_spiral_mesh +from compas_tna.diagrams.diagram_rectangular import create_cross_mesh +from compas_tna.diagrams.diagram_rectangular import create_fan_mesh +from compas_tna.diagrams.diagram_rectangular import create_ortho_mesh +from compas_tna.diagrams.diagram_rectangular import create_parametric_fan_mesh + + +def get_location(): + option = rs.GetString("Pattern location", "Origin", ["Origin", "Coordinates", "Point"]) + if not option: + return + if option == "Origin": + return 0.0, 0.0 + if option == "Coordinates": + x = rs.GetReal("X", 0.0) + if x is None: + return + y = rs.GetReal("Y", 0.0) + if y is None: + return + return x, y + point = rs.GetPoint("Point") + if not point: + return + return point[0], point[1] + + +def get_size(): + x_size = rs.GetReal("X size", 10.0, minimum=0.0) + if x_size is None: + return + y_size = rs.GetReal("Y size", 10.0, minimum=0.0) + if y_size is None: + return + return x_size, y_size + + +def get_circular_pattern(factory): + center = get_location() + if center is None: + return + radius = rs.GetReal("Radius", 5.0, minimum=0.0) + if radius is None: + return + n_hoops = rs.GetInteger("Hoops", 12, minimum=4) + if n_hoops is None: + return + n_parallels = rs.GetInteger("Radials", 24, minimum=12) + if n_parallels is None: + return + r_oculus = rs.GetReal("Oculus radius", 0.0, minimum=0.0) + if r_oculus is None: + return + if r_oculus >= radius: + rs.MessageBox("The oculus radius should be smaller than the pattern radius.", title="Warning") + return + return factory(center=center, radius=radius, n_hoops=n_hoops, n_parallels=n_parallels, r_oculus=r_oculus).copy(cls=Pattern) + + +def get_cross_pattern(): + point = get_location() + if point is None: + return + size = get_size() + if size is None: + return + resolution = rs.GetInteger("Resolution", 10, minimum=1) + if resolution is None: + return + return create_cross_mesh( + x_span=(point[0], point[0] + size[0]), + y_span=(point[1], point[1] + size[1]), + n=resolution, + ).copy(cls=Pattern) + + +def get_fan_pattern(): + point = get_location() + if point is None: + return + size = get_size() + if size is None: + return + n_fans = rs.GetInteger("Fans", 10, minimum=2) + if n_fans is None: + return + n_hoops = rs.GetInteger("Hoops", 10, minimum=2) + if n_hoops is None: + return + if n_fans % 2 or n_hoops % 2: + rs.MessageBox("The fan and hoop discretisation should be even.", title="Warning") + return + return create_fan_mesh( + x_span=(point[0], point[0] + size[0]), + y_span=(point[1], point[1] + size[1]), + n_fans=n_fans, + n_hoops=n_hoops, + ).copy(cls=Pattern) + + +def get_ortho_pattern(): + point = get_location() + if point is None: + return + size = get_size() + if size is None: + return + nx = rs.GetInteger("X faces", 10, minimum=2) + if nx is None: + return + ny = rs.GetInteger("Y faces", nx, minimum=2) + if ny is None: + return + return create_ortho_mesh( + x_span=(point[0], point[0] + size[0]), + y_span=(point[1], point[1] + size[1]), + nx=nx, + ny=ny, + ).copy(cls=Pattern) + + +def get_parametric_pattern(): + point = get_location() + if point is None: + return + size = get_size() + if size is None: + return + resolution = rs.GetInteger("Resolution", 10, minimum=2) + if resolution is None: + return + inclination = rs.GetReal("Lambda inclination", 0.5, minimum=0.0, maximum=1.0) + if inclination is None: + return + return create_parametric_fan_mesh( + x_span=(point[0], point[0] + size[0]), + y_span=(point[1], point[1] + size[1]), + n=resolution, + lambd=inclination, + ).copy(cls=Pattern) def RunCommand(): @@ -33,7 +171,7 @@ def RunCommand(): if not session.confirm("This will remove all current RhinoVAULT data and objects. Do you wish to proceed?"): return - session.scene.clear() + session.clear() # ============================================================================= # Make a Force "Pattern" @@ -83,30 +221,41 @@ def RunCommand(): "Spiral", "Cross", "Fan", + "Ortho", + "Parametric", ], ) if option2 == "Radial": - pattern = create_circular_radial_pattern() + pattern = get_circular_pattern(create_circular_radial_mesh) elif option2 == "RadialSpaced": - pattern = create_circular_radial_spaced_pattern() + pattern = get_circular_pattern(create_circular_radial_spaced_mesh) elif option2 == "Spiral": - pattern = create_circular_spiral_pattern() + pattern = get_circular_pattern(create_circular_spiral_mesh) elif option2 == "Cross": - pattern = create_cross_pattern() + pattern = get_cross_pattern() elif option2 == "Fan": - pattern = create_fan_pattern() + pattern = get_fan_pattern() + + elif option2 == "Ortho": + pattern = get_ortho_pattern() + + elif option2 == "Parametric": + pattern = get_parametric_pattern() else: - raise NotImplementedError + return else: return + if not pattern: + return + # ============================================================================= # Update scene # ============================================================================= diff --git a/commands/RV_scene_clear.py b/commands/RV_scene_clear.py index e2b2298..6919fe9 100644 --- a/commands/RV_scene_clear.py +++ b/commands/RV_scene_clear.py @@ -9,7 +9,7 @@ def RunCommand(): session = RVSession() if session.confirm("Note that this will remove all RhinoVAULT data and objects. Do you wish to proceed?"): - session.scene.clear() + session.clear() if session.settings.autosave: session.record(name="Clear") diff --git a/commands/RV_session_export.py b/commands/RV_session_export.py index bfabbcd..5fe4e43 100644 --- a/commands/RV_session_export.py +++ b/commands/RV_session_export.py @@ -48,6 +48,7 @@ def RunCommand(): return mesh: Mesh = form.diagram.copy() + mesh.vertices_attribute(name="z", value=0) for face in list(mesh.faces_where(_is_loaded=False)): mesh.delete_face(face) @@ -74,11 +75,11 @@ def RunCommand(): compas.json_dump(mesh, filepath) elif option == "ThrustDiagram": - thrust = session.find_thrustdiagram() - if not thrust: + form = session.find_formdiagram() + if not form: return - mesh: Mesh = thrust.diagram.copy() + mesh: Mesh = form.diagram.copy() for face in list(mesh.faces_where(_is_loaded=False)): mesh.delete_face(face) diff --git a/commands/RV_session_open.py b/commands/RV_session_open.py index 4440658..b71ed83 100644 --- a/commands/RV_session_open.py +++ b/commands/RV_session_open.py @@ -16,13 +16,12 @@ def RunCommand(): if not filepath: return - session.scene.clear() + session.clear() session.load(filepath) pattern = session.find_pattern(warn=False) form = session.find_formdiagram(warn=False) force = session.find_forcediagram(warn=False) - thrust = session.find_thrustdiagram(warn=False) if pattern: pattern.layer = "RhinoVAULT::Pattern" @@ -33,9 +32,6 @@ def RunCommand(): if force: force.layer = "RhinoVAULT::ForceDiagram" - if thrust: - thrust.layer = "RhinoVAULT::ThrustDiagram" - if form and force: form.diagram.dual = force.diagram force.diagram.primal = form.diagram diff --git a/commands/RV_session_redo.py b/commands/RV_session_redo.py index 4321f61..33edb31 100644 --- a/commands/RV_session_redo.py +++ b/commands/RV_session_redo.py @@ -16,7 +16,6 @@ def RunCommand(): pattern = session.find_pattern(warn=False) form = session.find_formdiagram(warn=False) force = session.find_forcediagram(warn=False) - thrust = session.find_thrustdiagram(warn=False) if pattern: pattern.layer = "RhinoVAULT::Pattern" @@ -27,9 +26,6 @@ def RunCommand(): if force: force.layer = "RhinoVAULT::ForceDiagram" - if thrust: - thrust.layer = "RhinoVAULT::ThrustDiagram" - if form and force: form.diagram.dual = force.diagram force.diagram.primal = form.diagram diff --git a/commands/RV_session_undo.py b/commands/RV_session_undo.py index 9ec6fcf..00c1ecf 100644 --- a/commands/RV_session_undo.py +++ b/commands/RV_session_undo.py @@ -16,7 +16,6 @@ def RunCommand(): pattern = session.find_pattern(warn=False) form = session.find_formdiagram(warn=False) force = session.find_forcediagram(warn=False) - thrust = session.find_thrustdiagram(warn=False) if pattern: pattern.layer = "RhinoVAULT::Pattern" @@ -27,9 +26,6 @@ def RunCommand(): if force: force.layer = "RhinoVAULT::ForceDiagram" - if thrust: - thrust.layer = "RhinoVAULT::ThrustDiagram" - if form and force: form.diagram.dual = force.diagram force.diagram.primal = form.diagram diff --git a/commands/RV_settings.py b/commands/RV_settings.py index 91edc62..1417daa 100644 --- a/commands/RV_settings.py +++ b/commands/RV_settings.py @@ -33,7 +33,7 @@ def update_settings(model, title): def RunCommand(): session = RVSession() - options = ["RhinoVault", "ThrustNetworkAnalysis", "Drawing"] + options = ["RhinoVault", "ThrustNetworkAnalysis", "ThrustNetworkOptimisation", "Envelope", "Drawing"] while True: option = rs.GetString(message="Choose a settings section, or escape/cancel to exit.", strings=options) @@ -46,6 +46,12 @@ def RunCommand(): elif option == "ThrustNetworkAnalysis": update_settings(session.settings.tna, title=option) + elif option == "ThrustNetworkOptimisation": + update_settings(session.settings.tno, title=option) + + elif option == "Envelope": + update_settings(session.settings.envelope, title=option) + elif option == "Drawing": update_settings(session.settings.drawing, title=option) diff --git a/commands/RV_thrust_info.py b/commands/RV_thrust_info.py index 26cca86..ba12f5b 100644 --- a/commands/RV_thrust_info.py +++ b/commands/RV_thrust_info.py @@ -9,20 +9,20 @@ def RunCommand(): session = RVSession() - thrust = session.find_thrustdiagram() - if not thrust: - print("There is no ThrustDiagram in the scene.") + form = session.find_formdiagram() + if not form: + print("There is no FormDiagram in the scene.") return - form = MeshInfoForm( - thrust.diagram, + form_info = MeshInfoForm( + form.diagram, vertex_attr_names=["x", "y", "z", "px", "py", "pz", "is_support", "_rx", "_ry", "_rz"], edge_attr_names=["q"], face_attr_names=["_is_loaded"], - title="Thrust Diagram Info", + title="Form Diagram Info (3D Thrust Surface)", ) - form.show() + form_info.show() # ============================================================================= diff --git a/commands/RV_thrust_modify.py b/commands/RV_thrust_modify.py index e47543a..6855f2f 100644 --- a/commands/RV_thrust_modify.py +++ b/commands/RV_thrust_modify.py @@ -22,11 +22,6 @@ def RunCommand(): print("There is no ForceDiagram in the scene.") return - thrust = session.find_thrustdiagram() - if not thrust: - print("There is no ThrustDiagram in the scene.") - return - # ============================================================================= # Modify pattern vertices # ============================================================================= @@ -42,60 +37,43 @@ def RunCommand(): return if option == "VertexAttributes": - thrust.show_vertices = list(thrust.diagram.vertices()) - thrust.redraw_vertices() - selected = thrust.select_vertices() + vertices = list(form.diagram.vertices()) + selected = form.select_thrust_vertices(vertices=vertices) if selected: - thrust.update_vertex_attributes(selected) + form.update_vertex_attributes(selected) elif option == "EdgeAttributes": - thrust.show_edges = list(thrust.diagram.edges_where(_is_edge=True)) - thrust.redraw_edges() - selected = thrust.select_edges() + edges = list(form.diagram.edges_where(_is_edge=True)) + selected = form.select_thrust_edges(edges=edges) if selected: - thrust.update_edge_attributes(selected) + form.update_edge_attributes(selected) elif option == "MoveSupports": - form.show_vertices = False - form.redraw_vertices() - thrust.show_vertices = list(thrust.diagram.vertices_where(is_support=True)) - thrust.redraw_vertices() - selected = thrust.select_vertices() + vertices = list(form.diagram.vertices_where(is_support=True)) + selected = form.select_thrust_vertices(vertices=vertices) if selected: - thrust.move_vertices_direction(selected, direction="Z") + form.move_vertices_direction(selected, direction="Z") elif option == "ScaleForceDensities": - thrust.show_edges = list(thrust.diagram.edges_where(_is_edge=True)) - thrust.redraw_edges() - selected = thrust.select_edges() + edges = list(form.diagram.edges_where(_is_edge=True)) + selected = form.select_thrust_edges(edges=edges) if selected: selected = list(set(selected)) factor = rs.GetReal("Scale factor", number=1.0, minimum=0) if not factor: return for edge in selected: - q = factor * thrust.diagram.edge_attribute(edge, "q") + q = factor * form.diagram.edge_attribute(edge, "q") form.diagram.edge_attribute(edge, "q", q) form.diagram.solve_fd() update_force_from_form(force.diagram, form.diagram) - _, scale = vertical_from_zmax(form.diagram, zmax, kmax=kmax) + density = 0.0 if form.diagram.attributes.get("loads_from_envelope") else 1.0 + _, scale = vertical_from_zmax(form.diagram, zmax, kmax=kmax, density=density) force.diagram.attributes["scale"] = scale force.diagram.update_position() - for vertex in form.diagram.vertices(): - form_attr = form.diagram.vertex_attributes(vertex) - thrust_attr = thrust.diagram.vertex_attributes(vertex) - thrust_attr.update(form_attr) # type: ignore - - for edge in form.diagram.edges(): - form_attr = form.diagram.edge_attributes(edge) - thrust_attr = thrust.diagram.edge_attributes(edge) - thrust_attr.update(form_attr) # type: ignore - - form.diagram.vertices_attribute(name="z", value=0) - else: raise NotImplementedError @@ -120,11 +98,17 @@ def RunCommand(): force.show_supports = True force.show_edges = True - thrust.show_vertices = True # type: ignore - thrust.show_free = False - thrust.show_fixed = True - thrust.show_supports = True - thrust.show_edges = False + form.show_thrust = True + session.settings.drawing.show_thrust_vertices = True + session.settings.drawing.show_thrust_free = False + session.settings.drawing.show_thrust_fixed = True + session.settings.drawing.show_thrust_supports = True + session.settings.drawing.show_thrust_edges = False + session.settings.drawing.show_thrust_faces = True + session.settings.drawing.show_reactions = True + session.settings.drawing.show_pipes = False + session.settings.drawing.show_force_labels = False + session.settings.drawing.show_reaction_labels = False session.scene.redraw() diff --git a/commands/RV_tna_vertical.py b/commands/RV_tna_vertical.py index 9e12cee..c5987b4 100644 --- a/commands/RV_tna_vertical.py +++ b/commands/RV_tna_vertical.py @@ -22,13 +22,8 @@ def RunCommand(): print("There is no ForceDiagram in the scene.") return - thrust = session.find_thrustdiagram() - if not thrust: - print("There is no ThrustDiagram in the scene.") - return - # ============================================================================= - # Compute horizontal + # Compute vertical # ============================================================================= kmax = session.settings.tna.vertical_kmax @@ -40,34 +35,14 @@ def RunCommand(): session.settings.tna.vertical_zmax = zmax - # copy the vertical coordinates of the thrust diagram onto the form diagram - for vertex in thrust.diagram.vertices_where(is_support=True): - z = thrust.diagram.vertex_attribute(vertex, "z") - form.diagram.vertex_attribute(vertex, "z", z) - - _, scale = vertical_from_zmax(form.diagram, zmax, kmax=kmax) - - if not _: # this makes no sense - print("Vertical equilibrium failed!") - return + # Compute vertical equilibrium directly on the form diagram + density = 0.0 if form.diagram.attributes.get("loads_from_envelope") else 1.0 + _, scale = vertical_from_zmax(form.diagram, zmax, kmax=kmax, density=density) force.diagram.attributes["scale"] = scale - for vertex in form.diagram.vertices(): - form_attr = form.diagram.vertex_attributes(vertex) - thrust_attr = thrust.diagram.vertex_attributes(vertex) - thrust_attr.update(form_attr) # type: ignore - - for edge in form.diagram.edges(): - form_attr = form.diagram.edge_attributes(edge) - thrust_attr = thrust.diagram.edge_attributes(edge) - thrust_attr.update(form_attr) # type: ignore - - # flatten the formdiagram again - form.diagram.vertices_attribute(name="z", value=0) - - # show the thrust diagram - thrust.show = True + # Enable 3D mode for the form diagram to show the thrust surface + form.show_thrust = True # ============================================================================= # Update scene @@ -75,10 +50,11 @@ def RunCommand(): rs.UnselectAllObjects() - thrust.redraw() + # Redraw the form diagram to show the updated 3D geometry + form.redraw() print("Vertical equilibrium found!") - print("ThrustDiagram object successfully created with target height of {}.".format(zmax)) + print("FormDiagram object updated with target height of {}.".format(zmax)) if session.settings.autosave: session.record(name="TNA Vertical") diff --git a/commands/RV_tno_analysis.py b/commands/RV_tno_analysis.py new file mode 100644 index 0000000..f030bd5 --- /dev/null +++ b/commands/RV_tno_analysis.py @@ -0,0 +1,323 @@ +#! python3 +# venv: brg-csd +# r: compas_rv>=0.9.5 + +import numpy as np +import rhinoscriptsyntax as rs # type: ignore +from compas_tno.analysis import Analysis + +from compas_rui.forms import NamedValuesForm +from compas_rv.conventions import invert_formdiagram_signs +from compas_rv.session import RVSession +from compas_rv.solvers import update_force_from_form +from compas_tna.envelope import MeshEnvelope + +OBJECTIVES = [ + "MinimumThrust", + "MaximumThrust", + "MinimumThickness", + "Bestfit", + "MaximumLoad", + "SupportDisplacement", +] + + +def get_optimisation_options(objective): + constraint_options = [ + ("Funicular", True), + ("Envelope", objective != "Bestfit"), + ("ReactionDirections", False), + ] + constraint_options = rs.CheckListBox(constraint_options, "Validate the constraints of the optimisation.", "TNO Constraints") + if constraint_options is None: + return + + variable_options = [] + if objective == "MinimumThickness": + variable_options.append(("Thickness", True)) + variable_options.extend( + [ + ("ForceDensities", True), + ("SupportHeights", True), + ] + ) + if objective == "MaximumLoad": + variable_options.append(("LoadMultiplier", True)) + variable_options = rs.CheckListBox(variable_options, "Validate the variables of the optimisation.", "TNO Variables") + if variable_options is None: + return + + constraint_names = { + "Funicular": "funicular", + "Envelope": "envelope", + "ReactionDirections": "reac_bounds", + } + variable_names = { + "Thickness": "t", + "ForceDensities": "q", + "SupportHeights": "zb", + "LoadMultiplier": "lambdv", + } + + constraints = [constraint_names[name] for name, checked in constraint_options if checked] + variables = [variable_names[name] for name, checked in variable_options if checked] + + return constraints, variables + + +def get_load_direction(formobject): + n = formobject.diagram.number_of_vertices() + load_direction = np.zeros((n, 1)) + index_vertex = formobject.diagram.index_vertex() + candidates = list(formobject.diagram.vertices_where(is_support=False)) + assigned = False + + while True: + vertices = formobject.select_thrust_vertices( + vertices=candidates, + message="Select vertices for maximum applied load", + use_edges=False, + ) + if not vertices: + break + + force = rs.GetReal("Initial vertical load p0 (negative downward)", -10.0) + if force is None: + return + + for vertex in vertices: + load_direction[index_vertex[vertex]] = force + assigned = True + + rs.UnselectAllObjects() + more = rs.GetString("Apply initial loads on additional vertices", "No", ["No", "Yes"]) + if more != "Yes": + break + + if not assigned: + formobject.session.warn("Select at least one vertex and assign an initial load.") + return + + return load_direction + + +def get_displacement_vector(defaults): + form = NamedValuesForm(["Ux", "Uy", "Uz"], defaults, title="Support Displacement", width=350, height=180) + if not form.show(): + return + + try: + return [float(form.attributes[name]) for name in ("Ux", "Uy", "Uz")] + except (TypeError, ValueError): + rs.MessageBox("Ux, Uy and Uz must be numbers.", title="Invalid Support Displacement") + + +DISPLACEMENT_DIRECTIONS = ["Outward", "Inward", "Downward", "Manual"] + + +def get_displacement_values(formobject, vertices, manual_defaults, magnitude_default): + """Prompt for the displacement to apply to a batch of selected supports. + + Returns + ------- + tuple[dict[int, list[float]], list[float], float] or None + A mapping from vertex to ``[ux, uy, uz]``, together with the updated + manual-entry and magnitude defaults to reuse for the next prompt, or + None if the user cancelled. + """ + direction = rs.GetString("Support displacement direction", "Manual", DISPLACEMENT_DIRECTIONS) + if not direction: + return None + + if direction == "Manual": + values = get_displacement_vector(manual_defaults) + if values is None: + return None + return {vertex: values for vertex in vertices}, values, magnitude_default + + magnitude = rs.GetReal("{0} displacement magnitude".format(direction), magnitude_default, minimum=0.0) + if magnitude is None: + return None + + if direction == "Downward": + vectors = {vertex: [0.0, 0.0, -magnitude] for vertex in vertices} + else: + outward = formobject.diagram.find_outward_displacement(vertices) + sign = -1.0 if direction == "Inward" else 1.0 + vectors = {vertex: [sign * magnitude * ux, sign * magnitude * uy, 0.0] for vertex, (ux, uy, _) in outward.items()} + + return vectors, manual_defaults, magnitude + + +def get_support_displacement(formobject): + supports = list(formobject.diagram.supports()) + displacement = np.zeros((len(supports), 3)) + assignments = {} + manual_defaults = [-1.0, -1.0, 0.0] + magnitude_default = 1.0 + + while True: + vertices = formobject.select_thrust_vertices( + vertices=supports, + message="Select supports for displacement", + use_edges=False, + ) + if not vertices: + break + + result = get_displacement_values(formobject, vertices, manual_defaults, magnitude_default) + if result is None: + return + vectors, manual_defaults, magnitude_default = result + + for vertex in vertices: + values = vectors[vertex] + displacement[supports.index(vertex)] = np.array(values) + assignments[vertex] = values + print("Applied displacement {0} to support {1}".format(values, vertex)) + + rs.UnselectAllObjects() + more = rs.GetString("Define additional displacement vectors", "No", ["No", "Yes"]) + if more != "Yes": + break + + if not assignments: + formobject.session.warn("Select at least one support and assign a displacement vector.") + return + + for support in supports: + formobject.diagram.vertex_attributes(support, ["ux", "uy", "uz"], assignments.get(support, [0.0, 0.0, 0.0])) + + return displacement + + +def create_analysis(objective, formobject, envelope): + settings = formobject.session.settings.tno + formdiagram = formobject.diagram + kwargs = { + "printout": settings.printout, + "max_iter": settings.max_iter, + "starting_point": settings.starting_point, + "solver": settings.solver, + } + + if objective == "MinimumThrust": + analysis = Analysis.create_minthrust_analysis(formdiagram, envelope, **kwargs) + elif objective == "MaximumThrust": + analysis = Analysis.create_maxthrust_analysis(formdiagram, envelope, **kwargs) + elif objective == "MinimumThickness": + if isinstance(envelope, MeshEnvelope): + formobject.session.warn("Minimum thickness analysis is only available for parametric envelopes.") + return + analysis = Analysis.create_minthk_analysis(formdiagram, envelope, **kwargs) + elif objective == "Bestfit": + analysis = Analysis.create_bestfit_analysis(formdiagram, envelope, **kwargs) + elif objective == "MaximumLoad": + load_direction = get_load_direction(formobject) + if load_direction is None: + return + max_lambd = rs.GetReal("Maximum load multiplier", 9999.0, minimum=0.0) + if max_lambd is None: + return + analysis = Analysis.create_max_load_analysis(formdiagram, envelope, load_direction=load_direction, max_lambd=max_lambd, **kwargs) + elif objective == "SupportDisplacement": + support_displacement = get_support_displacement(formobject) + if support_displacement is None: + return + analysis = Analysis.create_compl_energy_analysis(formdiagram, envelope, support_displacement=support_displacement, **kwargs) + else: + raise NotImplementedError + + return analysis + + +def report_result(objective, analysis): + result = analysis.result + fopt = result.fopt + + if objective in ("MinimumThrust", "MaximumThrust"): + print("Optimal horizontal thrust calculated: {0:.3f}".format(fopt)) + elif objective == "MinimumThickness": + print("Minimum thickness calculated: {0:.3f}".format(fopt)) + if result.exitflag == 0: + analysis.envelope.thickness = fopt + analysis.envelope.update_envelope() + elif objective == "MaximumLoad": + print("Maximum load multiplier calculated: {0:.3f}".format(fopt)) + elif objective == "SupportDisplacement": + print("Complementary energy to assigned displacements: {0:.3f}".format(fopt)) + elif objective == "Bestfit": + print("Optimal squared vertical distance to middle surface: {0:.3f}".format(fopt)) + + +def RunCommand(): + session = RVSession() + + formobject = session.find_formdiagram() + if not formobject: + return + + envelope = session.find_envelope() + if not envelope: + return + + objective = rs.GetString("TNO objective", "MinimumThrust", OBJECTIVES) + if not objective: + return + + solver = rs.GetString("Solver", session.settings.tno.solver, ["SLSQP", "IPOPT"]) + if not solver: + return + session.settings.tno.solver = solver + + options = get_optimisation_options(objective) + if not options: + return + constraints, variables = options + + analysis = create_analysis(objective, formobject, envelope) + if not analysis: + return + + analysis.optimiser.set_constraints(constraints) + analysis.optimiser.set_variables(variables) + + invert_formdiagram_signs(formobject.diagram) + try: + # Apply the envelope bounds and use the loads prepared on the FormDiagram. + envelope.apply_bounds_to_formdiagram(formobject.diagram) + + if abs(sum(formobject.diagram.vertices_attribute("pz"))) < 0.001: + return session.warn("There are no loads applied to the FormDiagram. Use RV_loads before running TNO analysis.") + + analysis.set_up_optimiser() + analysis.run() + session["analysis"] = analysis + finally: + invert_formdiagram_signs(formobject.diagram) + + forceobject = None + if analysis.result.success: + if objective == "MaximumLoad": + session.settings.drawing.show_loads = True + forceobject = session.find_forcediagram(warn=False) + if forceobject: + update_force_from_form(forceobject.diagram, formobject.diagram) + forceobject.diagram.update_position() + forceobject.diagram.update_angle_deviations() + + report_result(objective, analysis) + + formobject.show_thrust = True + + rs.UnselectAllObjects() + formobject.redraw() + if forceobject: + forceobject.redraw() + + if session.settings.autosave: + session.record(name="TNO Analysis") + + +if __name__ == "__main__": + RunCommand() diff --git a/compas-RV.rhproj b/compas-RV.rhproj index a92018d..6aa84c6 100644 --- a/compas-RV.rhproj +++ b/compas-RV.rhproj @@ -8,7 +8,7 @@ "id": "a6dc4669-0e8e-40ea-8d71-b9b0f4764ec1", "identity": { "name": "COMPAS-RhinoVAULT", - "version": "0.6.44", + "version": "0.6.47-beta", "publisher": { "email": "tom.v.mele@gmail.com", "name": "Tom Van Mele", @@ -76,7 +76,7 @@ "id": "*.*.python", "version": "3.*.*" }, - "title": "RV", + "title": "RV_init", "uri": "commands/RV.py", "image": { "light": { @@ -340,6 +340,90 @@ } } }, + { + "id": "54be0499-c175-4f78-a748-4c1322f2edc9", + "language": { + "id": "*.*.python", + "version": "3.*.*" + }, + "title": "RV_envelope", + "uri": "commands/RV_envelope.py", + "image": { + "light": { + "type": "svg", + "data": "<svg id="Layer_1" xmlns="http://www.w3.org/2000/svg" version="1.1" viewBox="0 0 32 32">
  <!-- Generator: Adobe Illustrator 29.8.10, SVG Export Plug-In . SVG Version: 2.1.1 Build 2)  -->
  <defs>
    <style>
      .st0 {
        stroke-miterlimit: 3.6;
        stroke-width: .1px;
      }

      .st0, .st1 {
        stroke: #a6a6ae;
        stroke-linecap: round;
      }

      .st0, .st1, .st2, .st3 {
        fill: none;
      }

      .st1 {
        stroke-miterlimit: 3.13;
        stroke-width: .09px;
      }

      .st4 {
        fill: #6f6f78;
      }

      .st2 {
        stroke: #111114;
      }

      .st2, .st3 {
        stroke-linejoin: round;
        stroke-width: .4px;
      }

      .st5 {
        opacity: .11;
      }

      .st3 {
        stroke: #4a4a52;
      }
    </style>
  </defs>
  <g class="st5">
    <polygon class="st4" points="28.52 14.71 27.39 11.5 26.11 8.46 24.66 6.37 23.08 6.19 22.67 6.91 22.42 7.1 22.21 6.82 19.14 4.14 15.9 3.02 12.67 4.14 9.59 6.82 9.39 7.1 9.12 6.9 8.72 6.19 7.14 6.37 5.69 8.46 4.41 11.5 3.29 14.71 6.14 12.24 8.85 10.23 10.48 9.5 11.92 14.15 13.46 20.85 14.95 28.25 16.85 28.25 18.34 20.85 19.88 14.15 21.33 9.5 22.95 10.23 25.66 12.24 28.52 14.71"/>
  </g>
  <g class="st5">
    <polygon class="st4" points="28.11 14.98 27.02 11.87 25.78 8.94 24.38 6.9 22.85 6.74 22.45 7.44 22.21 7.62 22.01 7.34 19.03 4.75 15.9 3.67 12.78 4.75 9.8 7.34 9.6 7.61 9.35 7.42 8.96 6.74 7.43 6.9 6.03 8.94 4.79 11.87 3.7 14.98 6.46 12.59 9.09 10.64 10.66 9.94 12.05 14.44 13.54 20.92 14.99 28.08 16.82 28.08 18.27 20.92 19.76 14.44 21.15 9.94 22.72 10.64 25.34 12.59 28.11 14.98"/>
  </g>
  <g class="st5">
    <polygon class="st4" points="27.7 15.24 26.64 12.24 25.45 9.41 24.09 7.44 22.62 7.28 22.23 7.96 22 8.13 21.8 7.87 18.93 5.36 15.91 4.32 12.88 5.36 10.01 7.87 9.82 8.13 9.57 7.94 9.2 7.28 7.72 7.44 6.37 9.41 5.17 12.24 4.12 15.24 6.79 12.93 9.32 11.06 10.84 10.37 12.19 14.72 13.63 20.99 15.02 27.9 16.79 27.9 18.19 20.99 19.63 14.72 20.98 10.37 22.49 11.06 25.03 12.93 27.7 15.24"/>
  </g>
  <g class="st5">
    <polygon class="st4" points="27.29 15.51 26.27 12.62 25.12 9.88 23.81 7.98 22.39 7.83 22.01 8.48 21.79 8.65 21.6 8.39 18.83 5.98 15.91 4.97 12.99 5.98 10.22 8.39 10.04 8.64 9.8 8.46 9.43 7.83 8.01 7.98 6.7 9.88 5.55 12.62 4.53 15.51 7.11 13.28 9.56 11.47 11.02 10.81 12.32 15 13.71 21.05 15.06 27.72 16.76 27.72 18.11 21.05 19.5 15 20.8 10.81 22.27 11.47 24.71 13.28 27.29 15.51"/>
  </g>
  <g class="st5">
    <polygon class="st4" points="26.88 15.78 25.9 12.99 24.79 10.35 23.53 8.52 22.16 8.37 21.8 9 21.58 9.17 21.4 8.91 18.73 6.59 15.91 5.62 13.1 6.59 10.43 8.91 10.25 9.16 10.02 8.99 9.67 8.37 8.3 8.52 7.04 10.35 5.93 12.99 4.95 15.78 7.43 13.63 9.79 11.88 11.2 11.25 12.45 15.29 13.79 21.12 15.09 27.55 16.74 27.55 18.04 21.12 19.38 15.29 20.63 11.25 22.04 11.88 24.4 13.63 26.88 15.78"/>
  </g>
  <g>
    <line class="st0" x1="3.94" y1="14.22" x2="4.64" y2="13.57"/>
    <line class="st0" x1="4.05" y1="14.15" x2="4.31" y2="13.87"/>
    <line class="st0" x1="3.94" y1="14.22" x2="4.05" y2="14.15"/>
    <line class="st0" x1="9.67" y1="6.98" x2="9.69" y2="6.7"/>
    <line class="st0" x1="4.16" y1="14.08" x2="4.32" y2="13.87"/>
    <line class="st0" x1="4.05" y1="14.15" x2="4.16" y2="14.08"/>
    <line class="st0" x1="9.57" y1="6.86" x2="9.69" y2="6.7"/>
    <line class="st0" x1="4.27" y1="14.01" x2="4.44" y2="13.76"/>
    <line class="st0" x1="4.16" y1="14.08" x2="4.27" y2="14.01"/>
    <line class="st0" x1="27.36" y1="13.57" x2="27.61" y2="13.82"/>
    <line class="st0" x1="27.95" y1="14.15" x2="28.06" y2="14.22"/>
    <line class="st0" x1="27.69" y1="13.87" x2="27.95" y2="14.15"/>
    <line class="st0" x1="27.84" y1="14.08" x2="27.95" y2="14.15"/>
    <line class="st0" x1="27.68" y1="13.87" x2="27.84" y2="14.08"/>
    <line class="st0" x1="27.73" y1="14.01" x2="27.84" y2="14.08"/>
    <line class="st0" x1="27.56" y1="13.76" x2="27.73" y2="14.01"/>
    <line class="st0" x1="22.31" y1="6.7" x2="22.43" y2="6.86"/>
    <line class="st0" x1="22.31" y1="6.7" x2="22.33" y2="6.98"/>
    <line class="st0" x1="4.51" y1="11.38" x2="5.02" y2="11.73"/>
    <line class="st0" x1="3.39" y1="14.59" x2="3.49" y2="14.52"/>
    <line class="st0" x1="5.79" y1="8.35" x2="6.67" y2="9.14"/>
    <line class="st0" x1="6.67" y1="9.14" x2="7.51" y2="9.77"/>
    <line class="st0" x1="5.02" y1="11.73" x2="5.48" y2="12.01"/>
    <line class="st0" x1="3.49" y1="14.52" x2="3.61" y2="14.45"/>
    <line class="st0" x1="7.24" y1="6.25" x2="8.41" y2="7.43"/>
    <line class="st0" x1="9.63" y1="8.35" x2="10.15" y2="8.39"/>
    <line class="st0" x1="8.41" y1="7.43" x2="9.63" y2="8.35"/>
    <line class="st0" x1="9.63" y1="8.35" x2="10.24" y2="8.56"/>
    <line class="st0" x1="8.31" y1="10.13" x2="10.48" y2="9.05"/>
    <line class="st0" x1="7.51" y1="9.77" x2="8.31" y2="10.13"/>
    <line class="st0" x1="8.31" y1="10.13" x2="8.95" y2="10.11"/>
    <line class="st0" x1="5.48" y1="12.01" x2="5.9" y2="12.16"/>
    <line class="st0" x1="3.72" y1="14.38" x2="5.9" y2="12.16"/>
    <line class="st0" x1="3.61" y1="14.45" x2="3.72" y2="14.38"/>
    <line class="st0" x1="5.9" y1="12.16" x2="8.31" y2="10.13"/>
    <line class="st0" x1="5.9" y1="12.16" x2="6.24" y2="12.12"/>
    <line class="st0" x1="3.72" y1="14.38" x2="3.83" y2="14.29"/>
    <line class="st0" x1="15.05" y1="28.13" x2="15.29" y2="28.13"/>
    <line class="st0" x1="15.29" y1="28.13" x2="15.52" y2="28.13"/>
    <line class="st0" x1="15.52" y1="28.13" x2="15.77" y2="28.13"/>
    <line class="st0" x1="15.77" y1="28.13" x2="16" y2="28.13"/>
    <line class="st0" x1="16" y1="28.13" x2="16.23" y2="28.13"/>
    <line class="st0" x1="16.23" y1="28.13" x2="16.48" y2="28.13"/>
    <line class="st0" x1="16.48" y1="28.13" x2="16.71" y2="28.13"/>
    <line class="st0" x1="16.71" y1="28.13" x2="16.95" y2="28.13"/>
    <line class="st0" x1="21.85" y1="8.39" x2="22.37" y2="8.35"/>
    <line class="st0" x1="21.76" y1="8.56" x2="22.37" y2="8.35"/>
    <line class="st0" x1="23.69" y1="10.13" x2="24.49" y2="9.77"/>
    <line class="st0" x1="21.52" y1="9.05" x2="23.69" y2="10.13"/>
    <line class="st0" x1="23.05" y1="10.11" x2="23.69" y2="10.13"/>
    <line class="st0" x1="22.37" y1="8.35" x2="23.59" y2="7.43"/>
    <line class="st0" x1="23.59" y1="7.43" x2="24.76" y2="6.25"/>
    <line class="st0" x1="25.33" y1="9.14" x2="26.21" y2="8.35"/>
    <line class="st0" x1="24.49" y1="9.77" x2="25.33" y2="9.14"/>
    <line class="st0" x1="26.52" y1="12.01" x2="26.98" y2="11.73"/>
    <line class="st0" x1="26.98" y1="11.73" x2="27.49" y2="11.38"/>
    <line class="st0" x1="23.69" y1="10.13" x2="26.1" y2="12.16"/>
    <line class="st0" x1="25.76" y1="12.12" x2="26.1" y2="12.16"/>
    <line class="st0" x1="26.1" y1="12.16" x2="26.52" y2="12.01"/>
    <line class="st0" x1="26.1" y1="12.16" x2="28.28" y2="14.38"/>
    <path class="st0" d="M12.09,8.66l.22-.32c.12-.18.24-.58.29-.89s.08-.87.11-1.25.05-1.02.05-1.43l.02-.75"/>
    <path class="st0" d="M19.23,4.02l.02.75c0,.41.04,1.05.05,1.43s.06.94.11,1.25.16.71.29.89l.22.32"/>
    <path class="st0" d="M10.85,8l.9-.56c.5-.31,1.65-.74,2.57-.96s2.42-.23,3.34,0,2.07.66,2.57.96l.9.56"/>
    <path class="st0" d="M3.39,14.59l1.5-1.29c.75-.65,1.97-1.63,2.72-2.18s1.72-1.17,2.17-1.37l.81-.37"/>
    <path class="st0" d="M21.42,9.38l.81.37c.45.21,1.42.82,2.17,1.37s1.97,1.53,2.72,2.18l1.5,1.29"/>
    <path class="st0" d="M9.69,6.7l1.71-1.5c.75-.65,2.08-1.43,2.97-1.74s2.34-.31,3.23,0,2.23,1.09,2.97,1.74l1.71,1.5"/>
    <path class="st0" d="M3.39,14.59l.56-1.6c.31-.88.86-2.29,1.21-3.13.35-.84.96-1.99,1.37-2.57s1.08-1.09,1.51-1.14,1.15.54,1.59,1.32,1.05,2.17,1.33,3.13l.53,1.71c.29.95.71,2.51.94,3.48l.73,3.18c.23.96.57,2.55.76,3.52l1.14,5.63"/>
    <path class="st0" d="M16.95,28.13l1.14-5.63c.2-.97.54-2.56.76-3.52l.73-3.18c.23-.96.64-2.53.94-3.48l.53-1.71c.29-.95.89-2.35,1.33-3.13s1.16-1.36,1.59-1.32,1.11.56,1.51,1.14,1.01,1.73,1.37,2.57.89,2.24,1.21,3.13l.56,1.6"/>
    <line class="st0" x1="15.05" y1="28.13" x2="16.95" y2="28.13"/>
  </g>
  <g>
    <line class="st1" x1="5.52" y1="15.35" x2="6.12" y2="14.79"/>
    <line class="st1" x1="5.62" y1="15.29" x2="5.84" y2="15.05"/>
    <line class="st1" x1="5.52" y1="15.35" x2="5.62" y2="15.29"/>
    <line class="st1" x1="10.5" y1="9.06" x2="10.52" y2="8.81"/>
    <line class="st1" x1="5.71" y1="15.23" x2="5.85" y2="15.05"/>
    <line class="st1" x1="5.62" y1="15.29" x2="5.71" y2="15.23"/>
    <line class="st1" x1="10.41" y1="8.95" x2="10.52" y2="8.81"/>
    <line class="st1" x1="5.8" y1="15.16" x2="5.95" y2="14.95"/>
    <line class="st1" x1="5.71" y1="15.23" x2="5.8" y2="15.16"/>
    <line class="st1" x1="25.88" y1="14.79" x2="26.09" y2="15"/>
    <line class="st1" x1="26.38" y1="15.29" x2="26.48" y2="15.35"/>
    <line class="st1" x1="26.16" y1="15.05" x2="26.38" y2="15.29"/>
    <line class="st1" x1="26.29" y1="15.23" x2="26.38" y2="15.29"/>
    <line class="st1" x1="26.15" y1="15.05" x2="26.29" y2="15.23"/>
    <line class="st1" x1="26.2" y1="15.16" x2="26.29" y2="15.23"/>
    <line class="st1" x1="26.05" y1="14.95" x2="26.2" y2="15.16"/>
    <line class="st1" x1="21.48" y1="8.81" x2="21.59" y2="8.95"/>
    <line class="st1" x1="21.48" y1="8.81" x2="21.5" y2="9.06"/>
    <line class="st1" x1="6.01" y1="12.89" x2="6.45" y2="13.18"/>
    <line class="st1" x1="5.04" y1="15.67" x2="5.13" y2="15.61"/>
    <line class="st1" x1="7.13" y1="10.25" x2="7.89" y2="10.94"/>
    <line class="st1" x1="7.89" y1="10.94" x2="8.62" y2="11.48"/>
    <line class="st1" x1="6.45" y1="13.18" x2="6.86" y2="13.43"/>
    <line class="st1" x1="5.13" y1="15.61" x2="5.23" y2="15.55"/>
    <line class="st1" x1="8.39" y1="8.42" x2="9.41" y2="9.45"/>
    <line class="st1" x1="10.46" y1="10.25" x2="10.92" y2="10.29"/>
    <line class="st1" x1="9.41" y1="9.45" x2="10.46" y2="10.25"/>
    <line class="st1" x1="10.46" y1="10.25" x2="11" y2="10.43"/>
    <line class="st1" x1="9.32" y1="11.8" x2="11.2" y2="10.86"/>
    <line class="st1" x1="8.62" y1="11.48" x2="9.32" y2="11.8"/>
    <line class="st1" x1="9.32" y1="11.8" x2="9.88" y2="11.78"/>
    <line class="st1" x1="6.86" y1="13.43" x2="7.22" y2="13.56"/>
    <line class="st1" x1="5.33" y1="15.49" x2="7.22" y2="13.56"/>
    <line class="st1" x1="5.23" y1="15.55" x2="5.33" y2="15.49"/>
    <line class="st1" x1="7.22" y1="13.56" x2="9.32" y2="11.8"/>
    <line class="st1" x1="7.22" y1="13.56" x2="7.52" y2="13.53"/>
    <line class="st1" x1="5.33" y1="15.49" x2="5.42" y2="15.41"/>
    <line class="st1" x1="15.18" y1="27.44" x2="15.38" y2="27.44"/>
    <line class="st1" x1="15.38" y1="27.44" x2="15.58" y2="27.44"/>
    <line class="st1" x1="15.58" y1="27.44" x2="15.8" y2="27.44"/>
    <line class="st1" x1="15.8" y1="27.44" x2="16" y2="27.44"/>
    <line class="st1" x1="16" y1="27.44" x2="16.2" y2="27.44"/>
    <line class="st1" x1="16.2" y1="27.44" x2="16.42" y2="27.44"/>
    <line class="st1" x1="16.42" y1="27.44" x2="16.62" y2="27.44"/>
    <line class="st1" x1="16.62" y1="27.44" x2="16.82" y2="27.44"/>
    <line class="st1" x1="21.08" y1="10.29" x2="21.54" y2="10.25"/>
    <line class="st1" x1="21" y1="10.43" x2="21.54" y2="10.25"/>
    <line class="st1" x1="22.68" y1="11.8" x2="23.38" y2="11.48"/>
    <line class="st1" x1="20.8" y1="10.86" x2="22.68" y2="11.8"/>
    <line class="st1" x1="22.12" y1="11.78" x2="22.68" y2="11.8"/>
    <line class="st1" x1="21.54" y1="10.25" x2="22.59" y2="9.45"/>
    <line class="st1" x1="22.59" y1="9.45" x2="23.61" y2="8.42"/>
    <line class="st1" x1="24.11" y1="10.94" x2="24.87" y2="10.25"/>
    <line class="st1" x1="23.38" y1="11.48" x2="24.11" y2="10.94"/>
    <line class="st1" x1="25.14" y1="13.43" x2="25.55" y2="13.18"/>
    <line class="st1" x1="25.55" y1="13.18" x2="25.99" y2="12.89"/>
    <line class="st1" x1="22.68" y1="11.8" x2="24.78" y2="13.56"/>
    <line class="st1" x1="24.48" y1="13.53" x2="24.78" y2="13.56"/>
    <line class="st1" x1="24.78" y1="13.56" x2="25.14" y2="13.43"/>
    <line class="st1" x1="24.78" y1="13.56" x2="26.67" y2="15.49"/>
    <path class="st1" d="M12.6,10.52l.19-.28c.1-.16.21-.5.25-.78s.07-.76.09-1.09.04-.88.05-1.25l.02-.65"/>
    <path class="st1" d="M18.81,6.49l.02.65c0,.36.03.92.05,1.25s.05.81.09,1.09.14.62.25.78l.19.28"/>
    <path class="st1" d="M11.53,9.94l.78-.49c.43-.27,1.43-.64,2.23-.84s2.11-.2,2.91,0,1.8.57,2.23.84l.78.49"/>
    <path class="st1" d="M5.04,15.67l1.3-1.12c.65-.56,1.72-1.42,2.37-1.9s1.5-1.02,1.89-1.19l.7-.32"/>
    <path class="st1" d="M20.71,11.15l.7.32c.39.18,1.24.71,1.89,1.19s1.72,1.33,2.37,1.9l1.3,1.12"/>
    <path class="st1" d="M10.52,8.81l1.49-1.3c.65-.56,1.81-1.25,2.58-1.51s2.04-.27,2.81,0,1.93.95,2.58,1.51l1.49,1.3"/>
    <path class="st1" d="M5.04,15.67l.49-1.39c.27-.77.74-1.99,1.05-2.72.31-.73.84-1.73,1.19-2.23s.94-.95,1.32-.99,1,.47,1.39,1.14.91,1.89,1.16,2.72l.46,1.49c.25.82.62,2.19.81,3.02l.63,2.76c.2.84.49,2.22.66,3.06l.99,4.89"/>
    <path class="st1" d="M16.82,27.44l.99-4.89c.17-.85.47-2.22.66-3.06l.63-2.76c.2-.84.56-2.2.81-3.02l.46-1.49c.25-.82.78-2.04,1.16-2.72s1.01-1.18,1.39-1.14.96.49,1.32.99.88,1.5,1.19,2.23.78,1.95,1.05,2.72l.49,1.39"/>
    <line class="st1" x1="15.18" y1="27.44" x2="16.82" y2="27.44"/>
  </g>
  <polygon class="st3" points="26.88 15.78 25.9 12.99 24.79 10.35 23.53 8.52 22.16 8.37 21.8 9 21.58 9.17 21.4 8.91 18.73 6.59 15.91 5.62 13.1 6.59 10.43 8.91 10.25 9.16 10.02 8.99 9.67 8.37 8.3 8.52 7.04 10.35 5.93 12.99 4.95 15.78 7.43 13.63 9.79 11.88 11.2 11.25 12.45 15.29 13.79 21.12 15.09 27.55 16.74 27.55 18.04 21.12 19.38 15.29 20.63 11.25 22.04 11.88 24.4 13.63 26.88 15.78"/>
  <polygon class="st2" points="28.52 14.71 27.39 11.5 26.11 8.46 24.66 6.37 23.08 6.19 22.67 6.91 22.42 7.1 22.21 6.82 19.14 4.14 15.9 3.02 12.67 4.14 9.59 6.82 9.39 7.1 9.12 6.9 8.72 6.19 7.14 6.37 5.69 8.46 4.41 11.5 3.29 14.71 6.14 12.24 8.85 10.23 10.48 9.5 11.92 14.15 13.46 20.85 14.95 28.25 16.85 28.25 18.34 20.85 19.88 14.15 21.33 9.5 22.95 10.23 25.66 12.24 28.52 14.71"/>
</svg>
" + }, + "rendered": { + "light": { + "bytes": "iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAERlWElmTU0AKgAAAAgAAYdpAAQAAAABAAAAGgAAAAAAA6ABAAMAAAABAAEAAKACAAQAAAABAAAAGKADAAQAAAABAAAAGAAAAADiNXWtAAADxElEQVRIDd1US2gbVxSdn6SRR9ZoPLZlIkseSXZtWR9DzcQk4EDooi2ldN91MV5nqa2LMU4XWRhhXEp3pVjdBgItVFBooSRVCW6rSkGNpbjNuDWy5v\u002BfvqkzQspHUeim9C3m3nfn3HPeu\u002B\u002B\u002BB0H/pVEoFIiNjQ3fq6wJHgV8/fq7WZ7nmGAQpyVJxhDE/2hmhnlw\u002B/ZnzZfloy8DsOxVlmFiuWg0psXjKSuZTJ0TBAHbtpwjSVo/OWn9OYzjGYHDw0P09PTsrcnJqVw\u002BX7hEUZN0JpOZcxyYdRw7YxhGliSJ\u002BNLScrfVagdZ9vI4gvgur6yw9M7O1u/lctnpF3ymRCx75Q2GWYguLCSSgiB0A4FxAkGcrM\u002BHHQNy3k2GYThiWTaDovj3HPcIn51NmNXqPU6SzmuVSuVuv8DADtLpXLxQyK7G4/M\u002BVVWvEUQ4D8MQRhDBtm07hm3boDQQAsTsQGCsa1laNhymsrIsUrFYrC6K3bl0Ot1sNBqqJ4J4jmtDIf9yMBjiYdh8WwOj3W5rpmnCum6ZqqoATVUxDE3Vdd0lMGTZMI\u002BPH1iOY8CWBb0Hw9hfjx\u002BfvdbP2RNYW1sLM8zcIuiUK/V6DY9EJqqRCHWv1Xo4pSiSCMpjeomuL0mC3Gw2ZpLJ9NcoGvgV\u002BEQms5yn6amrjuP0eHuOIKhp0B0TPN8trK6\u002B/gXPdxzbxg857uxE03TaI/dsp9OdVVXt205H\u002BkrXjW4qlb7TbD68Fg4H8PX1dcbD9QQWF1PvE0QIdM2lu5omh6anI7dKpQ9/8fv93wjC\u002BYyX4FlRFCdwHPquVLr5I8cpH1sWFqDpaBWCsPlYLPGmh8NcB2wJ3d3dvSMI1jw41MTWVnHPAwiCfCSKyjsU5UUurCDw/lBo6sidlcslEZiPbtwo7iwtZcvd7mnLLRPoNnugTff39xc2NzcbFxQX32g0SuRyq5/k89kfwD0w3KhtI\u002BP371fnKpUvPwAkA32/vb1NF4vFM4\u002BjVyI38DS5G\u002BM4TrIs/Q/QOb09KMr5JChF7WlyF99P7s4HBNzA8wdyJMty76B5XiV9PvPn52MHoyMJwLBRU1UZ91I1TcJIcrruzYfZkQR4nm\u002BCww4gCOriA5KkODQdOhlG7P0bSSCVSp2C50CxbSuoKBoJ3iHu4OBA9kiG2ZEEwAtpWZbRVlWdAq8FhSD2SOVxhUcSeLLCmiBIlChqQRSFB1r5X\u002B/AJRgbw\u002Bsoiq34/ViGJMnfhpH2//vnJvcHXuQnEomfIAj9PBwmtb29T9vgDrwI\u002Bj\u002BL/w13FKdOMSDM/wAAAABJRU5ErkJggg==", + "width": 24, + "height": 24 + }, + "dark": { + "bytes": "iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAERlWElmTU0AKgAAAAgAAYdpAAQAAAABAAAAGgAAAAAAA6ABAAMAAAABAAEAAKACAAQAAAABAAAAGKADAAQAAAABAAAAGAAAAADiNXWtAAADxElEQVRIDd1US2gbVxSdn6SRR9ZoPLZlIkseSXZtWR9DzcQk4EDooi2ldN91MV5nqa2LMU4XWRhhXEp3pVjdBgItVFBooSRVCW6rSkGNpbjNuDWy5v\u002BfvqkzQspHUeim9C3m3nfn3HPeu\u002B\u002B\u002BB0H/pVEoFIiNjQ3fq6wJHgV8/fq7WZ7nmGAQpyVJxhDE/2hmhnlw\u002B/ZnzZfloy8DsOxVlmFiuWg0psXjKSuZTJ0TBAHbtpwjSVo/OWn9OYzjGYHDw0P09PTsrcnJqVw\u002BX7hEUZN0JpOZcxyYdRw7YxhGliSJ\u002BNLScrfVagdZ9vI4gvgur6yw9M7O1u/lctnpF3ymRCx75Q2GWYguLCSSgiB0A4FxAkGcrM\u002BHHQNy3k2GYThiWTaDovj3HPcIn51NmNXqPU6SzmuVSuVuv8DADtLpXLxQyK7G4/M\u002BVVWvEUQ4D8MQRhDBtm07hm3boDQQAsTsQGCsa1laNhymsrIsUrFYrC6K3bl0Ot1sNBqqJ4J4jmtDIf9yMBjiYdh8WwOj3W5rpmnCum6ZqqoATVUxDE3Vdd0lMGTZMI\u002BPH1iOY8CWBb0Hw9hfjx\u002BfvdbP2RNYW1sLM8zcIuiUK/V6DY9EJqqRCHWv1Xo4pSiSCMpjeomuL0mC3Gw2ZpLJ9NcoGvgV\u002BEQms5yn6amrjuP0eHuOIKhp0B0TPN8trK6\u002B/gXPdxzbxg857uxE03TaI/dsp9OdVVXt205H\u002BkrXjW4qlb7TbD68Fg4H8PX1dcbD9QQWF1PvE0QIdM2lu5omh6anI7dKpQ9/8fv93wjC\u002BYyX4FlRFCdwHPquVLr5I8cpH1sWFqDpaBWCsPlYLPGmh8NcB2wJ3d3dvSMI1jw41MTWVnHPAwiCfCSKyjsU5UUurCDw/lBo6sidlcslEZiPbtwo7iwtZcvd7mnLLRPoNnugTff39xc2NzcbFxQX32g0SuRyq5/k89kfwD0w3KhtI\u002BP371fnKpUvPwAkA32/vb1NF4vFM4\u002BjVyI38DS5G\u002BM4TrIs/Q/QOb09KMr5JChF7WlyF99P7s4HBNzA8wdyJMty76B5XiV9PvPn52MHoyMJwLBRU1UZ91I1TcJIcrruzYfZkQR4nm\u002BCww4gCOriA5KkODQdOhlG7P0bSSCVSp2C50CxbSuoKBoJ3iHu4OBA9kiG2ZEEwAtpWZbRVlWdAq8FhSD2SOVxhUcSeLLCmiBIlChqQRSFB1r5X\u002B/AJRgbw\u002Bsoiq34/ViGJMnfhpH2//vnJvcHXuQnEomfIAj9PBwmtb29T9vgDrwI\u002Bj\u002BL/w13FKdOMSDM/wAAAABJRU5ErkJggg==", + "width": 24, + "height": 24 + } + } + } + }, + { + "id": "4d193e06-a5bf-4411-8933-cb2470015c83", + "language": { + "id": "*.*.python", + "version": "3.*.*" + }, + "title": "RV_loads", + "uri": "commands/RV_loads.py", + "image": { + "light": { + "type": "svg", + "data": "<svg id="Layer_1" xmlns="http://www.w3.org/2000/svg" version="1.1" viewBox="0 0 32 32">
  <!-- Generator: Adobe Illustrator 29.8.10, SVG Export Plug-In . SVG Version: 2.1.1 Build 2)  -->
  <defs>
    <style>
      .st0 {
        stroke-miterlimit: 3.6;
        stroke-width: .1px;
      }

      .st0, .st1 {
        stroke: #a6a6ae;
      }

      .st0, .st1, .st2 {
        stroke-linecap: round;
      }

      .st0, .st1, .st2, .st3, .st4 {
        fill: none;
      }

      .st1 {
        stroke-miterlimit: 3.13;
        stroke-width: .09px;
      }

      .st5 {
        fill: #178a3a;
      }

      .st6 {
        fill: #6f6f78;
      }

      .st2 {
        stroke: #178a3a;
        stroke-miterlimit: 3.37;
        stroke-width: 1.14px;
      }

      .st3 {
        stroke: #111114;
        stroke-width: .56px;
      }

      .st3, .st4 {
        stroke-linejoin: round;
      }

      .st7 {
        opacity: .11;
      }

      .st4 {
        stroke: #4a4a52;
        stroke-width: .43px;
      }
    </style>
  </defs>
  <g class="st7">
    <polygon class="st6" points="28.52 14.71 27.39 11.5 26.11 8.46 24.66 6.37 23.08 6.19 22.67 6.91 22.42 7.1 22.21 6.82 19.14 4.14 15.9 3.02 12.67 4.14 9.59 6.82 9.39 7.1 9.12 6.9 8.72 6.19 7.14 6.37 5.69 8.46 4.41 11.5 3.29 14.71 6.14 12.24 8.85 10.23 10.48 9.5 11.92 14.15 13.46 20.85 14.95 28.25 16.85 28.25 18.34 20.85 19.88 14.15 21.33 9.5 22.95 10.23 25.66 12.24 28.52 14.71"/>
  </g>
  <g class="st7">
    <polygon class="st6" points="28.11 14.98 27.02 11.87 25.78 8.94 24.38 6.9 22.85 6.74 22.45 7.44 22.21 7.62 22.01 7.34 19.03 4.75 15.9 3.67 12.78 4.75 9.8 7.34 9.6 7.61 9.35 7.42 8.96 6.74 7.43 6.9 6.03 8.94 4.79 11.87 3.7 14.98 6.46 12.59 9.09 10.64 10.66 9.94 12.05 14.44 13.54 20.92 14.99 28.08 16.82 28.08 18.27 20.92 19.76 14.44 21.15 9.94 22.72 10.64 25.34 12.59 28.11 14.98"/>
  </g>
  <g class="st7">
    <polygon class="st6" points="27.7 15.24 26.64 12.24 25.45 9.41 24.09 7.44 22.62 7.28 22.23 7.96 22 8.13 21.8 7.87 18.93 5.36 15.91 4.32 12.88 5.36 10.01 7.87 9.82 8.13 9.57 7.94 9.2 7.28 7.72 7.44 6.37 9.41 5.17 12.24 4.12 15.24 6.79 12.93 9.32 11.06 10.84 10.37 12.19 14.72 13.63 20.99 15.02 27.9 16.79 27.9 18.19 20.99 19.63 14.72 20.98 10.37 22.49 11.06 25.03 12.93 27.7 15.24"/>
  </g>
  <g class="st7">
    <polygon class="st6" points="27.29 15.51 26.27 12.62 25.12 9.88 23.81 7.98 22.39 7.83 22.01 8.48 21.79 8.65 21.6 8.39 18.83 5.98 15.91 4.97 12.99 5.98 10.22 8.39 10.04 8.64 9.8 8.46 9.43 7.83 8.01 7.98 6.7 9.88 5.55 12.62 4.53 15.51 7.11 13.28 9.56 11.47 11.02 10.81 12.32 15 13.71 21.05 15.06 27.72 16.76 27.72 18.11 21.05 19.5 15 20.8 10.81 22.27 11.47 24.71 13.28 27.29 15.51"/>
  </g>
  <g class="st7">
    <polygon class="st6" points="26.88 15.78 25.9 12.99 24.79 10.35 23.53 8.52 22.16 8.37 21.8 9 21.58 9.17 21.4 8.91 18.73 6.59 15.91 5.62 13.1 6.59 10.43 8.91 10.25 9.16 10.02 8.99 9.67 8.37 8.3 8.52 7.04 10.35 5.93 12.99 4.95 15.78 7.43 13.63 9.79 11.88 11.2 11.25 12.45 15.29 13.79 21.12 15.09 27.55 16.74 27.55 18.04 21.12 19.38 15.29 20.63 11.25 22.04 11.88 24.4 13.63 26.88 15.78"/>
  </g>
  <g>
    <line class="st0" x1="3.94" y1="14.22" x2="4.64" y2="13.57"/>
    <line class="st0" x1="4.05" y1="14.15" x2="4.31" y2="13.87"/>
    <line class="st0" x1="3.94" y1="14.22" x2="4.05" y2="14.15"/>
    <line class="st0" x1="9.67" y1="6.98" x2="9.69" y2="6.7"/>
    <line class="st0" x1="4.16" y1="14.08" x2="4.32" y2="13.87"/>
    <line class="st0" x1="4.05" y1="14.15" x2="4.16" y2="14.08"/>
    <line class="st0" x1="9.57" y1="6.86" x2="9.69" y2="6.7"/>
    <line class="st0" x1="4.27" y1="14.01" x2="4.44" y2="13.76"/>
    <line class="st0" x1="4.16" y1="14.08" x2="4.27" y2="14.01"/>
    <line class="st0" x1="27.36" y1="13.57" x2="27.61" y2="13.82"/>
    <line class="st0" x1="27.95" y1="14.15" x2="28.06" y2="14.22"/>
    <line class="st0" x1="27.69" y1="13.87" x2="27.95" y2="14.15"/>
    <line class="st0" x1="27.84" y1="14.08" x2="27.95" y2="14.15"/>
    <line class="st0" x1="27.68" y1="13.87" x2="27.84" y2="14.08"/>
    <line class="st0" x1="27.73" y1="14.01" x2="27.84" y2="14.08"/>
    <line class="st0" x1="27.56" y1="13.76" x2="27.73" y2="14.01"/>
    <line class="st0" x1="22.31" y1="6.7" x2="22.43" y2="6.86"/>
    <line class="st0" x1="22.31" y1="6.7" x2="22.33" y2="6.98"/>
    <line class="st0" x1="4.51" y1="11.38" x2="5.02" y2="11.73"/>
    <line class="st0" x1="3.39" y1="14.59" x2="3.49" y2="14.52"/>
    <line class="st0" x1="5.79" y1="8.35" x2="6.67" y2="9.14"/>
    <line class="st0" x1="6.67" y1="9.14" x2="7.51" y2="9.77"/>
    <line class="st0" x1="5.02" y1="11.73" x2="5.48" y2="12.01"/>
    <line class="st0" x1="3.49" y1="14.52" x2="3.61" y2="14.45"/>
    <line class="st0" x1="7.24" y1="6.25" x2="8.41" y2="7.43"/>
    <line class="st0" x1="9.63" y1="8.35" x2="10.15" y2="8.39"/>
    <line class="st0" x1="8.41" y1="7.43" x2="9.63" y2="8.35"/>
    <line class="st0" x1="9.63" y1="8.35" x2="10.24" y2="8.56"/>
    <line class="st0" x1="8.31" y1="10.13" x2="10.48" y2="9.05"/>
    <line class="st0" x1="7.51" y1="9.77" x2="8.31" y2="10.13"/>
    <line class="st0" x1="8.31" y1="10.13" x2="8.95" y2="10.11"/>
    <line class="st0" x1="5.48" y1="12.01" x2="5.9" y2="12.16"/>
    <line class="st0" x1="3.72" y1="14.38" x2="5.9" y2="12.16"/>
    <line class="st0" x1="3.61" y1="14.45" x2="3.72" y2="14.38"/>
    <line class="st0" x1="5.9" y1="12.16" x2="8.31" y2="10.13"/>
    <line class="st0" x1="5.9" y1="12.16" x2="6.24" y2="12.12"/>
    <line class="st0" x1="3.72" y1="14.38" x2="3.83" y2="14.29"/>
    <line class="st0" x1="15.05" y1="28.13" x2="15.29" y2="28.13"/>
    <line class="st0" x1="15.29" y1="28.13" x2="15.52" y2="28.13"/>
    <line class="st0" x1="15.52" y1="28.13" x2="15.77" y2="28.13"/>
    <line class="st0" x1="15.77" y1="28.13" x2="16" y2="28.13"/>
    <line class="st0" x1="16" y1="28.13" x2="16.23" y2="28.13"/>
    <line class="st0" x1="16.23" y1="28.13" x2="16.48" y2="28.13"/>
    <line class="st0" x1="16.48" y1="28.13" x2="16.71" y2="28.13"/>
    <line class="st0" x1="16.71" y1="28.13" x2="16.95" y2="28.13"/>
    <line class="st0" x1="21.85" y1="8.39" x2="22.37" y2="8.35"/>
    <line class="st0" x1="21.76" y1="8.56" x2="22.37" y2="8.35"/>
    <line class="st0" x1="23.69" y1="10.13" x2="24.49" y2="9.77"/>
    <line class="st0" x1="21.52" y1="9.05" x2="23.69" y2="10.13"/>
    <line class="st0" x1="23.05" y1="10.11" x2="23.69" y2="10.13"/>
    <line class="st0" x1="22.37" y1="8.35" x2="23.59" y2="7.43"/>
    <line class="st0" x1="23.59" y1="7.43" x2="24.76" y2="6.25"/>
    <line class="st0" x1="25.33" y1="9.14" x2="26.21" y2="8.35"/>
    <line class="st0" x1="24.49" y1="9.77" x2="25.33" y2="9.14"/>
    <line class="st0" x1="26.52" y1="12.01" x2="26.98" y2="11.73"/>
    <line class="st0" x1="26.98" y1="11.73" x2="27.49" y2="11.38"/>
    <line class="st0" x1="23.69" y1="10.13" x2="26.1" y2="12.16"/>
    <line class="st0" x1="25.76" y1="12.12" x2="26.1" y2="12.16"/>
    <line class="st0" x1="26.1" y1="12.16" x2="26.52" y2="12.01"/>
    <line class="st0" x1="26.1" y1="12.16" x2="28.28" y2="14.38"/>
    <path class="st0" d="M12.09,8.66l.22-.32c.12-.18.24-.58.29-.89s.08-.87.11-1.25.05-1.02.05-1.43l.02-.75"/>
    <path class="st0" d="M19.23,4.02l.02.75c0,.41.04,1.05.05,1.43s.06.94.11,1.25.16.71.29.89l.22.32"/>
    <path class="st0" d="M10.85,8l.9-.56c.5-.31,1.65-.74,2.57-.96s2.42-.23,3.34,0,2.07.66,2.57.96l.9.56"/>
    <path class="st0" d="M3.39,14.59l1.5-1.29c.75-.65,1.97-1.63,2.72-2.18s1.72-1.17,2.17-1.37l.81-.37"/>
    <path class="st0" d="M21.42,9.38l.81.37c.45.21,1.42.82,2.17,1.37s1.97,1.53,2.72,2.18l1.5,1.29"/>
    <path class="st0" d="M9.69,6.7l1.71-1.5c.75-.65,2.08-1.43,2.97-1.74s2.34-.31,3.23,0,2.23,1.09,2.97,1.74l1.71,1.5"/>
    <path class="st0" d="M3.39,14.59l.56-1.6c.31-.88.86-2.29,1.21-3.13.35-.84.96-1.99,1.37-2.57s1.08-1.09,1.51-1.14,1.15.54,1.59,1.32,1.05,2.17,1.33,3.13l.53,1.71c.29.95.71,2.51.94,3.48l.73,3.18c.23.96.57,2.55.76,3.52l1.14,5.63"/>
    <path class="st0" d="M16.95,28.13l1.14-5.63c.2-.97.54-2.56.76-3.52l.73-3.18c.23-.96.64-2.53.94-3.48l.53-1.71c.29-.95.89-2.35,1.33-3.13s1.16-1.36,1.59-1.32,1.11.56,1.51,1.14,1.01,1.73,1.37,2.57.89,2.24,1.21,3.13l.56,1.6"/>
    <line class="st0" x1="15.05" y1="28.13" x2="16.95" y2="28.13"/>
  </g>
  <g>
    <line class="st1" x1="5.52" y1="15.35" x2="6.12" y2="14.79"/>
    <line class="st1" x1="5.62" y1="15.29" x2="5.84" y2="15.05"/>
    <line class="st1" x1="5.52" y1="15.35" x2="5.62" y2="15.29"/>
    <line class="st1" x1="10.5" y1="9.06" x2="10.52" y2="8.81"/>
    <line class="st1" x1="5.71" y1="15.23" x2="5.85" y2="15.05"/>
    <line class="st1" x1="5.62" y1="15.29" x2="5.71" y2="15.23"/>
    <line class="st1" x1="10.41" y1="8.95" x2="10.52" y2="8.81"/>
    <line class="st1" x1="5.8" y1="15.16" x2="5.95" y2="14.95"/>
    <line class="st1" x1="5.71" y1="15.23" x2="5.8" y2="15.16"/>
    <line class="st1" x1="25.88" y1="14.79" x2="26.09" y2="15"/>
    <line class="st1" x1="26.38" y1="15.29" x2="26.48" y2="15.35"/>
    <line class="st1" x1="26.16" y1="15.05" x2="26.38" y2="15.29"/>
    <line class="st1" x1="26.29" y1="15.23" x2="26.38" y2="15.29"/>
    <line class="st1" x1="26.15" y1="15.05" x2="26.29" y2="15.23"/>
    <line class="st1" x1="26.2" y1="15.16" x2="26.29" y2="15.23"/>
    <line class="st1" x1="26.05" y1="14.95" x2="26.2" y2="15.16"/>
    <line class="st1" x1="21.48" y1="8.81" x2="21.59" y2="8.95"/>
    <line class="st1" x1="21.48" y1="8.81" x2="21.5" y2="9.06"/>
    <line class="st1" x1="6.01" y1="12.89" x2="6.45" y2="13.18"/>
    <line class="st1" x1="5.04" y1="15.67" x2="5.13" y2="15.61"/>
    <line class="st1" x1="7.13" y1="10.25" x2="7.89" y2="10.94"/>
    <line class="st1" x1="7.89" y1="10.94" x2="8.62" y2="11.48"/>
    <line class="st1" x1="6.45" y1="13.18" x2="6.86" y2="13.43"/>
    <line class="st1" x1="5.13" y1="15.61" x2="5.23" y2="15.55"/>
    <line class="st1" x1="8.39" y1="8.42" x2="9.41" y2="9.45"/>
    <line class="st1" x1="10.46" y1="10.25" x2="10.92" y2="10.29"/>
    <line class="st1" x1="9.41" y1="9.45" x2="10.46" y2="10.25"/>
    <line class="st1" x1="10.46" y1="10.25" x2="11" y2="10.43"/>
    <line class="st1" x1="9.32" y1="11.8" x2="11.2" y2="10.86"/>
    <line class="st1" x1="8.62" y1="11.48" x2="9.32" y2="11.8"/>
    <line class="st1" x1="9.32" y1="11.8" x2="9.88" y2="11.78"/>
    <line class="st1" x1="6.86" y1="13.43" x2="7.22" y2="13.56"/>
    <line class="st1" x1="5.33" y1="15.49" x2="7.22" y2="13.56"/>
    <line class="st1" x1="5.23" y1="15.55" x2="5.33" y2="15.49"/>
    <line class="st1" x1="7.22" y1="13.56" x2="9.32" y2="11.8"/>
    <line class="st1" x1="7.22" y1="13.56" x2="7.52" y2="13.53"/>
    <line class="st1" x1="5.33" y1="15.49" x2="5.42" y2="15.41"/>
    <line class="st1" x1="15.18" y1="27.44" x2="15.38" y2="27.44"/>
    <line class="st1" x1="15.38" y1="27.44" x2="15.58" y2="27.44"/>
    <line class="st1" x1="15.58" y1="27.44" x2="15.8" y2="27.44"/>
    <line class="st1" x1="15.8" y1="27.44" x2="16" y2="27.44"/>
    <line class="st1" x1="16" y1="27.44" x2="16.2" y2="27.44"/>
    <line class="st1" x1="16.2" y1="27.44" x2="16.42" y2="27.44"/>
    <line class="st1" x1="16.42" y1="27.44" x2="16.62" y2="27.44"/>
    <line class="st1" x1="16.62" y1="27.44" x2="16.82" y2="27.44"/>
    <line class="st1" x1="21.08" y1="10.29" x2="21.54" y2="10.25"/>
    <line class="st1" x1="21" y1="10.43" x2="21.54" y2="10.25"/>
    <line class="st1" x1="22.68" y1="11.8" x2="23.38" y2="11.48"/>
    <line class="st1" x1="20.8" y1="10.86" x2="22.68" y2="11.8"/>
    <line class="st1" x1="22.12" y1="11.78" x2="22.68" y2="11.8"/>
    <line class="st1" x1="21.54" y1="10.25" x2="22.59" y2="9.45"/>
    <line class="st1" x1="22.59" y1="9.45" x2="23.61" y2="8.42"/>
    <line class="st1" x1="24.11" y1="10.94" x2="24.87" y2="10.25"/>
    <line class="st1" x1="23.38" y1="11.48" x2="24.11" y2="10.94"/>
    <line class="st1" x1="25.14" y1="13.43" x2="25.55" y2="13.18"/>
    <line class="st1" x1="25.55" y1="13.18" x2="25.99" y2="12.89"/>
    <line class="st1" x1="22.68" y1="11.8" x2="24.78" y2="13.56"/>
    <line class="st1" x1="24.48" y1="13.53" x2="24.78" y2="13.56"/>
    <line class="st1" x1="24.78" y1="13.56" x2="25.14" y2="13.43"/>
    <line class="st1" x1="24.78" y1="13.56" x2="26.67" y2="15.49"/>
    <path class="st1" d="M12.6,10.52l.19-.28c.1-.16.21-.5.25-.78s.07-.76.09-1.09.04-.88.05-1.25l.02-.65"/>
    <path class="st1" d="M18.81,6.49l.02.65c0,.36.03.92.05,1.25s.05.81.09,1.09.14.62.25.78l.19.28"/>
    <path class="st1" d="M11.53,9.94l.78-.49c.43-.27,1.43-.64,2.23-.84s2.11-.2,2.91,0,1.8.57,2.23.84l.78.49"/>
    <path class="st1" d="M5.04,15.67l1.3-1.12c.65-.56,1.72-1.42,2.37-1.9s1.5-1.02,1.89-1.19l.7-.32"/>
    <path class="st1" d="M20.71,11.15l.7.32c.39.18,1.24.71,1.89,1.19s1.72,1.33,2.37,1.9l1.3,1.12"/>
    <path class="st1" d="M10.52,8.81l1.49-1.3c.65-.56,1.81-1.25,2.58-1.51s2.04-.27,2.81,0,1.93.95,2.58,1.51l1.49,1.3"/>
    <path class="st1" d="M5.04,15.67l.49-1.39c.27-.77.74-1.99,1.05-2.72.31-.73.84-1.73,1.19-2.23s.94-.95,1.32-.99,1,.47,1.39,1.14.91,1.89,1.16,2.72l.46,1.49c.25.82.62,2.19.81,3.02l.63,2.76c.2.84.49,2.22.66,3.06l.99,4.89"/>
    <path class="st1" d="M16.82,27.44l.99-4.89c.17-.85.47-2.22.66-3.06l.63-2.76c.2-.84.56-2.2.81-3.02l.46-1.49c.25-.82.78-2.04,1.16-2.72s1.01-1.18,1.39-1.14.96.49,1.32.99.88,1.5,1.19,2.23.78,1.95,1.05,2.72l.49,1.39"/>
    <line class="st1" x1="15.18" y1="27.44" x2="16.82" y2="27.44"/>
  </g>
  <polygon class="st4" points="26.88 15.78 25.9 12.99 24.79 10.35 23.53 8.52 22.16 8.37 21.8 9 21.58 9.17 21.4 8.91 18.73 6.59 15.91 5.62 13.1 6.59 10.43 8.91 10.25 9.16 10.02 8.99 9.67 8.37 8.3 8.52 7.04 10.35 5.93 12.99 4.95 15.78 7.43 13.63 9.79 11.88 11.2 11.25 12.45 15.29 13.79 21.12 15.09 27.55 16.74 27.55 18.04 21.12 19.38 15.29 20.63 11.25 22.04 11.88 24.4 13.63 26.88 15.78"/>
  <polygon class="st3" points="28.52 14.71 27.39 11.5 26.11 8.46 24.66 6.37 23.08 6.19 22.67 6.91 22.42 7.1 22.21 6.82 19.14 4.14 15.9 3.02 12.67 4.14 9.59 6.82 9.39 7.1 9.12 6.9 8.72 6.19 7.14 6.37 5.69 8.46 4.41 11.5 3.29 14.71 6.14 12.24 8.85 10.23 10.48 9.5 11.92 14.15 13.46 20.85 14.95 28.25 16.85 28.25 18.34 20.85 19.88 14.15 21.33 9.5 22.95 10.23 25.66 12.24 28.52 14.71"/>
  <line class="st2" x1="5.48" y1="2.98" x2="5.48" y2="8.34"/>
  <polygon class="st5" points="5.48 10.97 3.46 7.97 7.51 7.97 5.48 10.97"/>
  <line class="st2" x1="26.2" y1="2.98" x2="26.2" y2="8.34"/>
  <polygon class="st5" points="26.2 10.97 24.18 7.97 28.22 7.97 26.2 10.97"/>
  <line class="st2" x1="9.93" y1=".97" x2="9.93" y2="6.33"/>
  <polygon class="st5" points="9.93 8.97 7.91 5.96 11.96 5.96 9.93 8.97"/>
  <line class="st2" x1="21.31" y1=".97" x2="21.31" y2="6.33"/>
  <polygon class="st5" points="21.31 8.97 19.29 5.96 23.33 5.96 21.31 8.97"/>
  <line class="st2" x1="15.62" y1=".6" x2="15.62" y2="5.96"/>
  <polygon class="st5" points="15.62 8.59 13.6 5.58 17.64 5.58 15.62 8.59"/>
</svg>
" + } + } + }, + { + "id": "999051c0-e7a0-4af8-937c-233ff85436b1", + "language": { + "id": "*.*.python", + "version": "3.*.*" + }, + "title": "RV_tno_analysis", + "uri": "commands/RV_tno_analysis.py", + "image": { + "light": { + "type": "svg", + "data": "<svg xmlns="http://www.w3.org/2000/svg" viewBox="-3 -3 38 38" width="32" height="32"><defs><linearGradient id="rvbar" x1="18.68" y1="0" x2="29.89" y2="0" gradientUnits="userSpaceOnUse"><stop offset="0" stop-color="#2e4ab5"></stop><stop offset="1" stop-color="#bdc9fa"></stop></linearGradient></defs>
<g transform="translate(-0.800 -1.180) scale(1.05)"><g opacity=".4"><polygon fill="#D8D8DE" points="29.89 15.1 28.64 11.54 27.22 8.17 25.61 5.84 23.86 5.65 23.4 6.45 23.12 6.66 22.89 6.34 19.48 3.37 15.89 2.13 12.3 3.37 8.89 6.34 8.66 6.65 8.37 6.43 7.92 5.65 6.17 5.84 4.56 8.17 3.14 11.54 1.89 15.1 5.06 12.36 8.07 10.13 9.87 9.32 11.47 14.48 13.18 21.92 14.84 30.13 16.94 30.13 18.6 21.92 20.31 14.48 21.91 9.32 23.71 10.13 26.72 12.36 29.89 15.1"></polygon></g></g>
<g transform="translate(0.800 1.180) scale(0.95)"><g opacity=".4"><polygon fill="#D8D8DE" points="29.89 15.1 28.64 11.54 27.22 8.17 25.61 5.84 23.86 5.65 23.4 6.45 23.12 6.66 22.89 6.34 19.48 3.37 15.89 2.13 12.3 3.37 8.89 6.34 8.66 6.65 8.37 6.43 7.92 5.65 6.17 5.84 4.56 8.17 3.14 11.54 1.89 15.1 5.06 12.36 8.07 10.13 9.87 9.32 11.47 14.48 13.18 21.92 14.84 30.13 16.94 30.13 18.6 21.92 20.31 14.48 21.91 9.32 23.71 10.13 26.72 12.36 29.89 15.1"></polygon></g></g>
<g transform="translate(-1.120 -1.690) scale(1.07)"><g fill="none" stroke="#C2C2C9" stroke-width="0.11" stroke-linecap="round"><line x1="2.62" y1="14.56" x2="3.39" y2="13.84"></line><line x1="2.74" y1="14.48" x2="3.03" y2="14.17"></line><line x1="2.62" y1="14.56" x2="2.74" y2="14.48"></line><line x1="8.98" y1="6.52" x2="9" y2="6.21"></line><line x1="2.86" y1="14.4" x2="3.04" y2="14.17"></line><line x1="2.74" y1="14.48" x2="2.86" y2="14.4"></line><line x1="8.86" y1="6.39" x2="9" y2="6.21"></line><line x1="2.98" y1="14.32" x2="3.17" y2="14.05"></line><line x1="2.86" y1="14.4" x2="2.98" y2="14.32"></line><line x1="28.61" y1="13.84" x2="28.89" y2="14.11"></line><line x1="29.26" y1="14.48" x2="29.38" y2="14.56"></line><line x1="28.97" y1="14.17" x2="29.26" y2="14.48"></line><line x1="29.14" y1="14.4" x2="29.26" y2="14.48"></line><line x1="28.96" y1="14.17" x2="29.14" y2="14.4"></line><line x1="29.02" y1="14.32" x2="29.14" y2="14.4"></line><line x1="28.83" y1="14.05" x2="29.02" y2="14.32"></line><line x1="23" y1="6.21" x2="23.14" y2="6.39"></line><line x1="23" y1="6.21" x2="23.02" y2="6.52"></line><line x1="3.25" y1="11.41" x2="3.81" y2="11.79"></line><line x1="2" y1="14.97" x2="2.12" y2="14.89"></line><line x1="4.67" y1="8.04" x2="5.65" y2="8.92"></line><line x1="5.65" y1="8.92" x2="6.58" y2="9.62"></line><line x1="3.81" y1="11.79" x2="4.33" y2="12.1"></line><line x1="2.12" y1="14.89" x2="2.25" y2="14.81"></line><line x1="6.28" y1="5.71" x2="7.58" y2="7.02"></line><line x1="8.93" y1="8.04" x2="9.51" y2="8.09"></line><line x1="7.58" y1="7.02" x2="8.93" y2="8.04"></line><line x1="8.93" y1="8.04" x2="9.61" y2="8.28"></line><line x1="7.47" y1="10.02" x2="9.87" y2="8.82"></line><line x1="6.58" y1="9.62" x2="7.47" y2="10.02"></line><line x1="7.47" y1="10.02" x2="8.18" y2="10"></line><line x1="4.33" y1="12.1" x2="4.79" y2="12.27"></line><line x1="2.37" y1="14.73" x2="4.79" y2="12.27"></line><line x1="2.25" y1="14.81" x2="2.37" y2="14.73"></line><line x1="4.79" y1="12.27" x2="7.47" y2="10.02"></line><line x1="4.79" y1="12.27" x2="5.17" y2="12.23"></line><line x1="2.37" y1="14.73" x2="2.49" y2="14.64"></line><line x1="14.95" y1="30" x2="15.21" y2="30"></line><line x1="15.21" y1="30" x2="15.47" y2="30"></line><line x1="15.47" y1="30" x2="15.74" y2="30"></line><line x1="15.74" y1="30" x2="16" y2="30"></line><line x1="16" y1="30" x2="16.26" y2="30"></line><line x1="16.26" y1="30" x2="16.53" y2="30"></line><line x1="16.53" y1="30" x2="16.79" y2="30"></line><line x1="16.79" y1="30" x2="17.05" y2="30"></line><line x1="22.49" y1="8.09" x2="23.07" y2="8.04"></line><line x1="22.39" y1="8.28" x2="23.07" y2="8.04"></line><line x1="24.53" y1="10.02" x2="25.42" y2="9.62"></line><line x1="22.13" y1="8.82" x2="24.53" y2="10.02"></line><line x1="23.82" y1="10" x2="24.53" y2="10.02"></line><line x1="23.07" y1="8.04" x2="24.42" y2="7.02"></line><line x1="24.42" y1="7.02" x2="25.72" y2="5.71"></line><line x1="26.35" y1="8.92" x2="27.33" y2="8.04"></line><line x1="25.42" y1="9.62" x2="26.35" y2="8.92"></line><line x1="27.67" y1="12.1" x2="28.19" y2="11.79"></line><line x1="28.19" y1="11.79" x2="28.75" y2="11.41"></line><line x1="24.53" y1="10.02" x2="27.21" y2="12.27"></line><line x1="26.83" y1="12.23" x2="27.21" y2="12.27"></line><line x1="27.21" y1="12.27" x2="27.67" y2="12.1"></line><line x1="27.21" y1="12.27" x2="29.63" y2="14.73"></line><path d="M11.66,8.39l.24-.36c.13-.2.27-.64.32-.99s.09-.97.12-1.39.05-1.13.06-1.59l.02-.83"></path><path d="M19.59,3.24l.02.83c.01.46.04,1.17.06,1.59s.07,1.04.12,1.39.18.79.32.99l.24.36"></path><path d="M10.29,7.65l1-.62c.55-.34,1.83-.82,2.85-1.07s2.69-.25,3.71,0,2.3.73,2.85,1.07l1,.62"></path><path d="M2,14.97l1.66-1.43c.83-.72,2.19-1.81,3.02-2.42s1.91-1.3,2.41-1.52l.9-.41"></path><path d="M22.01,9.19l.9.41c.5.23,1.58.91,2.41,1.52s2.19,1.7,3.02,2.42l1.66,1.43"></path><path d="M9,6.21l1.9-1.66c.83-.72,2.31-1.59,3.3-1.93s2.6-.34,3.59,0,2.47,1.21,3.3,1.93l1.9,1.66"></path><path d="M2,14.97l.62-1.78c.34-.98.95-2.54,1.34-3.47s1.07-2.21,1.52-2.85,1.2-1.21,1.68-1.26,1.28.6,1.77,1.46,1.16,2.41,1.48,3.47l.59,1.9c.32,1.05.79,2.79,1.04,3.86l.81,3.53c.25,1.07.63,2.83.84,3.91l1.26,6.25"></path><path d="M17.05,30l1.26-6.25c.22-1.08.6-2.84.84-3.91l.81-3.53c.25-1.07.71-2.81,1.04-3.86l.59-1.9c.32-1.05.99-2.61,1.48-3.47s1.29-1.51,1.77-1.46,1.23.62,1.68,1.26,1.12,1.92,1.52,2.85.99,2.49,1.34,3.47l.62,1.78"></path><line x1="14.95" y1="30" x2="17.05" y2="30"></line></g></g>
<g transform="translate(1.120 1.690) scale(0.93)"><g fill="none" stroke="#C2C2C9" stroke-width="0.11" stroke-linecap="round"><line x1="2.62" y1="14.56" x2="3.39" y2="13.84"></line><line x1="2.74" y1="14.48" x2="3.03" y2="14.17"></line><line x1="2.62" y1="14.56" x2="2.74" y2="14.48"></line><line x1="8.98" y1="6.52" x2="9" y2="6.21"></line><line x1="2.86" y1="14.4" x2="3.04" y2="14.17"></line><line x1="2.74" y1="14.48" x2="2.86" y2="14.4"></line><line x1="8.86" y1="6.39" x2="9" y2="6.21"></line><line x1="2.98" y1="14.32" x2="3.17" y2="14.05"></line><line x1="2.86" y1="14.4" x2="2.98" y2="14.32"></line><line x1="28.61" y1="13.84" x2="28.89" y2="14.11"></line><line x1="29.26" y1="14.48" x2="29.38" y2="14.56"></line><line x1="28.97" y1="14.17" x2="29.26" y2="14.48"></line><line x1="29.14" y1="14.4" x2="29.26" y2="14.48"></line><line x1="28.96" y1="14.17" x2="29.14" y2="14.4"></line><line x1="29.02" y1="14.32" x2="29.14" y2="14.4"></line><line x1="28.83" y1="14.05" x2="29.02" y2="14.32"></line><line x1="23" y1="6.21" x2="23.14" y2="6.39"></line><line x1="23" y1="6.21" x2="23.02" y2="6.52"></line><line x1="3.25" y1="11.41" x2="3.81" y2="11.79"></line><line x1="2" y1="14.97" x2="2.12" y2="14.89"></line><line x1="4.67" y1="8.04" x2="5.65" y2="8.92"></line><line x1="5.65" y1="8.92" x2="6.58" y2="9.62"></line><line x1="3.81" y1="11.79" x2="4.33" y2="12.1"></line><line x1="2.12" y1="14.89" x2="2.25" y2="14.81"></line><line x1="6.28" y1="5.71" x2="7.58" y2="7.02"></line><line x1="8.93" y1="8.04" x2="9.51" y2="8.09"></line><line x1="7.58" y1="7.02" x2="8.93" y2="8.04"></line><line x1="8.93" y1="8.04" x2="9.61" y2="8.28"></line><line x1="7.47" y1="10.02" x2="9.87" y2="8.82"></line><line x1="6.58" y1="9.62" x2="7.47" y2="10.02"></line><line x1="7.47" y1="10.02" x2="8.18" y2="10"></line><line x1="4.33" y1="12.1" x2="4.79" y2="12.27"></line><line x1="2.37" y1="14.73" x2="4.79" y2="12.27"></line><line x1="2.25" y1="14.81" x2="2.37" y2="14.73"></line><line x1="4.79" y1="12.27" x2="7.47" y2="10.02"></line><line x1="4.79" y1="12.27" x2="5.17" y2="12.23"></line><line x1="2.37" y1="14.73" x2="2.49" y2="14.64"></line><line x1="14.95" y1="30" x2="15.21" y2="30"></line><line x1="15.21" y1="30" x2="15.47" y2="30"></line><line x1="15.47" y1="30" x2="15.74" y2="30"></line><line x1="15.74" y1="30" x2="16" y2="30"></line><line x1="16" y1="30" x2="16.26" y2="30"></line><line x1="16.26" y1="30" x2="16.53" y2="30"></line><line x1="16.53" y1="30" x2="16.79" y2="30"></line><line x1="16.79" y1="30" x2="17.05" y2="30"></line><line x1="22.49" y1="8.09" x2="23.07" y2="8.04"></line><line x1="22.39" y1="8.28" x2="23.07" y2="8.04"></line><line x1="24.53" y1="10.02" x2="25.42" y2="9.62"></line><line x1="22.13" y1="8.82" x2="24.53" y2="10.02"></line><line x1="23.82" y1="10" x2="24.53" y2="10.02"></line><line x1="23.07" y1="8.04" x2="24.42" y2="7.02"></line><line x1="24.42" y1="7.02" x2="25.72" y2="5.71"></line><line x1="26.35" y1="8.92" x2="27.33" y2="8.04"></line><line x1="25.42" y1="9.62" x2="26.35" y2="8.92"></line><line x1="27.67" y1="12.1" x2="28.19" y2="11.79"></line><line x1="28.19" y1="11.79" x2="28.75" y2="11.41"></line><line x1="24.53" y1="10.02" x2="27.21" y2="12.27"></line><line x1="26.83" y1="12.23" x2="27.21" y2="12.27"></line><line x1="27.21" y1="12.27" x2="27.67" y2="12.1"></line><line x1="27.21" y1="12.27" x2="29.63" y2="14.73"></line><path d="M11.66,8.39l.24-.36c.13-.2.27-.64.32-.99s.09-.97.12-1.39.05-1.13.06-1.59l.02-.83"></path><path d="M19.59,3.24l.02.83c.01.46.04,1.17.06,1.59s.07,1.04.12,1.39.18.79.32.99l.24.36"></path><path d="M10.29,7.65l1-.62c.55-.34,1.83-.82,2.85-1.07s2.69-.25,3.71,0,2.3.73,2.85,1.07l1,.62"></path><path d="M2,14.97l1.66-1.43c.83-.72,2.19-1.81,3.02-2.42s1.91-1.3,2.41-1.52l.9-.41"></path><path d="M22.01,9.19l.9.41c.5.23,1.58.91,2.41,1.52s2.19,1.7,3.02,2.42l1.66,1.43"></path><path d="M9,6.21l1.9-1.66c.83-.72,2.31-1.59,3.3-1.93s2.6-.34,3.59,0,2.47,1.21,3.3,1.93l1.9,1.66"></path><path d="M2,14.97l.62-1.78c.34-.98.95-2.54,1.34-3.47s1.07-2.21,1.52-2.85,1.2-1.21,1.68-1.26,1.28.6,1.77,1.46,1.16,2.41,1.48,3.47l.59,1.9c.32,1.05.79,2.79,1.04,3.86l.81,3.53c.25,1.07.63,2.83.84,3.91l1.26,6.25"></path><path d="M17.05,30l1.26-6.25c.22-1.08.6-2.84.84-3.91l.81-3.53c.25-1.07.71-2.81,1.04-3.86l.59-1.9c.32-1.05.99-2.61,1.48-3.47s1.29-1.51,1.77-1.46,1.23.62,1.68,1.26,1.12,1.92,1.52,2.85.99,2.49,1.34,3.47l.62,1.78"></path><line x1="14.95" y1="30" x2="17.05" y2="30"></line></g></g>
<g transform="translate(-1.120 -1.690) scale(1.07)"><polygon fill="none" stroke="#A9A9B1" stroke-width="0.45" stroke-linejoin="round" points="29.89 15.1 28.64 11.54 27.22 8.17 25.61 5.84 23.86 5.65 23.4 6.45 23.12 6.66 22.89 6.34 19.48 3.37 15.89 2.13 12.3 3.37 8.89 6.34 8.66 6.65 8.37 6.43 7.92 5.65 6.17 5.84 4.56 8.17 3.14 11.54 1.89 15.1 5.06 12.36 8.07 10.13 9.87 9.32 11.47 14.48 13.18 21.92 14.84 30.13 16.94 30.13 18.6 21.92 20.31 14.48 21.91 9.32 23.71 10.13 26.72 12.36 29.89 15.1"></polygon></g>
<g transform="translate(1.120 1.690) scale(0.93)"><polygon fill="none" stroke="#8B8B93" stroke-width="0.5" stroke-linejoin="round" points="29.89 15.1 28.64 11.54 27.22 8.17 25.61 5.84 23.86 5.65 23.4 6.45 23.12 6.66 22.89 6.34 19.48 3.37 15.89 2.13 12.3 3.37 8.89 6.34 8.66 6.65 8.37 6.43 7.92 5.65 6.17 5.84 4.56 8.17 3.14 11.54 1.89 15.1 5.06 12.36 8.07 10.13 9.87 9.32 11.47 14.48 13.18 21.92 14.84 30.13 16.94 30.13 18.6 21.92 20.31 14.48 21.91 9.32 23.71 10.13 26.72 12.36 29.89 15.1"></polygon></g>
<g fill="none" stroke="#A32FC4" stroke-width="0.3" stroke-linecap="round"><line x1="2.62" y1="14.56" x2="3.39" y2="13.84"></line><line x1="2.74" y1="14.48" x2="3.03" y2="14.17"></line><line x1="2.62" y1="14.56" x2="2.74" y2="14.48"></line><line x1="8.98" y1="6.52" x2="9" y2="6.21"></line><line x1="2.86" y1="14.4" x2="3.04" y2="14.17"></line><line x1="2.74" y1="14.48" x2="2.86" y2="14.4"></line><line x1="8.86" y1="6.39" x2="9" y2="6.21"></line><line x1="2.98" y1="14.32" x2="3.17" y2="14.05"></line><line x1="2.86" y1="14.4" x2="2.98" y2="14.32"></line><line x1="28.61" y1="13.84" x2="28.89" y2="14.11"></line><line x1="29.26" y1="14.48" x2="29.38" y2="14.56"></line><line x1="28.97" y1="14.17" x2="29.26" y2="14.48"></line><line x1="29.14" y1="14.4" x2="29.26" y2="14.48"></line><line x1="28.96" y1="14.17" x2="29.14" y2="14.4"></line><line x1="29.02" y1="14.32" x2="29.14" y2="14.4"></line><line x1="28.83" y1="14.05" x2="29.02" y2="14.32"></line><line x1="23" y1="6.21" x2="23.14" y2="6.39"></line><line x1="23" y1="6.21" x2="23.02" y2="6.52"></line><line x1="3.25" y1="11.41" x2="3.81" y2="11.79"></line><line x1="2" y1="14.97" x2="2.12" y2="14.89"></line><line x1="4.67" y1="8.04" x2="5.65" y2="8.92"></line><line x1="5.65" y1="8.92" x2="6.58" y2="9.62"></line><line x1="3.81" y1="11.79" x2="4.33" y2="12.1"></line><line x1="2.12" y1="14.89" x2="2.25" y2="14.81"></line><line x1="6.28" y1="5.71" x2="7.58" y2="7.02"></line><line x1="8.93" y1="8.04" x2="9.51" y2="8.09"></line><line x1="7.58" y1="7.02" x2="8.93" y2="8.04"></line><line x1="8.93" y1="8.04" x2="9.61" y2="8.28"></line><line x1="7.47" y1="10.02" x2="9.87" y2="8.82"></line><line x1="6.58" y1="9.62" x2="7.47" y2="10.02"></line><line x1="7.47" y1="10.02" x2="8.18" y2="10"></line><line x1="4.33" y1="12.1" x2="4.79" y2="12.27"></line><line x1="2.37" y1="14.73" x2="4.79" y2="12.27"></line><line x1="2.25" y1="14.81" x2="2.37" y2="14.73"></line><line x1="4.79" y1="12.27" x2="7.47" y2="10.02"></line><line x1="4.79" y1="12.27" x2="5.17" y2="12.23"></line><line x1="2.37" y1="14.73" x2="2.49" y2="14.64"></line><line x1="14.95" y1="30" x2="15.21" y2="30"></line><line x1="15.21" y1="30" x2="15.47" y2="30"></line><line x1="15.47" y1="30" x2="15.74" y2="30"></line><line x1="15.74" y1="30" x2="16" y2="30"></line><line x1="16" y1="30" x2="16.26" y2="30"></line><line x1="16.26" y1="30" x2="16.53" y2="30"></line><line x1="16.53" y1="30" x2="16.79" y2="30"></line><line x1="16.79" y1="30" x2="17.05" y2="30"></line><line x1="22.49" y1="8.09" x2="23.07" y2="8.04"></line><line x1="22.39" y1="8.28" x2="23.07" y2="8.04"></line><line x1="24.53" y1="10.02" x2="25.42" y2="9.62"></line><line x1="22.13" y1="8.82" x2="24.53" y2="10.02"></line><line x1="23.82" y1="10" x2="24.53" y2="10.02"></line><line x1="23.07" y1="8.04" x2="24.42" y2="7.02"></line><line x1="24.42" y1="7.02" x2="25.72" y2="5.71"></line><line x1="26.35" y1="8.92" x2="27.33" y2="8.04"></line><line x1="25.42" y1="9.62" x2="26.35" y2="8.92"></line><line x1="27.67" y1="12.1" x2="28.19" y2="11.79"></line><line x1="28.19" y1="11.79" x2="28.75" y2="11.41"></line><line x1="24.53" y1="10.02" x2="27.21" y2="12.27"></line><line x1="26.83" y1="12.23" x2="27.21" y2="12.27"></line><line x1="27.21" y1="12.27" x2="27.67" y2="12.1"></line><line x1="27.21" y1="12.27" x2="29.63" y2="14.73"></line><path d="M11.66,8.39l.24-.36c.13-.2.27-.64.32-.99s.09-.97.12-1.39.05-1.13.06-1.59l.02-.83"></path><path d="M19.59,3.24l.02.83c.01.46.04,1.17.06,1.59s.07,1.04.12,1.39.18.79.32.99l.24.36"></path><path d="M10.29,7.65l1-.62c.55-.34,1.83-.82,2.85-1.07s2.69-.25,3.71,0,2.3.73,2.85,1.07l1,.62"></path><path d="M2,14.97l1.66-1.43c.83-.72,2.19-1.81,3.02-2.42s1.91-1.3,2.41-1.52l.9-.41"></path><path d="M22.01,9.19l.9.41c.5.23,1.58.91,2.41,1.52s2.19,1.7,3.02,2.42l1.66,1.43"></path><path d="M9,6.21l1.9-1.66c.83-.72,2.31-1.59,3.3-1.93s2.6-.34,3.59,0,2.47,1.21,3.3,1.93l1.9,1.66"></path><path d="M2,14.97l.62-1.78c.34-.98.95-2.54,1.34-3.47s1.07-2.21,1.52-2.85,1.2-1.21,1.68-1.26,1.28.6,1.77,1.46,1.16,2.41,1.48,3.47l.59,1.9c.32,1.05.79,2.79,1.04,3.86l.81,3.53c.25,1.07.63,2.83.84,3.91l1.26,6.25"></path><path d="M17.05,30l1.26-6.25c.22-1.08.6-2.84.84-3.91l.81-3.53c.25-1.07.71-2.81,1.04-3.86l.59-1.9c.32-1.05.99-2.61,1.48-3.47s1.29-1.51,1.77-1.46,1.23.62,1.68,1.26,1.12,1.92,1.52,2.85.99,2.49,1.34,3.47l.62,1.78"></path><line x1="14.95" y1="30" x2="17.05" y2="30"></line></g><g fill="#A32FC4"><path d="M2.12,14.89c1.55-2.71,2.71-5.99,5.36-7.83.38-.27.95-.28,1.42-.26.33,0,.33.52,0,.5-.38-.01-.85-.09-1.21.15-2.64,1.71-3.92,4.86-5.57,7.45h0Z"></path><path d="M2.25,14.81c1.85-2.54,3.83-5.3,6.54-6.97.11-.08.27-.06.35.05.08.11.06.27-.05.35-.68.45-1.37.83-1.99,1.33-1.8,1.42-3.39,3.48-4.85,5.24h0Z"></path><path d="M11.33,8.08c.93,1.61,1.63,3.42,2.02,5.26,0,0,.92,5.54.92,5.54.47,3.7.85,7.41,1.21,11.12-.64-5.34-1.44-11.26-2.56-16.55-.44-1.81-1.13-3.48-2.11-5.08-.2-.34.35-.65.53-.29h0Z"></path><path d="M16.53,30.14c.36-3.71.74-7.42,1.21-11.12,0,0,.92-5.54.92-5.54.39-1.84,1.09-3.65,2.02-5.26.17-.35.72-.08.54.27-.98,1.61-1.68,3.28-2.12,5.1,0,0-1.06,5.47-1.06,5.47-.57,3.68-1.05,7.38-1.5,11.08h0Z"></path><path d="M23.09,6.79c1.08-.11,1.83.41,2.53,1.15,1.83,2.04,2.98,4.56,4.26,6.95-1.64-2.58-2.92-5.74-5.57-7.45-.36-.23-.83-.16-1.21-.15-.33.02-.34-.51,0-.5h0Z"></path><path d="M23.21,7.84c2.71,1.67,4.69,4.43,6.54,6.97-1.97-2.42-4.03-5.03-6.82-6.56-.29-.17,0-.62.28-.41h0Z"></path><path d="M8.32,5.57c.78.63,2.18,1.87,2.97,2.44.79.31,1.62.48,2.53.41.72-.04,1.45-.18,2.18-.26-.72.17-1.41.39-2.15.51-.74.1-1.49.19-2.29-.05-.4-.09-.75-.17-1.07-.43-.6-.4-2.14-1.41-2.76-1.82-.57-.39.06-1.24.6-.8h0Z"></path><path d="M16,8.16c1.58.25,3.29.5,4.77-.16.77-.63,2.23-1.85,3.01-2.49.5-.42,1.14.35.64.77-.9.59-2.43,1.59-3.31,2.17-1.73.63-3.43.16-5.1-.29h0Z"></path><path d="M18.89,21.99c-.87.49-1.83,1.02-2.85,1.06,1.01-.22,1.78-.85,2.57-1.48.27-.23.59.24.28.41h0Z"></path><path d="M16.04,16.83c1.3-.17,2.4-.88,3.32-1.78.32-.28.62-.58.93-.89.1-.1.26-.1.35,0,.11.1.1.28-.02.37-1.32,1.1-2.79,2.25-4.59,2.3h0Z"></path><path d="M22.4,8.8c-.88.81-1.77,1.69-2.84,2.27-1.08.59-2.32.7-3.52.74,1.19-.12,2.4-.31,3.4-.96.99-.63,1.79-1.54,2.61-2.4.22-.26.61.12.36.35h0Z"></path><path d="M16.37,2.39l-.38,27.61-.38-27.61c0-.49.75-.5.75,0h0Z"></path><path d="M13.43,21.58c.79.63,1.56,1.26,2.57,1.48-1.02-.04-1.98-.57-2.85-1.06-.12-.07-.17-.22-.1-.34.07-.14.26-.17.38-.07h0Z"></path><path d="M16,16.83c-1.79-.05-3.26-1.2-4.59-2.3-.11-.09-.12-.24-.04-.35.09-.12.27-.13.37-.02,1.2,1.21,2.5,2.45,4.25,2.67h0Z"></path><path d="M9.99,8.45c.82.86,1.61,1.77,2.61,2.4,1,.64,2.21.83,3.4.96-1.2-.04-2.45-.15-3.52-.74-1.07-.58-1.97-1.46-2.85-2.27-.24-.23.14-.6.36-.35h0Z"></path></g>
<g transform="translate(2.70 2.64) scale(0.989)"><rect x="18.3" y="18.36" width="12" height="12.13" fill="#ffffff" stroke="#111114" stroke-width="0.7"></rect><rect x="18.68" y="18.68" width="11.21" height="1.1" fill="url(#rvbar)"></rect><line x1="18.43" y1="20.35" x2="30.3" y2="20.35" stroke="#111114" stroke-width="0.45"></line><line x1="19.31" y1="28.52" x2="29.22" y2="28.52" stroke="#111114" stroke-width="0.45"></line><polyline points="19.31 27.03 20.82 27.03 23.38 21.7 24.86 24.87 26.64 24.87 28.59 27.39" fill="none" stroke="#111114" stroke-width="0.7" stroke-linejoin="round"></polyline></g>
</svg>
" + }, + "rendered": { + "light": { + "bytes": "iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAERlWElmTU0AKgAAAAgAAYdpAAQAAAABAAAAGgAAAAAAA6ABAAMAAAABAAEAAKACAAQAAAABAAAAGKADAAQAAAABAAAAGAAAAADiNXWtAAAEvklEQVRIDbVV3W8UVRS/c\u002Bdzd2Z3urW01CDQYqW0koYCNTGgRCoBwpekadVoa8T0ScMDD33gQR\u002BM\u002BmCixvgPEJIKfmxFAgJtWigLCbRhXWrDR21py1KgZXc7\u002BzE7c\u002B/c68zKbNZQ7fLgTW7O7577O\u002Bd358w9MwD8z4N9mvxHjhyRGxoa6MDAACk2jimGePx4z1qeFyp5VngeWRam1BoTBN\u002BdXbs2jy8Wv6hAMHhmvZyU93iAImk3zHKO4SxPDfMwSdJJ3R8PtrTsvvFfIk8IUErZkyfPbaWI8zA8TsnpQCO\u002Bz2wEVVnFnGAqACBAquai3KSUtMqyEVyq96Y1Y4XohdGdO7cNMQxjFQpyhQsHB4OnN/kzpc2ZMGkCaUi5LXDCks1VPhyIpXRsQpsjmox3Xoov80J/RvuJ7hBVD2DrSOjEiXNO8iEnjzscfn50d595TpkPbJM8ggeb1sr0FG6Mh9AWn6SmvMukpPgM1LkAk/Ut92oqV5qMX8g0G1G6LmuYKxTRy\u002BOo8Mbg4GAgn9AG/xBQFGYNZ/HS/QvaHiHAW55qPsFkIReP6AEjZkBgAsBghgKM8XwYlUHEQaEaamJAwrPh1F6VV8SZmUTNggJHj57y8zH5VWzgF1kBWigK4qQKn0e12hzNUCiqrMFIADvTlqEMC5C\u002BKpGQa5mz\u002BB5MwaWU2uVf7jPVffZ7zB88DzguWyVy3IrYJaOBNz03M5uiPbPK9KcmhyY8jewcShLePZmDaRmirIgvPvDNfYVem/2ZnZKmY\u002BeNzdCA5ceO9VS53LyAX1Hfm/vVbBIrmdvp9Y9O8l7r887ON29RyxqwJF3Qp7HiBjnYKjcNw2D629t3jYxPXf86uW6uHy4htzIh8JLP53/d5eYEnKsJR0pGUZLGzI3pvrb27d\u002B1trbmrhthyVVtLOtBcSI5QaUvex84WJ/UBX\u002BpPOz4urq6km917Pws1RC7iBJmxAyBSbdMOQHn7mrDfx6VO6132tp2fOIEuYOUJK7jElOz3ysHWUhwAgsIYpao6P7uD1654/Ic29Gx/7D3ff5DdPvRWTtn7nPyRKMVBrj4\u002B29Od5cz5SuXNpeMOb67g7M1c6l46O1DOw65nH\u002BzTzTaQkRE0LBhmvXunvEIyxiSYVUt22CXYsFDIkRndD12tygBxmtFTN3IlccR0dPI\u002BiX8I9zX8e1VTgwAVRGB3ycCnz3/xgK4cvGH4S\u002B/ONxUlIBHFkdNzUSpm1i1CGGpkk2NjoenPn53O6ipWeI\u002B2GNr2NYAvz2c1BxHUQKWkJoBghKX6mEKIySSeRCLRqf06upq0NjYCIaGhkAodBkcPPjRYxEA/H5f1lnk\u002ByC/swBwrqyJ6XjsWurZ\u002BO/ZSsjQkUJaOBwBdXVrQF9fP8hkMoVbxQnkIij9g5YZBPmzBoOtnAAhBFy7Fgb19XWguXkrEEUBdHcfdz5VeZGiSuSwVUUY1XrxaowIEJpKJ2wXPzNzD8zPJ0FLy35gtzXYsGE9qK1dDS5duvz0Ag/56SvllS\u002BcEomA5BrD\u002BYutlWUFVFRUgEgkkk/oALv\u002B\u002BXXRT3DgwIGkHdXhRkpSyWwwGOxV1YDu\u002Bgrt9PTkmN0jCzdJIXER7LX3F2w024/saf4FDc8wtXMedT4AAAAASUVORK5CYII=", + "width": 24, + "height": 24 + }, + "dark": { + "bytes": "iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAERlWElmTU0AKgAAAAgAAYdpAAQAAAABAAAAGgAAAAAAA6ABAAMAAAABAAEAAKACAAQAAAABAAAAGKADAAQAAAABAAAAGAAAAADiNXWtAAAEvklEQVRIDbVV3W8UVRS/c\u002Bdzd2Z3urW01CDQYqW0koYCNTGgRCoBwpekadVoa8T0ScMDD33gQR\u002BM\u002BmCixvgPEJIKfmxFAgJtWigLCbRhXWrDR21py1KgZXc7\u002BzE7c\u002B/c68zKbNZQ7fLgTW7O7577O\u002Bd358w9MwD8z4N9mvxHjhyRGxoa6MDAACk2jimGePx4z1qeFyp5VngeWRam1BoTBN\u002BdXbs2jy8Wv6hAMHhmvZyU93iAImk3zHKO4SxPDfMwSdJJ3R8PtrTsvvFfIk8IUErZkyfPbaWI8zA8TsnpQCO\u002Bz2wEVVnFnGAqACBAquai3KSUtMqyEVyq96Y1Y4XohdGdO7cNMQxjFQpyhQsHB4OnN/kzpc2ZMGkCaUi5LXDCks1VPhyIpXRsQpsjmox3Xoov80J/RvuJ7hBVD2DrSOjEiXNO8iEnjzscfn50d595TpkPbJM8ggeb1sr0FG6Mh9AWn6SmvMukpPgM1LkAk/Ut92oqV5qMX8g0G1G6LmuYKxTRy\u002BOo8Mbg4GAgn9AG/xBQFGYNZ/HS/QvaHiHAW55qPsFkIReP6AEjZkBgAsBghgKM8XwYlUHEQaEaamJAwrPh1F6VV8SZmUTNggJHj57y8zH5VWzgF1kBWigK4qQKn0e12hzNUCiqrMFIADvTlqEMC5C\u002BKpGQa5mz\u002BB5MwaWU2uVf7jPVffZ7zB88DzguWyVy3IrYJaOBNz03M5uiPbPK9KcmhyY8jewcShLePZmDaRmirIgvPvDNfYVem/2ZnZKmY\u002BeNzdCA5ceO9VS53LyAX1Hfm/vVbBIrmdvp9Y9O8l7r887ON29RyxqwJF3Qp7HiBjnYKjcNw2D629t3jYxPXf86uW6uHy4htzIh8JLP53/d5eYEnKsJR0pGUZLGzI3pvrb27d\u002B1trbmrhthyVVtLOtBcSI5QaUvex84WJ/UBX\u002BpPOz4urq6km917Pws1RC7iBJmxAyBSbdMOQHn7mrDfx6VO6132tp2fOIEuYOUJK7jElOz3ysHWUhwAgsIYpao6P7uD1654/Ic29Gx/7D3ff5DdPvRWTtn7nPyRKMVBrj4\u002B29Od5cz5SuXNpeMOb67g7M1c6l46O1DOw65nH\u002BzTzTaQkRE0LBhmvXunvEIyxiSYVUt22CXYsFDIkRndD12tygBxmtFTN3IlccR0dPI\u002BiX8I9zX8e1VTgwAVRGB3ycCnz3/xgK4cvGH4S\u002B/ONxUlIBHFkdNzUSpm1i1CGGpkk2NjoenPn53O6ipWeI\u002B2GNr2NYAvz2c1BxHUQKWkJoBghKX6mEKIySSeRCLRqf06upq0NjYCIaGhkAodBkcPPjRYxEA/H5f1lnk\u002ByC/swBwrqyJ6XjsWurZ\u002BO/ZSsjQkUJaOBwBdXVrQF9fP8hkMoVbxQnkIij9g5YZBPmzBoOtnAAhBFy7Fgb19XWguXkrEEUBdHcfdz5VeZGiSuSwVUUY1XrxaowIEJpKJ2wXPzNzD8zPJ0FLy35gtzXYsGE9qK1dDS5duvz0Ag/56SvllS\u002BcEomA5BrD\u002BYutlWUFVFRUgEgkkk/oALv\u002B\u002BXXRT3DgwIGkHdXhRkpSyWwwGOxV1YDu\u002Bgrt9PTkmN0jCzdJIXER7LX3F2w024/saf4FDc8wtXMedT4AAAAASUVORK5CYII=", + "width": 24, + "height": 24 + } + } + } + }, + { + "id": "b4188b27-d157-4b8c-bd8e-7f8543ccaa93", + "language": { + "id": "*.*.python", + "version": "3.*.*" + }, + "title": "RV_dem_blocks", + "uri": "commands/RV_dem_blocks.py", + "image": { + "light": { + "type": "svg", + "data": "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" + } + } + }, { "id": "3bf1a0c6-b98e-4123-b989-bc1e206b7b87", "language": { @@ -421,6 +505,21 @@ } } }, + { + "id": "04e977e4-9c76-46a1-8378-a7d5eb00a25a", + "language": { + "id": "*.*.python", + "version": "3.*.*" + }, + "title": "RV_thrust_info", + "uri": "commands/RV_thrust_info.py", + "image": { + "light": { + "type": "svg", + "data": "<svg xmlns="http://www.w3.org/2000/svg" viewBox="-3 -3 38 38" width="32" height="32"><g transform="translate(-0.800 -1.180) scale(1.05)" opacity=".22"><polygon fill="#D8D8DE" points="29.89 15.1 28.64 11.54 27.22 8.17 25.61 5.84 23.86 5.65 23.4 6.45 23.12 6.66 22.89 6.34 19.48 3.37 15.89 2.13 12.3 3.37 8.89 6.34 8.66 6.65 8.37 6.43 7.92 5.65 6.17 5.84 4.56 8.17 3.14 11.54 1.89 15.1 5.06 12.36 8.07 10.13 9.87 9.32 11.47 14.48 13.18 21.92 14.84 30.13 16.94 30.13 18.6 21.92 20.31 14.48 21.91 9.32 23.71 10.13 26.72 12.36 29.89 15.1"></polygon></g><g transform="translate(0.800 1.180) scale(0.95)" opacity=".22"><polygon fill="#D8D8DE" points="29.89 15.1 28.64 11.54 27.22 8.17 25.61 5.84 23.86 5.65 23.4 6.45 23.12 6.66 22.89 6.34 19.48 3.37 15.89 2.13 12.3 3.37 8.89 6.34 8.66 6.65 8.37 6.43 7.92 5.65 6.17 5.84 4.56 8.17 3.14 11.54 1.89 15.1 5.06 12.36 8.07 10.13 9.87 9.32 11.47 14.48 13.18 21.92 14.84 30.13 16.94 30.13 18.6 21.92 20.31 14.48 21.91 9.32 23.71 10.13 26.72 12.36 29.89 15.1"></polygon></g><g opacity=".5"><g fill="none" stroke="#A32FC4" stroke-width="0.3" stroke-linecap="round"><line x1="2.62" y1="14.56" x2="3.39" y2="13.84"></line><line x1="2.74" y1="14.48" x2="3.03" y2="14.17"></line><line x1="2.62" y1="14.56" x2="2.74" y2="14.48"></line><line x1="8.98" y1="6.52" x2="9" y2="6.21"></line><line x1="2.86" y1="14.4" x2="3.04" y2="14.17"></line><line x1="2.74" y1="14.48" x2="2.86" y2="14.4"></line><line x1="8.86" y1="6.39" x2="9" y2="6.21"></line><line x1="2.98" y1="14.32" x2="3.17" y2="14.05"></line><line x1="2.86" y1="14.4" x2="2.98" y2="14.32"></line><line x1="28.61" y1="13.84" x2="28.89" y2="14.11"></line><line x1="29.26" y1="14.48" x2="29.38" y2="14.56"></line><line x1="28.97" y1="14.17" x2="29.26" y2="14.48"></line><line x1="29.14" y1="14.4" x2="29.26" y2="14.48"></line><line x1="28.96" y1="14.17" x2="29.14" y2="14.4"></line><line x1="29.02" y1="14.32" x2="29.14" y2="14.4"></line><line x1="28.83" y1="14.05" x2="29.02" y2="14.32"></line><line x1="23" y1="6.21" x2="23.14" y2="6.39"></line><line x1="23" y1="6.21" x2="23.02" y2="6.52"></line><line x1="3.25" y1="11.41" x2="3.81" y2="11.79"></line><line x1="2" y1="14.97" x2="2.12" y2="14.89"></line><line x1="4.67" y1="8.04" x2="5.65" y2="8.92"></line><line x1="5.65" y1="8.92" x2="6.58" y2="9.62"></line><line x1="3.81" y1="11.79" x2="4.33" y2="12.1"></line><line x1="2.12" y1="14.89" x2="2.25" y2="14.81"></line><line x1="6.28" y1="5.71" x2="7.58" y2="7.02"></line><line x1="8.93" y1="8.04" x2="9.51" y2="8.09"></line><line x1="7.58" y1="7.02" x2="8.93" y2="8.04"></line><line x1="8.93" y1="8.04" x2="9.61" y2="8.28"></line><line x1="7.47" y1="10.02" x2="9.87" y2="8.82"></line><line x1="6.58" y1="9.62" x2="7.47" y2="10.02"></line><line x1="7.47" y1="10.02" x2="8.18" y2="10"></line><line x1="4.33" y1="12.1" x2="4.79" y2="12.27"></line><line x1="2.37" y1="14.73" x2="4.79" y2="12.27"></line><line x1="2.25" y1="14.81" x2="2.37" y2="14.73"></line><line x1="4.79" y1="12.27" x2="7.47" y2="10.02"></line><line x1="4.79" y1="12.27" x2="5.17" y2="12.23"></line><line x1="2.37" y1="14.73" x2="2.49" y2="14.64"></line><line x1="14.95" y1="30" x2="15.21" y2="30"></line><line x1="15.21" y1="30" x2="15.47" y2="30"></line><line x1="15.47" y1="30" x2="15.74" y2="30"></line><line x1="15.74" y1="30" x2="16" y2="30"></line><line x1="16" y1="30" x2="16.26" y2="30"></line><line x1="16.26" y1="30" x2="16.53" y2="30"></line><line x1="16.53" y1="30" x2="16.79" y2="30"></line><line x1="16.79" y1="30" x2="17.05" y2="30"></line><line x1="22.49" y1="8.09" x2="23.07" y2="8.04"></line><line x1="22.39" y1="8.28" x2="23.07" y2="8.04"></line><line x1="24.53" y1="10.02" x2="25.42" y2="9.62"></line><line x1="22.13" y1="8.82" x2="24.53" y2="10.02"></line><line x1="23.82" y1="10" x2="24.53" y2="10.02"></line><line x1="23.07" y1="8.04" x2="24.42" y2="7.02"></line><line x1="24.42" y1="7.02" x2="25.72" y2="5.71"></line><line x1="26.35" y1="8.92" x2="27.33" y2="8.04"></line><line x1="25.42" y1="9.62" x2="26.35" y2="8.92"></line><line x1="27.67" y1="12.1" x2="28.19" y2="11.79"></line><line x1="28.19" y1="11.79" x2="28.75" y2="11.41"></line><line x1="24.53" y1="10.02" x2="27.21" y2="12.27"></line><line x1="26.83" y1="12.23" x2="27.21" y2="12.27"></line><line x1="27.21" y1="12.27" x2="27.67" y2="12.1"></line><line x1="27.21" y1="12.27" x2="29.63" y2="14.73"></line><path d="M11.66,8.39l.24-.36c.13-.2.27-.64.32-.99s.09-.97.12-1.39.05-1.13.06-1.59l.02-.83"></path><path d="M19.59,3.24l.02.83c.01.46.04,1.17.06,1.59s.07,1.04.12,1.39.18.79.32.99l.24.36"></path><path d="M10.29,7.65l1-.62c.55-.34,1.83-.82,2.85-1.07s2.69-.25,3.71,0,2.3.73,2.85,1.07l1,.62"></path><path d="M2,14.97l1.66-1.43c.83-.72,2.19-1.81,3.02-2.42s1.91-1.3,2.41-1.52l.9-.41"></path><path d="M22.01,9.19l.9.41c.5.23,1.58.91,2.41,1.52s2.19,1.7,3.02,2.42l1.66,1.43"></path><path d="M9,6.21l1.9-1.66c.83-.72,2.31-1.59,3.3-1.93s2.6-.34,3.59,0,2.47,1.21,3.3,1.93l1.9,1.66"></path><path d="M2,14.97l.62-1.78c.34-.98.95-2.54,1.34-3.47s1.07-2.21,1.52-2.85,1.2-1.21,1.68-1.26,1.28.6,1.77,1.46,1.16,2.41,1.48,3.47l.59,1.9c.32,1.05.79,2.79,1.04,3.86l.81,3.53c.25,1.07.63,2.83.84,3.91l1.26,6.25"></path><path d="M17.05,30l1.26-6.25c.22-1.08.6-2.84.84-3.91l.81-3.53c.25-1.07.71-2.81,1.04-3.86l.59-1.9c.32-1.05.99-2.61,1.48-3.47s1.29-1.51,1.77-1.46,1.23.62,1.68,1.26,1.12,1.92,1.52,2.85.99,2.49,1.34,3.47l.62,1.78"></path><line x1="14.95" y1="30" x2="17.05" y2="30"></line></g><g fill="#A32FC4"><path d="M2.12,14.89c1.55-2.71,2.71-5.99,5.36-7.83.38-.27.95-.28,1.42-.26.33,0,.33.52,0,.5-.38-.01-.85-.09-1.21.15-2.64,1.71-3.92,4.86-5.57,7.45h0Z"></path><path d="M2.25,14.81c1.85-2.54,3.83-5.3,6.54-6.97.11-.08.27-.06.35.05.08.11.06.27-.05.35-.68.45-1.37.83-1.99,1.33-1.8,1.42-3.39,3.48-4.85,5.24h0Z"></path><path d="M11.33,8.08c.93,1.61,1.63,3.42,2.02,5.26,0,0,.92,5.54.92,5.54.47,3.7.85,7.41,1.21,11.12-.64-5.34-1.44-11.26-2.56-16.55-.44-1.81-1.13-3.48-2.11-5.08-.2-.34.35-.65.53-.29h0Z"></path><path d="M16.53,30.14c.36-3.71.74-7.42,1.21-11.12,0,0,.92-5.54.92-5.54.39-1.84,1.09-3.65,2.02-5.26.17-.35.72-.08.54.27-.98,1.61-1.68,3.28-2.12,5.1,0,0-1.06,5.47-1.06,5.47-.57,3.68-1.05,7.38-1.5,11.08h0Z"></path><path d="M23.09,6.79c1.08-.11,1.83.41,2.53,1.15,1.83,2.04,2.98,4.56,4.26,6.95-1.64-2.58-2.92-5.74-5.57-7.45-.36-.23-.83-.16-1.21-.15-.33.02-.34-.51,0-.5h0Z"></path><path d="M23.21,7.84c2.71,1.67,4.69,4.43,6.54,6.97-1.97-2.42-4.03-5.03-6.82-6.56-.29-.17,0-.62.28-.41h0Z"></path><path d="M8.32,5.57c.78.63,2.18,1.87,2.97,2.44.79.31,1.62.48,2.53.41.72-.04,1.45-.18,2.18-.26-.72.17-1.41.39-2.15.51-.74.1-1.49.19-2.29-.05-.4-.09-.75-.17-1.07-.43-.6-.4-2.14-1.41-2.76-1.82-.57-.39.06-1.24.6-.8h0Z"></path><path d="M16,8.16c1.58.25,3.29.5,4.77-.16.77-.63,2.23-1.85,3.01-2.49.5-.42,1.14.35.64.77-.9.59-2.43,1.59-3.31,2.17-1.73.63-3.43.16-5.1-.29h0Z"></path><path d="M18.89,21.99c-.87.49-1.83,1.02-2.85,1.06,1.01-.22,1.78-.85,2.57-1.48.27-.23.59.24.28.41h0Z"></path><path d="M16.04,16.83c1.3-.17,2.4-.88,3.32-1.78.32-.28.62-.58.93-.89.1-.1.26-.1.35,0,.11.1.1.28-.02.37-1.32,1.1-2.79,2.25-4.59,2.3h0Z"></path><path d="M22.4,8.8c-.88.81-1.77,1.69-2.84,2.27-1.08.59-2.32.7-3.52.74,1.19-.12,2.4-.31,3.4-.96.99-.63,1.79-1.54,2.61-2.4.22-.26.61.12.36.35h0Z"></path><path d="M16.37,2.39l-.38,27.61-.38-27.61c0-.49.75-.5.75,0h0Z"></path><path d="M13.43,21.58c.79.63,1.56,1.26,2.57,1.48-1.02-.04-1.98-.57-2.85-1.06-.12-.07-.17-.22-.1-.34.07-.14.26-.17.38-.07h0Z"></path><path d="M16,16.83c-1.79-.05-3.26-1.2-4.59-2.3-.11-.09-.12-.24-.04-.35.09-.12.27-.13.37-.02,1.2,1.21,2.5,2.45,4.25,2.67h0Z"></path><path d="M9.99,8.45c.82.86,1.61,1.77,2.61,2.4,1,.64,2.21.83,3.4.96-1.2-.04-2.45-.15-3.52-.74-1.07-.58-1.97-1.46-2.85-2.27-.24-.23.14-.6.36-.35h0Z"></path></g></g><g><line x1="18.6" y1="18.6" x2="30.5" y2="30.5" stroke="#ffffff" stroke-width="5.4" stroke-linecap="round"></line><circle cx="13" cy="13" r="9.2" fill="none" stroke="#ffffff" stroke-width="5"></circle><circle cx="13" cy="13" r="9.2" fill="#ffffff" fill-opacity="0.28" stroke="#111114" stroke-width="2.1"></circle><line x1="19.2" y1="19.2" x2="30" y2="30" stroke="#111114" stroke-width="3.2" stroke-linecap="round"></line></g></svg>" + } + } + }, { "id": "2046fcd3-8377-4c58-b672-8507fdb9b064", "language": { @@ -529,6 +628,21 @@ } } }, + { + "id": "82655369-f673-4500-9cae-0395ad799563", + "language": { + "id": "*.*.python", + "version": "3.*.*" + }, + "title": "RV_session_export", + "uri": "commands/RV_session_export.py", + "image": { + "light": { + "type": "svg", + "data": "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" + } + } + }, { "id": "65337e9c-96b6-4cc3-a257-7a6ae95ddcd9", "language": { @@ -609,42 +723,6 @@ } } } - }, - { - "id": "82655369-f673-4500-9cae-0395ad799563", - "language": { - "id": "*.*.python", - "version": "3.*.*" - }, - "title": "RV_session_export", - "uri": "commands/RV_session_export.py" - }, - { - "id": "04e977e4-9c76-46a1-8378-a7d5eb00a25a", - "language": { - "id": "*.*.python", - "version": "3.*.*" - }, - "title": "RV_thrust_info", - "uri": "commands/RV_thrust_info.py" - }, - { - "id": "b4188b27-d157-4b8c-bd8e-7f8543ccaa93", - "language": { - "id": "*.*.python", - "version": "3.*.*" - }, - "title": "RV_dem_blocks", - "uri": "commands/RV_dem_blocks.py" - }, - { - "id": "f2ffb9b6-2616-48a2-818b-9d512ac0a3f3", - "language": { - "id": "*.*.python", - "version": "3.*.*" - }, - "title": "RV_form_solve", - "uri": "commands/RV_form_solve.py" } ], "resources": [ @@ -661,4 +739,4 @@ "uri": "resources/splash/compas-RV_dark.jpg" } ] -} \ No newline at end of file +} diff --git a/requirements.txt b/requirements.txt index b12943f..f5e5780 100644 --- a/requirements.txt +++ b/requirements.txt @@ -6,5 +6,6 @@ compas_rui >=0.5.1 compas_session >=0.5.5 compas_skeleton compas_tna >=0.5 +compas_tno >=0.4.0 compas_triangle >=1.2.1 tessagon diff --git a/resources/icons/RV_blockexport.svg b/resources/icons/RV_blockexport.svg new file mode 100644 index 0000000..0971211 --- /dev/null +++ b/resources/icons/RV_blockexport.svg @@ -0,0 +1,37 @@ + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/resources/icons/RV_envelope.svg b/resources/icons/RV_envelope.svg new file mode 100644 index 0000000..e917679 --- /dev/null +++ b/resources/icons/RV_envelope.svg @@ -0,0 +1,205 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/resources/icons/RV_export.svg b/resources/icons/RV_export.svg new file mode 100644 index 0000000..b0263b9 --- /dev/null +++ b/resources/icons/RV_export.svg @@ -0,0 +1,64 @@ + + + + + + + + + + + + + + + + + + + + + diff --git a/resources/icons/RV_loads.svg b/resources/icons/RV_loads.svg new file mode 100644 index 0000000..982f133 --- /dev/null +++ b/resources/icons/RV_loads.svg @@ -0,0 +1,229 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/resources/icons/RV_thrust_inspect.svg b/resources/icons/RV_thrust_inspect.svg new file mode 100644 index 0000000..6400f24 --- /dev/null +++ b/resources/icons/RV_thrust_inspect.svg @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/resources/icons/RV_tno.svg b/resources/icons/RV_tno.svg new file mode 100644 index 0000000..84265cd --- /dev/null +++ b/resources/icons/RV_tno.svg @@ -0,0 +1,10 @@ + + + + + + + + + + \ No newline at end of file diff --git a/src/compas_rv/conventions.py b/src/compas_rv/conventions.py new file mode 100644 index 0000000..8dd14b1 --- /dev/null +++ b/src/compas_rv/conventions.py @@ -0,0 +1,19 @@ +VERTEX_ATTRIBUTES = ["px", "py", "pz", "pzext", "_rx", "_ry", "_rz"] +EDGE_ATTRIBUTES = ["q", "_f"] + + +def invert_formdiagram_signs(formdiagram): + """Invert the equilibrium sign convention of a form diagram. + + Notes + ----- + Applying this function twice restores the original values. + + """ + for vertex in formdiagram.vertices(): + values = formdiagram.vertex_attributes(vertex, VERTEX_ATTRIBUTES) + formdiagram.vertex_attributes(vertex, VERTEX_ATTRIBUTES, [-value if value is not None else None for value in values]) + + for edge in formdiagram.edges_where(_is_edge=True): + values = formdiagram.edge_attributes(edge, EDGE_ATTRIBUTES) + formdiagram.edge_attributes(edge, EDGE_ATTRIBUTES, [-value if value is not None else None for value in values]) diff --git a/src/compas_rv/datastructures/__init__.py b/src/compas_rv/datastructures/__init__.py index 927c125..34e4894 100644 --- a/src/compas_rv/datastructures/__init__.py +++ b/src/compas_rv/datastructures/__init__.py @@ -1,13 +1,10 @@ -from __future__ import print_function -from __future__ import absolute_import -from __future__ import division +from __future__ import absolute_import, division, print_function -from .subdmesh import SubdMesh -from .pattern import Pattern from .diagram import Diagram -from .formdiagram import FormDiagram from .forcediagram import ForceDiagram -from .thrustdiagram import ThrustDiagram +from .formdiagram import FormDiagram +from .pattern import Pattern +from .subdmesh import SubdMesh __all__ = [ "SubdMesh", @@ -15,5 +12,4 @@ "Diagram", "FormDiagram", "ForceDiagram", - "ThrustDiagram", ] diff --git a/src/compas_rv/datastructures/formdiagram.py b/src/compas_rv/datastructures/formdiagram.py index e9ceae9..e311b1f 100644 --- a/src/compas_rv/datastructures/formdiagram.py +++ b/src/compas_rv/datastructures/formdiagram.py @@ -1,4 +1,10 @@ +from compas.geometry import Box +from compas.geometry import bounding_box +from compas.geometry import centroid_points +from compas.geometry import cross_vectors +from compas.geometry import length_vector from compas.geometry import scale_vector +from compas.geometry import subtract_vectors from compas.geometry import sum_vectors from compas_fd.solvers import fd_numpy from compas_tna.diagrams import FormDiagram as BaseFormDiagram @@ -12,6 +18,17 @@ class FormDiagram(Diagram, BaseFormDiagram): Data structure for form diagrams. """ + def __init__(self, *args, **kwargs): + super().__init__(*args, **kwargs) + self.default_vertex_attributes.update( + { + "pzext": None, + "ux": 0.0, + "uy": 0.0, + "uz": 0.0, + } + ) + @classmethod def from_pattern(cls, pattern: Pattern) -> "FormDiagram": """Construct a form diagram from a pattern. @@ -97,3 +114,125 @@ def flip_cycles_if_normal_down(self): normal = scale_vector(sum_vectors(normals), scale) if normal[2] < 0: self.flip_cycles() + + def vertex_tributary_area(self, vertex: int) -> float: + """ + Compute the tributary area of a vertex taking into account only the loaded faces. + + Parameters + ---------- + vertex : int + The vertex identifier. + + Returns + ------- + float + + """ + area = 0 + p0 = self.vertex_coordinates(vertex) + for nbr in self.halfedge[vertex]: + p1 = self.vertex_coordinates(nbr) + v1 = subtract_vectors(p1, p0) + fkey = self.halfedge[vertex][nbr] + if fkey is not None: + if self.face_attribute(fkey, "_is_loaded"): + p2 = self.face_centroid(fkey) + v2 = subtract_vectors(p2, p0) + area += length_vector(cross_vectors(v1, v2)) + fkey = self.halfedge[nbr][vertex] + if fkey is not None: + if self.face_attribute(fkey, "_is_loaded"): + p3 = self.face_centroid(fkey) + v3 = subtract_vectors(p3, p0) + area += length_vector(cross_vectors(v1, v3)) + return 0.25 * area + + def vertex_lumped_stress(self, vertex: int) -> float: + """ + Compute an approximation of the compressive stress at a vertex. + + Parameters + ---------- + vertex : int + The vertex identifier. + + Returns + ------- + float + + """ + stress = 0 + neighbors = self.vertex_neighbors(vertex) + count = 0 + for nbr in neighbors: + edge_area = 0 + edge_thickness = sum(self.vertices_attribute("t", keys=[vertex, nbr])) / 2 + edge_force = self.edge_attribute((vertex, nbr), "_f") + + if abs(edge_force) <= 0: + continue + + mp = self.edge_midpoint((vertex, nbr)) + + f0 = self.halfedge_face((vertex, nbr)) + if f0 is not None: + if self.face_attribute(f0, "_is_loaded"): + f0_c = self.face_center(f0) + area = length_vector(subtract_vectors(f0_c, mp)) * edge_thickness + if area > 0: + edge_area += area + f1 = self.halfedge_face((nbr, vertex)) + if f1 is not None: + if self.face_attribute(f1, "_is_loaded"): + f1_c = self.face_center(f1) + area = length_vector(subtract_vectors(f1_c, mp)) * edge_thickness + if area > 0: + edge_area += area + + if edge_area > 0: + stress += edge_force / edge_area + count += 1 + + return stress / count + + def find_outward_displacement(self, vertices: list[int]) -> dict[int, list[float]]: + """Compute unit horizontal displacement vectors pointing away from the centroid of the supports. + + Parameters + ---------- + vertices : list[int] + The vertices for which to compute an outward displacement direction. + + Returns + ------- + dict[int, list[float]] + Mapping from vertex identifier to a unit ``[ux, uy, 0.0]`` vector pointing + away from the centroid of the diagram's supports, in the XY plane. + + """ + supports = list(self.supports()) + centroid = centroid_points(self.vertices_attributes("xyz", keys=supports)) + + directions = {} + for vertex in vertices: + x, y, _ = self.vertex_attributes(vertex, "xyz") # type: ignore + vector = [x - centroid[0], y - centroid[1], 0.0] + length = length_vector(vector) + if length > 1e-9: + vector = scale_vector(vector, 1.0 / length) + directions[vertex] = vector + return directions + + def compute_zmax(self) -> float: + """Compute a suitable value for zmax based on the length of the diagonal of the bounding box of the projection of the diagram in XY. + + Returns + ------- + float + Maximum Z coordinate. + + """ + bbox = Box.from_bounding_box(bounding_box(self.vertices_attributes("xyz"))) + diagonal = bbox.points[2] - bbox.points[0] + return 0.25 * diagonal.length diff --git a/src/compas_rv/datastructures/thrustdiagram.py b/src/compas_rv/datastructures/thrustdiagram.py deleted file mode 100644 index fa16ec7..0000000 --- a/src/compas_rv/datastructures/thrustdiagram.py +++ /dev/null @@ -1,105 +0,0 @@ -from compas.geometry import Box -from compas.geometry import bounding_box -from compas.geometry import cross_vectors -from compas.geometry import length_vector -from compas.geometry import subtract_vectors - -from .formdiagram import FormDiagram - - -class ThrustDiagram(FormDiagram): - """Data structure for thrust diagrams.""" - - def vertex_tributary_area(self, vertex: int) -> float: - """ - Compute the tributary area of a vertex taking into account only the loaded faces. - - Parameters - ---------- - vertex : int - The vertex identifier. - - Returns - ------- - float - - """ - area = 0 - p0 = self.vertex_coordinates(vertex) - for nbr in self.halfedge[vertex]: - p1 = self.vertex_coordinates(nbr) - v1 = subtract_vectors(p1, p0) - fkey = self.halfedge[vertex][nbr] - if fkey is not None: - if self.face_attribute(fkey, "_is_loaded"): - p2 = self.face_centroid(fkey) - v2 = subtract_vectors(p2, p0) - area += length_vector(cross_vectors(v1, v2)) - fkey = self.halfedge[nbr][vertex] - if fkey is not None: - if self.face_attribute(fkey, "_is_loaded"): - p3 = self.face_centroid(fkey) - v3 = subtract_vectors(p3, p0) - area += length_vector(cross_vectors(v1, v3)) - return 0.25 * area - - def vertex_lumped_stress(self, vertex: int) -> float: - """ - Compute an approximation of the compressive stress at a vertex. - - Parameters - ---------- - vertex : int - The vertex identifier. - - Returns - ------- - float - - """ - stress = 0 - neighbors = self.vertex_neighbors(vertex) - count = 0 - for nbr in neighbors: - edge_area = 0 - edge_thickness = sum(self.vertices_attribute("t", keys=[vertex, nbr])) / 2 - edge_force = self.edge_attribute((vertex, nbr), "_f") - - if abs(edge_force) <= 0: - continue - - mp = self.edge_midpoint((vertex, nbr)) - - f0 = self.halfedge_face((vertex, nbr)) - if f0 is not None: - if self.face_attribute(f0, "_is_loaded"): - f0_c = self.face_center(f0) - area = length_vector(subtract_vectors(f0_c, mp)) * edge_thickness - if area > 0: - edge_area += area - f1 = self.halfedge_face((nbr, vertex)) - if f1 is not None: - if self.face_attribute(f1, "_is_loaded"): - f1_c = self.face_center(f1) - area = length_vector(subtract_vectors(f1_c, mp)) * edge_thickness - if area > 0: - edge_area += area - - if edge_area > 0: - stress += edge_force / edge_area - count += 1 - - return stress / count - - def compute_zmax(self) -> float: - """Compute a suitable value for zmax based on the length of the diagonal of the bounding box of the projection of the diagram in XY. - - Returns - ------- - float - Maximum Z coordinate. - - """ - bbox = Box.from_bounding_box(bounding_box(self.vertices_attributes("xyz"))) - diagonal = bbox.points[2] - bbox.points[0] - return 0.25 * diagonal.length diff --git a/src/compas_rv/patterns/__init__.py b/src/compas_rv/patterns/__init__.py deleted file mode 100644 index e69de29..0000000 diff --git a/src/compas_rv/patterns/circular.py b/src/compas_rv/patterns/circular.py deleted file mode 100644 index 3211bac..0000000 --- a/src/compas_rv/patterns/circular.py +++ /dev/null @@ -1,294 +0,0 @@ -import math - -from compas.geometry import intersection_line_line_xy -from compas_rv.datastructures import Pattern - - -def create_circular_radial_pattern( - center=[5.0, 5.0], - radius=5.0, - discretisation=[8, 20], - r_oculus=0.0, - diagonal=False, - partial_diagonal=False, -) -> Pattern: - """Construct a circular radial FormDiagram with hoops equally spaced in plan. - - Parameters - ---------- - center : list, optional - Planar coordinates of the form-diagram [xc, yc], by default [5.0, 5.0] - radius : float, optional - Radius of the form diagram, by default 5.0 - discretisation : list, optional - Number of hoops, and of parallels of the dome form diagram], by default [8, 20] - r_oculus : float, optional - Value of the radius of the oculus, if no oculus is present should be set to zero, by default 0.0 - diagonal : bool, optional - Activate diagonal in the quads, by default False - partial_diagonal : bool, optional - Activate partial diagonal in the quads, by default False - - Returns - ------- - :class:`~compas_tno.diagrams.FormDiagram` - The FormDiagram created. - - """ - - xc = center[0] - yc = center[1] - n_radial = discretisation[0] - n_spikes = discretisation[1] - theta = 2 * math.pi / n_spikes - r_div = (radius - r_oculus) / n_radial - lines = [] - - for nr in range(n_radial + 1): - for nc in range(n_spikes): - if (r_oculus + nr * r_div) > 0.0: - # Meridian Elements - xa = xc + (r_oculus + nr * r_div) * math.cos(theta * nc) - xb = xc + (r_oculus + nr * r_div) * math.cos(theta * (nc + 1)) - ya = yc + (r_oculus + nr * r_div) * math.sin(theta * nc) - yb = yc + (r_oculus + nr * r_div) * math.sin(theta * (nc + 1)) - lines.append([[xa, ya, 0.0], [xb, yb, 0.0]]) - - if nr <= n_radial - 1: - # Radial Elements - xa = xc + (r_oculus + nr * r_div) * math.cos(theta * nc) - xb = xc + (r_oculus + (nr + 1) * r_div) * math.cos(theta * nc) - ya = yc + (r_oculus + nr * r_div) * math.sin(theta * nc) - yb = yc + (r_oculus + (nr + 1) * r_div) * math.sin(theta * nc) - lines.append([[xa, ya, 0.0], [xb, yb, 0.0]]) - - if diagonal: - for nr in range(n_radial): - for nc in range(n_spikes): - if (r_oculus + nr * r_div) > 0.0: - # Meridian Element i - xa = xc + (r_oculus + nr * r_div) * math.cos(theta * nc) - xb = xc + (r_oculus + nr * r_div) * math.cos(theta * (nc + 1)) - ya = yc + (r_oculus + nr * r_div) * math.sin(theta * nc) - yb = yc + (r_oculus + nr * r_div) * math.sin(theta * (nc + 1)) - - # Meridian Element i + 1 - xa_ = xc + (r_oculus + (nr + 1) * r_div) * math.cos(theta * nc) - xb_ = xc + (r_oculus + (nr + 1) * r_div) * math.cos(theta * (nc + 1)) - ya_ = yc + (r_oculus + (nr + 1) * r_div) * math.sin(theta * nc) - yb_ = yc + (r_oculus + (nr + 1) * r_div) * math.sin(theta * (nc + 1)) - - if partial_diagonal == "right": - if nc + 1 > n_spikes / 2: - lines.append([[xa, ya, 0.0], [xb_, yb_, 0.0]]) - else: - lines.append([[xa_, ya_, 0.0], [xb, yb, 0.0]]) - elif partial_diagonal == "left": - if nc + 1 > n_spikes / 2: - lines.append([[xa_, ya_, 0.0], [xb, yb, 0.0]]) - else: - lines.append([[xa, ya, 0.0], [xb_, yb_, 0.0]]) - elif partial_diagonal == "rotation": - lines.append([[xa, ya, 0.0], [xb_, yb_, 0.0]]) - elif partial_diagonal == "straight": - midx, midy, _ = intersection_line_line_xy([[xa, ya], [xb_, yb_]], [[xa_, ya_], [xb, yb]]) # type: ignore - lines.append([[xa, ya, 0.0], [midx, midy, 0.0]]) - lines.append([[midx, midy, 0.0], [xb_, yb_, 0.0]]) - lines.append([[xa_, ya_, 0.0], [midx, midy, 0.0]]) - lines.append([[midx, midy, 0.0], [xb, yb, 0.0]]) - else: - midx = (xa + xa_ + xb + xb_) / 4 - midy = (ya + ya_ + yb + yb_) / 4 - lines.append([[xa, ya, 0.0], [midx, midy, 0.0]]) - lines.append([[midx, midy, 0.0], [xb_, yb_, 0.0]]) - lines.append([[xa_, ya_, 0.0], [midx, midy, 0.0]]) - lines.append([[midx, midy, 0.0], [xb, yb, 0.0]]) - - pattern: Pattern = Pattern.from_lines(lines, delete_boundary_face=True) # type: ignore - return pattern - - -def create_circular_radial_spaced_pattern( - center=[5.0, 5.0], - radius=5.0, - discretisation=[8, 20], - r_oculus=0.0, - diagonal=False, - partial_diagonal=False, -) -> Pattern: - """Construct a circular radial FormDiagram with hoops not equally spaced in plan, but equally spaced with regards to the projection on a hemisphere. - - Parameters - ---------- - center : list, optional - Planar coordinates of the form-diagram [xc, yc], by default [5.0, 5.0] - radius : float, optional - Radius of the form diagram, by default 5.0 - discretisation : list, optional - Number of hoops, and of parallels of the dome form diagram], by default [8, 20] - r_oculus : float, optional - Value of the radius of the oculus, if no oculus is present should be set to zero, by default 0.0 - diagonal : bool, optional - Activate diagonal in the quads, by default False - partial_diagonal : bool, optional - Activate partial diagonal in the quads, by default False - - Returns - ------- - form : :class:`~compas_tno.diagrams.FormDiagram` - The FormDiagram created. - - """ - xc = center[0] - yc = center[1] - n_radial = discretisation[0] - n_spikes = discretisation[1] - theta = 2 * math.pi / n_spikes - r_div = (radius - r_oculus) / n_radial - lines = [] - - for nr in range(n_radial + 1): - for nc in range(n_spikes): - if (r_oculus + nr) > 0: - # Meridian Elements - xa = xc + (r_oculus + radius * math.cos((n_radial - nr) / n_radial * math.pi / 2)) * math.cos(theta * nc) - xb = xc + (r_oculus + radius * math.cos((n_radial - nr) / n_radial * math.pi / 2)) * math.cos(theta * (nc + 1)) - ya = yc + (r_oculus + radius * math.cos((n_radial - nr) / n_radial * math.pi / 2)) * math.sin(theta * nc) - yb = yc + (r_oculus + radius * math.cos((n_radial - nr) / n_radial * math.pi / 2)) * math.sin(theta * (nc + 1)) - lines.append([[xa, ya, 0.0], [xb, yb, 0.0]]) - - if nr <= n_radial - 1: - # Radial Elements - xa = xc + (r_oculus + radius * math.cos((n_radial - nr) / n_radial * math.pi / 2)) * math.cos(theta * nc) - xb = xc + (r_oculus + radius * math.cos((n_radial - (nr + 1)) / n_radial * math.pi / 2)) * math.cos(theta * nc) - ya = yc + (r_oculus + radius * math.cos((n_radial - nr) / n_radial * math.pi / 2)) * math.sin(theta * nc) - yb = yc + (r_oculus + radius * math.cos((n_radial - (nr + 1)) / n_radial * math.pi / 2)) * math.sin(theta * nc) - lines.append([[xa, ya, 0.0], [xb, yb, 0.0]]) - - if diagonal: - for nr in range(n_radial): - for nc in range(n_spikes): - if (r_oculus + nr * r_div) > 0.0: - # Meridian Element i - xa = xc + (r_oculus + radius * math.cos((n_radial - nr) / n_radial * math.pi / 2)) * math.cos(theta * nc) - xb = xc + (r_oculus + radius * math.cos((n_radial - nr) / n_radial * math.pi / 2)) * math.cos(theta * (nc + 1)) - ya = yc + (r_oculus + radius * math.cos((n_radial - nr) / n_radial * math.pi / 2)) * math.sin(theta * nc) - yb = yc + (r_oculus + radius * math.cos((n_radial - nr) / n_radial * math.pi / 2)) * math.sin(theta * (nc + 1)) - - # radius * math.cos((n_radial - (nr + 1)) / n_radial * math.pi / 2) - - # Meridian Element i + 1 - xa_ = xc + (r_oculus + radius * math.cos((n_radial - (nr + 1)) / n_radial * math.pi / 2)) * math.cos(theta * nc) - xb_ = xc + (r_oculus + radius * math.cos((n_radial - (nr + 1)) / n_radial * math.pi / 2)) * math.cos(theta * (nc + 1)) - ya_ = yc + (r_oculus + radius * math.cos((n_radial - (nr + 1)) / n_radial * math.pi / 2)) * math.sin(theta * nc) - yb_ = yc + (r_oculus + radius * math.cos((n_radial - (nr + 1)) / n_radial * math.pi / 2)) * math.sin(theta * (nc + 1)) - if partial_diagonal == "right": - if nc + 1 > n_spikes / 2: - lines.append([[xa, ya, 0.0], [xb_, yb_, 0.0]]) - else: - lines.append([[xa_, ya_, 0.0], [xb, yb, 0.0]]) - elif partial_diagonal == "left": - if nc + 1 > n_spikes / 2: - lines.append([[xa_, ya_, 0.0], [xb, yb, 0.0]]) - else: - lines.append([[xa, ya, 0.0], [xb_, yb_, 0.0]]) - elif partial_diagonal == "straight": - midx, midy, _ = intersection_line_line_xy([[xa, ya], [xb_, yb_]], [[xa_, ya_], [xb, yb]]) # type: ignore - lines.append([[xa, ya, 0.0], [midx, midy, 0.0]]) - lines.append([[midx, midy, 0.0], [xb_, yb_, 0.0]]) - lines.append([[xa_, ya_, 0.0], [midx, midy, 0.0]]) - lines.append([[midx, midy, 0.0], [xb, yb, 0.0]]) - else: - midx = (xa + xa_ + xb + xb_) / 4 - midy = (ya + ya_ + yb + yb_) / 4 - lines.append([[xa, ya, 0.0], [midx, midy, 0.0]]) - lines.append([[midx, midy, 0.0], [xb_, yb_, 0.0]]) - lines.append([[xa_, ya_, 0.0], [midx, midy, 0.0]]) - lines.append([[midx, midy, 0.0], [xb, yb, 0.0]]) - - pattern: Pattern = Pattern.from_lines(lines, delete_boundary_face=True) # type: ignore - return pattern - - -def create_circular_spiral_pattern( - center=[5.0, 5.0], - radius=5.0, - discretisation=[8, 20], - r_oculus=0.0, -) -> Pattern: - """Construct a circular radial FormDiagram with hoops not equally spaced in plan, but equally spaced with regards to the projection on a hemisphere. - - Parameters - ---------- - center : list, optional - Planar coordinates of the form-diagram [xc, yc], by default [5.0, 5.0] - radius : float, optional - Radius of the form diagram, by default 5.0 - discretisation : list, optional - Number of hoops, and of parallels of the dome form diagram], by default [8, 20] - r_oculus : float, optional - Value of the radius of the oculus, if no oculus is present should be set to zero, by default 0.0 - - Returns - ------- - :class:`~compas_tno.diagrams.FormDiagram` - The FormDiagram created. - - """ - xc = center[0] - yc = center[1] - n_radial = discretisation[0] - n_spikes = discretisation[1] - theta = 2 * math.pi / n_spikes - r_div = (radius - r_oculus) / n_radial - lines = [] - - for nr in range(n_radial + 1): - for nc in range(n_spikes): - if nr > 0.0: # This avoid the center... - if nr % 2 == 0: - # Diagonal to Up - xa = xc + (r_oculus + nr * r_div) * math.cos(theta * nc) - xb = xc + (r_oculus + (nr - 1) * r_div) * math.cos(theta * (nc + 1 / 2)) - ya = yc + (r_oculus + nr * r_div) * math.sin(theta * nc) - yb = yc + (r_oculus + (nr - 1) * r_div) * math.sin(theta * (nc + 1 / 2)) - - # Diagonal to Down - xa_ = xc + (r_oculus + nr * r_div) * math.cos(theta * nc) - xb_ = xc + (r_oculus + (nr - 1) * r_div) * math.cos(theta * (nc - 1 / 2)) - ya_ = yc + (r_oculus + nr * r_div) * math.sin(theta * nc) - yb_ = yc + (r_oculus + (nr - 1) * r_div) * math.sin(theta * (nc - 1 / 2)) - - lines.append([[xa, ya, 0.0], [xb, yb, 0.0]]) - lines.append([[xa_, ya_, 0.0], [xb_, yb_, 0.0]]) - else: - # Diagonal to Up - xa = xc + (r_oculus + nr * r_div) * math.cos(theta * (nc + 1 / 2)) - xb = xc + (r_oculus + (nr - 1) * r_div) * math.cos(theta * (nc + 1)) - ya = yc + (r_oculus + nr * r_div) * math.sin(theta * (nc + 1 / 2)) - yb = yc + (r_oculus + (nr - 1) * r_div) * math.sin(theta * (nc + 1)) - - # Diagonal to Down - xa_ = xc + (r_oculus + nr * r_div) * math.cos(theta * (nc + 1 / 2)) - xb_ = xc + (r_oculus + (nr - 1) * r_div) * math.cos(theta * (nc)) - ya_ = yc + (r_oculus + nr * r_div) * math.sin(theta * (nc + 1 / 2)) - yb_ = yc + (r_oculus + (nr - 1) * r_div) * math.sin(theta * (nc)) - - lines.append([[xa, ya, 0.0], [xb, yb, 0.0]]) - lines.append([[xa_, ya_, 0.0], [xb_, yb_, 0.0]]) - if nr == n_radial: - xa = xc + (r_oculus + nr * r_div) * math.cos(theta * nc) - xb = xc + (r_oculus + nr * r_div) * math.cos(theta * (nc + 1)) - ya = yc + (r_oculus + nr * r_div) * math.sin(theta * nc) - yb = yc + (r_oculus + nr * r_div) * math.sin(theta * (nc + 1)) - lines.append([[xa, ya, 0.0], [xb, yb, 0.0]]) - if nr == 0 and r_oculus > 0.0: - # If oculus, this will be the compression ring - xa = xc + (r_oculus) * math.cos(theta * (nc)) - xb = xc + (r_oculus) * math.cos(theta * (nc + 1)) - ya = yc + (r_oculus) * math.sin(theta * (nc)) - yb = yc + (r_oculus) * math.sin(theta * (nc + 1)) - lines.append([[xa, ya, 0.0], [xb, yb, 0.0]]) - - pattern: Pattern = Pattern.from_lines(lines, delete_boundary_face=True) # type: ignore - return pattern diff --git a/src/compas_rv/patterns/rectangular.py b/src/compas_rv/patterns/rectangular.py deleted file mode 100644 index b5b5778..0000000 --- a/src/compas_rv/patterns/rectangular.py +++ /dev/null @@ -1,603 +0,0 @@ -import math - -from compas.geometry import distance_point_point_xy -from compas.geometry import mirror_points_line -from compas.geometry import rotate_points_xy -from compas_rv.datastructures import Pattern - - -def mirror_4x(line, line_hor, line_ver, lines): - """Helper to mirror an object 4 times.""" - lines.append(line) - a_mirror, b_mirror = mirror_points_line(line, line_hor) - lines.append([a_mirror, b_mirror]) - a_mirror, b_mirror = mirror_points_line([a_mirror, b_mirror], line_ver) - lines.append([a_mirror, b_mirror]) - a_mirror, b_mirror = mirror_points_line(line, line_ver) - lines.append([a_mirror, b_mirror]) - return lines - - -def mirror_8x(line, origin, line_hor, line_ver, lines): - """Helper to mirror an object 8 times.""" - lines = mirror_4x(line, line_hor, line_ver, lines) - rot = rotate_points_xy(line, math.pi / 2, origin=origin) - lines = mirror_4x(rot, line_hor, line_ver, lines) - return lines - - -def append_mirrored_lines(line, list_, line_hor, line_ver): - """Helper to mirror an object 8 times and add to the list""" - mirror_a = mirror_points_line(line, line_hor) - mirror_b = mirror_points_line(mirror_a, line_ver) - mirror_c = mirror_points_line(line, line_ver) - list_.append(mirror_a) - list_.append(mirror_b) - list_.append(mirror_c) - - -def create_cross_pattern( - xy_span=[[0.0, 10.0], [0.0, 10.0]], - discretisation=10, -) -> Pattern: - """Construct a FormDiagram based on cross discretiastion with orthogonal arrangement and diagonal. - - Parameters - ---------- - xy_span : list, optional - List with initial- and end-points of the vault, by default [[0.0, 10.0], [0.0, 10.0]] - discretisation : int, optional - Set the density of the grid in x and y directions, by default 10 - fix : str, optional - Option to select the constrained nodes: 'corners', 'all' are accepted., by default 'corners' - - Returns - ------- - :class:`~compas_tno.diagrams.FormDiagram` - The FormDiagram created. - - Notes - ---------------------- - Position of the quadrants is as in the schema below: - - Q3 - Q2 Q1 - Q4 - """ - if isinstance(discretisation, list): - discretisation = discretisation[0] - - y1 = float(xy_span[1][1]) - y0 = float(xy_span[1][0]) - x1 = float(xy_span[0][1]) - x0 = float(xy_span[0][0]) - x_span = x1 - x0 - y_span = y1 - y0 - dx = x_span / discretisation - dy = y_span / discretisation - - lines = [] - - for i in range(discretisation + 1): - for j in range(discretisation + 1): - if i < discretisation and j < discretisation: - # Vertical Members: - xa = x0 + dx * i - ya = y0 + dy * j - xb = x0 + dx * (i + 1) - yb = y0 + dy * j - # Horizontal Members: - xc = x0 + dx * i - yc = y0 + dy * j - xd = x0 + dx * i - yd = y0 + dy * (j + 1) - lines.append([[xa, ya, 0.0], [xb, yb, 0.0]]) - lines.append([[xc, yc, 0.0], [xd, yd, 0.0]]) - if i == j: - # Diagonal Members in + Direction: - xc = x0 + dx * i - yc = y0 + dy * j - xd = x0 + dx * (i + 1) - yd = y0 + dy * (j + 1) - lines.append([[xc, yc, 0.0], [xd, yd, 0.0]]) - if i + j == discretisation: - # Diagonal Members in - Direction: - xc = x0 + dx * i - yc = y0 + dy * j - xd = x0 + dx * (i - 1) - yd = y0 + dy * (j + 1) - lines.append([[xc, yc, 0.0], [xd, yd, 0.0]]) - if i == (discretisation - 1): - xc = x0 + dx * i - yc = y0 + dy * j - xd = x0 + dx * (i + 1) - yd = y0 + dy * (j - 1) - lines.append([[xc, yc, 0.0], [xd, yd, 0.0]]) - else: - if i == discretisation and j < discretisation: - # Vertical Members on last column: - xa = x0 + dx * j - ya = y0 + dy * i - xb = x0 + dx * (j + 1) - yb = y0 + dy * i - # Horizontal Members: - xc = x0 + dx * i - yc = y0 + dy * j - xd = x0 + dx * i - yd = y0 + dy * (j + 1) - lines.append([[xa, ya, 0.0], [xb, yb, 0.0]]) - lines.append([[xc, yc, 0.0], [xd, yd, 0.0]]) - - pattern: Pattern = Pattern.from_lines(lines, delete_boundary_face=True) # type: ignore - return pattern - - -def create_cross_diagonal_pattern( - xy_span=[[0.0, 10.0], [0.0, 10.0]], - partial_bracing_modules=None, - discretisation=10, -) -> Pattern: - """Construct a FormDiagram based on a mixture of cross and fan discretiastion - - Parameters - ---------- - xy_span : list, optional - List with initial- and end-points of the vault, by default [[0.0, 10.0], [0.0, 10.0]] - discretisation : int, optional - Set the density of the grid in x and y directions, by default 10 - partial_bracing_modules : str, optional - If partial bracing modules are included, by default None - fix : str, optional - Option to select the constrained nodes: 'corners', 'all' are accepted, by default 'corners' - - Returns - ------- - :class:`~compas_tno.diagrams.FormDiagram` - The FormDiagram created. - - """ - if isinstance(discretisation, list): - discretisation = discretisation[0] - - y1 = float(xy_span[1][1]) - y0 = float(xy_span[1][0]) - x1 = float(xy_span[0][1]) - x0 = float(xy_span[0][0]) - x_span = x1 - x0 - y_span = y1 - y0 - dx = x_span / discretisation - dy = y_span / discretisation - - xc0 = x0 + x_span / 2 - yc0 = y0 + y_span / 2 - - nx = ny = int(discretisation / 2) - if partial_bracing_modules is None: - nstop = 0 - else: - nstop = nx - partial_bracing_modules # Test to stop - - line_hor = [[x0, yc0, 0.0], [xc0, yc0, 0.0]] - line_ver = [[xc0, y0, 0.0], [xc0, yc0, 0.0]] - origin = [xc0, yc0, 0.0] - - lines = [] - - for i in range(nx): - for j in range(ny + 1): - if j <= i: - if i >= nstop and j >= nstop: - # Diagonal Members: - xa = x0 + dx * i - ya = y0 + dy * 1 * (i - j) / (nx - j) + dy * j - xb = x0 + dx * (i + 1) - yb = y0 + dy * 1 * (i - j + 1) / (nx - j) + dy * j - lin = [[xa, ya, 0.0], [xb, yb, 0.0]] - lines = mirror_8x(lin, origin, line_hor, line_ver, lines) - - if i == j and i < nx - 1: - # Main diagonal: - xa = x0 + dx * i - ya = y0 + dy * j - xb = x0 + dx * (i + 1) - yb = y0 + dy * (j + 1) - lin = [[xa, ya, 0.0], [xb, yb, 0.0]] - lines = mirror_4x(lin, line_hor, line_ver, lines) - - # Horizontal Members: - xa = x0 + dx * i - ya = y0 + dy * j - xb = x0 + dx * (i + 1) - yb = y0 + dy * j - lin = [[xa, ya, 0.0], [xb, yb, 0.0]] - lines = mirror_8x(lin, origin, line_hor, line_ver, lines) - - i += 1 - # Vertical Members: - xa = x0 + dx * i - ya = y0 + dy * j - xb = x0 + dx * i - yb = y0 + dy * (j + 1) - - if i >= nstop and j >= nstop: - x_ = xa - y_ = y0 + dy * 1 * (i - j) / (nx - j) + dy * j - lin = [[xa, ya, 0.0], [x_, y_, 0.0]] - lines = mirror_8x(lin, origin, line_hor, line_ver, lines) - lin = [[x_, y_, 0.0], [xb, yb, 0.0]] - lines = mirror_8x(lin, origin, line_hor, line_ver, lines) - else: - lin = [[xa, ya, 0.0], [xb, yb, 0.0]] - lines = mirror_8x(lin, origin, line_hor, line_ver, lines) - - i -= 1 - - pattern: Pattern = Pattern.from_lines(lines, delete_boundary_face=True) # type: ignore - return pattern - - -def create_cross_with_diagonal_pattern( - xy_span=[[0.0, 10.0], [0.0, 10.0]], - discretisation=10, -) -> Pattern: - """Construct a FormDiagram based on cross discretiastion with diagonals. - - Parameters - ---------- - xy_span : list, optional - List with initial- and end-points of the vault, by default [[0.0, 10.0], [0.0, 10.0]] - discretisation : int, optional - Set the density of the grid in x and y directions, by default 10 - fix : str, optional - Option to select the constrained nodes: 'corners', 'all' are accepted, by default 'corners' - - Returns - ------- - :class:`~compas_tno.diagrams.FormDiagram` - The FormDiagram created. - """ - - if isinstance(discretisation, list): - discretisation = discretisation[0] - - y1 = float(xy_span[1][1]) - y0 = float(xy_span[1][0]) - x1 = float(xy_span[0][1]) - x0 = float(xy_span[0][0]) - x_span = x1 - x0 - y_span = y1 - y0 - dx = x_span / discretisation - dy = y_span / discretisation - - lines = [] - - for i in range(discretisation + 1): - for j in range(discretisation + 1): - if i < discretisation and j < discretisation: - # Hor Members: - xa = x0 + dx * i - ya = y0 + dy * j - xb = x0 + dx * (i + 1) - yb = y0 + dy * j - # Ver Members: - xc = x0 + dx * i - yc = y0 + dy * j - xd = x0 + dx * i - yd = y0 + dy * (j + 1) - lines.append([[xa, ya, 0.0], [xb, yb, 0.0]]) - lines.append([[xc, yc, 0.0], [xd, yd, 0.0]]) - # lines.append([[xc, yc, 0.0], [xd, yd, 0.0]]) - if (i < discretisation / 2 and j < discretisation / 2) or (i >= discretisation / 2 and j >= discretisation / 2): - # Diagonal Members in + Direction: - xc = x0 + dx * i - yc = y0 + dy * j - xd = x0 + dx * (i + 1) - yd = y0 + dy * (j + 1) - lines.append([[xc, yc, 0.0], [xd, yd, 0.0]]) - else: - # Diagonal Members in - Direction: - xc = x0 + dx * i - yc = y0 + dy * (j + 1) - xd = x0 + dx * (i + 1) - yd = y0 + dy * j - lines.append([[xc, yc, 0.0], [xd, yd, 0.0]]) - # if i == (discretisation - 1): - # xc = x0 + dx*i - # yc = y0 + dy*j - # xd = x0 + dx*(i + 1) - # yd = y0 + dy*(j - 1) - # lines.append([[xc, yc, 0.0], [xd, yd, 0.0]]) - else: - if i == discretisation and j < discretisation: - # Vertical Members on last column: - xa = x0 + dx * j - ya = y0 + dy * i - xb = x0 + dx * (j + 1) - yb = y0 + dy * i - # Horizontal Members: - xc = x0 + dx * i - yc = y0 + dy * j - xd = x0 + dx * i - yd = y0 + dy * (j + 1) - lines.append([[xa, ya, 0.0], [xb, yb, 0.0]]) - lines.append([[xc, yc, 0.0], [xd, yd, 0.0]]) - - pattern: Pattern = Pattern.from_lines(lines, delete_boundary_face=True) # type: ignore - return pattern - - -def create_fan_pattern( - xy_span=[[0.0, 10.0], [0.0, 10.0]], - discretisation=[10, 10], -) -> Pattern: - """Helper to construct a FormDiagram based on fan discretiastion with straight lines to the corners. - - Parameters - ---------- - xy_span : list, optional - List with initial- and end-points of the vault, by default [[0.0, 10.0], [0.0, 10.0]] - discretisation : int, optional - Set the density of the grid in x and y directions, by default 10 - fix : str, optional - Option to select the constrained nodes: 'corners', 'all' are accepted, by default 'corners' - - Returns - ------- - :class:`~compas_tno.diagrams.FormDiagram` - The FormDiagram created. - """ - - if isinstance(discretisation, int): - discretisation = [discretisation, discretisation] - if discretisation[0] % 2 != 0 or discretisation[1] % 2 != 0: - msg = "Warning!: discretisation of this form diagram has to be even." - raise ValueError(msg) - - y1 = float(xy_span[1][1]) - y0 = float(xy_span[1][0]) - x1 = float(xy_span[0][1]) - x0 = float(xy_span[0][0]) - - x_span = x1 - x0 - y_span = y1 - y0 - xc0 = x0 + x_span / 2 - yc0 = y0 + y_span / 2 - division_x = discretisation[0] - division_y = discretisation[1] - dx = float(x_span / division_x) - dy = float(y_span / division_y) - nx = int(division_x / 2) - ny = int(division_y / 2) - line_hor = [[x0, yc0, 0.0], [xc0, yc0, 0.0]] - line_ver = [[xc0, y0, 0.0], [xc0, yc0, 0.0]] - - lines = [] - - for i in range(nx): - for j in range(ny + 1): - # Diagonal Members: - xa = x0 + dx * i - ya = y0 + dy * j * i / nx - xb = x0 + dx * (i + 1) - yb = y0 + dy * j * (i + 1) / nx - lines.append([[xa, ya, 0.0], [xb, yb, 0.0]]) - - a_mirror, b_mirror = mirror_points_line([[xa, ya, 0.0], [xb, yb, 0.0]], line_hor) - lines.append([a_mirror, b_mirror]) - a_mirror, b_mirror = mirror_points_line([a_mirror, b_mirror], line_ver) - lines.append([a_mirror, b_mirror]) - a_mirror, b_mirror = mirror_points_line([[xa, ya, 0.0], [xb, yb, 0.0]], line_ver) - lines.append([a_mirror, b_mirror]) - - xa_ = x0 + dx * j * i / nx - ya_ = y0 + dy * i - xb_ = x0 + dx * j * (i + 1) / nx - yb_ = y0 + dy * (i + 1) - lines.append([[xa_, ya_, 0.0], [xb_, yb_, 0.0]]) - - a_mirror, b_mirror = mirror_points_line([[xa_, ya_, 0.0], [xb_, yb_, 0.0]], line_hor) - lines.append([a_mirror, b_mirror]) - a_mirror, b_mirror = mirror_points_line([a_mirror, b_mirror], line_ver) - lines.append([a_mirror, b_mirror]) - a_mirror, b_mirror = mirror_points_line([[xa_, ya_, 0.0], [xb_, yb_, 0.0]], line_ver) - lines.append([a_mirror, b_mirror]) - - if j < ny: - # Vertical or Horizontal Members: - xc = x0 + dx * (i + 1) - yc = y0 + dy * j * (i + 1) / nx - xd = x0 + dx * (i + 1) - yd = y0 + dy * (j + 1) * (i + 1) / nx - lines.append([[xc, yc, 0.0], [xd, yd, 0.0]]) - - c_mirror, d_mirror = mirror_points_line([[xc, yc, 0.0], [xd, yd, 0.0]], line_hor) - lines.append([c_mirror, d_mirror]) - c_mirror, d_mirror = mirror_points_line([c_mirror, d_mirror], line_ver) - lines.append([c_mirror, d_mirror]) - c_mirror, d_mirror = mirror_points_line([[xc, yc, 0.0], [xd, yd, 0.0]], line_ver) - lines.append([c_mirror, d_mirror]) - - xc_ = x0 + dx * j * (i + 1) / nx - yc_ = y0 + dy * (i + 1) - xd_ = x0 + dx * (j + 1) * (i + 1) / nx - yd_ = y0 + dy * (i + 1) - lines.append([[xc_, yc_, 0.0], [xd_, yd_, 0.0]]) - - c_mirror, d_mirror = mirror_points_line([[xc_, yc_, 0.0], [xd_, yd_, 0.0]], line_hor) - lines.append([c_mirror, d_mirror]) - c_mirror, d_mirror = mirror_points_line([c_mirror, d_mirror], line_ver) - lines.append([c_mirror, d_mirror]) - c_mirror, d_mirror = mirror_points_line([[xc_, yc_, 0.0], [xd_, yd_, 0.0]], line_ver) - lines.append([c_mirror, d_mirror]) - - pattern: Pattern = Pattern.from_lines(lines, delete_boundary_face=True) # type: ignore - return pattern - - -def create_ortho_pattern( - xy_span=[[0.0, 10.0], [0.0, 10.0]], - discretisation=[10, 10], -) -> Pattern: - """Helper to construct a FormDiagram based on a simple orthogonal discretisation. - - Parameters - ---------- - xy_span : list, optional - List with initial- and end-points of the vault, by default [[0.0, 10.0], [0.0, 10.0]] - discretisation : int, optional - Set the density of the grid in x and y directions, by default 10 - fix : str, optional - Option to select the constrained nodes: 'corners', 'all' are accepted, by default 'corners' - - Returns - ------- - :class:`~compas_tno.diagrams.FormDiagram` - The FormDiagram created. - """ - - if isinstance(discretisation, int): - discretisation = [discretisation, discretisation] - # if discretisation[0] % 2 != 0 or discretisation[1] % 2 != 0: - # msg = "Warning!: discretisation of this form diagram has to be even." - # raise ValueError(msg) - - y1 = float(xy_span[1][1]) - y0 = float(xy_span[1][0]) - x1 = float(xy_span[0][1]) - x0 = float(xy_span[0][0]) - x_span = x1 - x0 - y_span = y1 - y0 - division_x = discretisation[0] - division_y = discretisation[1] - dx = float(x_span / division_x) - dy = float(y_span / division_y) - - vertices = [] - faces = [] - - for j in range(division_y + 1): - for i in range(division_x + 1): - xi = x0 + dx * i - yi = y0 + dy * j - vertices.append([xi, yi, 0.0]) - if i < division_x and j < division_y: - p1 = j * (division_x + 1) + i - p2 = j * (division_x + 1) + i + 1 - p3 = (j + 1) * (division_x + 1) + i + 1 - p4 = (j + 1) * (division_x + 1) + i - face = [p1, p2, p3, p4, p1] - faces.append(face) - print(face) - - pattern: Pattern = Pattern.from_vertices_and_faces(vertices, faces) # type: ignore - return pattern - - -def create_parametric_pattern( - xy_span=[[0.0, 10.0], [0.0, 10.0]], - discretisation=10, - lambd=0.5, -) -> Pattern: - """Create a parametric form diagram based on the inclination lambda of the arches - - Parameters - ---------- - xy_span : [[float, float], [float, float]], optional - List with initial- and end-points of the vault, by default, by default [[0.0, 10.0], [0.0, 10.0]] - discretisation : int, optional - Set the density of the grid in x and y directions, by default 10 - lambd : float, optional - Inclination of the arches in the diagram (0.0 will result in cross and 1.0 in fan diagrams), by default 0.5 - fix : str, optional - Option to select the constrained nodes: 'corners', 'all' are accepted, by default 'corners' - - Returns - ------- - :class:`~compas_tno.diagrams.FormDiagram` - The FormDiagram created. - - Notes - --------- - Diagram implemented after `N. A. Nodargi et al., 2022 `_. - """ - if 0.0 > lambd or lambd > 1.0: - raise ValueError("Lambda should be between 0.0 and 1.0") - - x_span = xy_span[0][1] - xy_span[0][0] - y_span = xy_span[1][1] - xy_span[1][0] - - if abs(x_span - y_span) > 1e-6: - y_span = x_span = 10.0 - x0, x1 = y0, y1 = 0.0, 10.0 - else: - x0, x1 = xy_span[0][0], xy_span[0][1] - y0, y1 = xy_span[1][0], xy_span[1][1] - - xc = (x1 + x0) / 2 - yc = (y1 + y0) / 2 - - xc0 = x0 + x_span / 2 - yc0 = y0 + y_span / 2 - division_x = discretisation - division_y = discretisation - dx = float(x_span / division_x) - dy = float(y_span / division_y) - nx = int(division_x / 2) - line_hor = [[x0, yc0, 0.0], [xc0, yc0, 0.0]] - line_ver = [[xc0, y0, 0.0], [xc0, yc0, 0.0]] - - lines = [] - - for i in range(nx + 1): - j = i - - xa = xc - ya = xc - dy * j - xb = (ya - y0) * (1 - lambd) - yb = (ya - y0) * (1 - lambd) - - if distance_point_point_xy([xa, ya], [xb, yb]): - lines.append([[xa, ya, 0.0], [xb, yb, 0.0]]) - - append_mirrored_lines([[xa, ya, 0.0], [xb, yb, 0.0]], lines, line_hor, line_ver) - - if i == 0: - xa = x0 - ya = y0 - - if distance_point_point_xy([xa, ya], [xb, yb]): - lines.append([[xa, ya, 0.0], [xb, yb, 0.0]]) - - append_mirrored_lines([[xa, ya, 0.0], [xb, yb, 0.0]], lines, line_hor, line_ver) - - xa = xc - dx * j - xb = xc - dx * j - ya = yc - dy * j - yb = y0 - - if distance_point_point_xy([xa, ya], [xb, yb]): - lines.append([[xa, ya, 0.0], [xb, yb, 0.0]]) - - append_mirrored_lines([[xa, ya, 0.0], [xb, yb, 0.0]], lines, line_hor, line_ver) - - xa = yc - dy * j - ya = yc - xb = (xa - x0) * (1 - lambd) - yb = xb * (y1 - y0) / (x1 - x0) + y0 - - if distance_point_point_xy([xa, ya], [xb, yb]): - lines.append([[xa, ya, 0.0], [xb, yb, 0.0]]) - - append_mirrored_lines([[xa, ya, 0.0], [xb, yb, 0.0]], lines, line_hor, line_ver) - - xa = xc - dx * j - xb = x0 - ya = yc - dy * j - yb = yc - dy * j - - if distance_point_point_xy([xa, ya], [xb, yb]): - lines.append([[xa, ya, 0.0], [xb, yb, 0.0]]) - - append_mirrored_lines([[xa, ya, 0.0], [xb, yb, 0.0]], lines, line_hor, line_ver) - - # clean_lines = split_intersection_lines(lines) diff --git a/src/compas_rv/scene/__init__.py b/src/compas_rv/scene/__init__.py index e690dbe..71ed7e6 100644 --- a/src/compas_rv/scene/__init__.py +++ b/src/compas_rv/scene/__init__.py @@ -1,20 +1,15 @@ from compas.plugins import plugin from compas.scene.context import register -from compas_rv.datastructures import ForceDiagram -from compas_rv.datastructures import FormDiagram -from compas_rv.datastructures import Pattern -from compas_rv.datastructures import ThrustDiagram +from compas_rv.datastructures import ForceDiagram, FormDiagram, Pattern from .forceobject import RhinoForceObject from .formobject import RhinoFormObject from .patternobject import RhinoPatternObject -from .thrustobject import RhinoThrustObject @plugin(category="factories", pluggable_name="register_scene_objects", requires=["Rhino"]) def register_scene_objects_rhino(): register(Pattern, RhinoPatternObject, context="Rhino") register(FormDiagram, RhinoFormObject, context="Rhino") - register(ThrustDiagram, RhinoThrustObject, context="Rhino") register(ForceDiagram, RhinoForceObject, context="Rhino") diff --git a/src/compas_rv/scene/diagramobject.py b/src/compas_rv/scene/diagramobject.py index 2460e20..e4eec4f 100644 --- a/src/compas_rv/scene/diagramobject.py +++ b/src/compas_rv/scene/diagramobject.py @@ -122,7 +122,12 @@ def draw(self): return self.guids - def draw_vertices(self): + def draw_vertices(self, anchorcolor=None, fixedcolor=None, freecolor=None): + # enable definiting the colors to serve form and thrust diagrams + anchorcolor = anchorcolor or self.anchorcolor + fixedcolor = fixedcolor or self.fixedcolor + freecolor = freecolor or self.freecolor + if self.show_vertices is True: vertices = [] if self.show_free: @@ -135,11 +140,11 @@ def draw_vertices(self): for vertex in self.diagram.vertices(): if self.diagram.vertex_attribute(vertex, "is_support"): - self.vertexcolor[vertex] = self.anchorcolor + self.vertexcolor[vertex] = anchorcolor elif self.diagram.vertex_attribute(vertex, "is_fixed"): - self.vertexcolor[vertex] = self.fixedcolor + self.vertexcolor[vertex] = fixedcolor else: - self.vertexcolor[vertex] = self.freecolor + self.vertexcolor[vertex] = freecolor return super().draw_vertices() diff --git a/src/compas_rv/scene/forceobject.py b/src/compas_rv/scene/forceobject.py index df5baaa..1fba751 100644 --- a/src/compas_rv/scene/forceobject.py +++ b/src/compas_rv/scene/forceobject.py @@ -49,3 +49,4 @@ def forces(self): # ============================================================================= # Redraw # ============================================================================= + diff --git a/src/compas_rv/scene/formobject.py b/src/compas_rv/scene/formobject.py index 3206647..8b10b3b 100644 --- a/src/compas_rv/scene/formobject.py +++ b/src/compas_rv/scene/formobject.py @@ -1,5 +1,18 @@ +from contextlib import contextmanager + +import rhinoscriptsyntax as rs # type: ignore +import scriptcontext as sc # type: ignore + +import compas_rhino.conversions +import compas_rhino.objects from compas.colors import Color +from compas.geometry import Cylinder +from compas.geometry import Line +from compas.geometry import Sphere +from compas.geometry import Vector +from compas.scene.descriptors.color import ColorAttribute from compas.scene.descriptors.colordict import ColorDictAttribute +from compas_rui.scene import RUIMeshObject from compas_rv.datastructures import FormDiagram from compas_rv.session import RVSession @@ -10,16 +23,59 @@ class RhinoFormObject(RhinoDiagramObject): session = RVSession() diagram: FormDiagram # type: ignore + # Planar form diagram colors (existing) vertexcolor = ColorDictAttribute(default=Color.green()) edgecolor = ColorDictAttribute(default=Color.green().darkened(50)) facecolor = ColorDictAttribute(default=Color.green().lightened(25)) + # Thrust diagram colors (for 3D representation) + thrust_vertexcolor = ColorDictAttribute(default=Color.purple()) + thrust_edgecolor = ColorDictAttribute(default=Color.purple().darkened(50)) + thrust_facecolor = ColorDictAttribute(default=Color.purple().lightened(25)) + thrust_freecolor = ColorAttribute(default=Color.purple()) + thrust_anchorcolor = ColorAttribute(default=Color.red()) + thrust_fixedcolor = ColorAttribute(default=Color.cyan()) + + residualcolor = ColorAttribute(default=Color.cyan()) + reactioncolor = ColorAttribute(default=Color.green()) + loadcolor = ColorAttribute(default=Color.green().darkened(50)) + displacementcolor = ColorAttribute(default=Color.orange()) + selfweightcolor = ColorAttribute(default=Color.white()) + compressioncolor = ColorAttribute(default=Color.blue()) + tensioncolor = ColorAttribute(default=Color.red()) + ecrackcolor = ColorAttribute(default=Color.green()) + icrackcolor = ColorAttribute(default=Color.blue()) + boundscolor = ColorAttribute(default=Color.magenta()) + + form_layer = "RhinoVAULT::FormDiagram" + thrust_layer = "RhinoVAULT::ThrustDiagram" + envelope_layer = "RhinoVAULT::Envelope" + def __init__( self, vertexgroup="RhinoVAULT::FormDiagram::Vertices", edgegroup="RhinoVAULT::FormDiagram::Edges", facegroup="RhinoVAULT::FormDiagram::Faces", - layer="RhinoVAULT::FormDiagram", + layer=form_layer, + thrust_vertexgroup="RhinoVAULT::ThrustDiagram::Vertices", + thrust_edgegroup="RhinoVAULT::ThrustDiagram::Edges", + thrust_facegroup="RhinoVAULT::ThrustDiagram::Faces", + loadgroup="RhinoVAULT::ThrustDiagram::Loads", + displacementgroup="RhinoVAULT::ThrustDiagram::SupportDisplacements", + selfweightgroup="RhinoVAULT::ThrustDiagram::Selfweight", + forcegroup="RhinoVAULT::ThrustDiagram::Forces", + labelgroup="RhinoVAULT::ThrustDiagram::Labels", + reactiongroup="RhinoVAULT::ThrustDiagram::Reactions", + residualgroup="RhinoVAULT::ThrustDiagram::Residuals", + crackgroup="RhinoVAULT::Envelope::Cracks", + boundsgroup="RhinoVAULT::Envelope::Bounds", + show_thrust=False, + show_thrust_vertices=True, + show_thrust_edges=True, + show_thrust_faces=True, + show_thrust_supports=True, + show_thrust_fixed=True, + show_thrust_free=False, **kwargs, ): super().__init__( @@ -30,24 +86,669 @@ def __init__( **kwargs, ) + # Store thrust diagram layer groups + self.thrust_vertexgroup = thrust_vertexgroup + self.thrust_edgegroup = thrust_edgegroup + self.thrust_facegroup = thrust_facegroup + self.loadgroup = loadgroup + self.displacementgroup = displacementgroup + self.selfweightgroup = selfweightgroup + self.forcegroup = forcegroup + self.labelgroup = labelgroup + self.reactiongroup = reactiongroup + self.residualgroup = residualgroup + self.crackgroup = crackgroup + self.boundsgroup = boundsgroup + + self.show_supports = True + self.show_fixed = True + self.show_free = False + + self.show_thrust = show_thrust + self.show_thrust_vertices = show_thrust_vertices + self.show_thrust_edges = show_thrust_edges + self.show_thrust_faces = show_thrust_faces + self.show_thrust_supports = show_thrust_supports + self.show_thrust_fixed = show_thrust_fixed + self.show_thrust_free = show_thrust_free + + self._selection_thrust_vertices = None + self._selection_thrust_edges = None + self._selection_active = False + # ============================================================================= # Properties # ============================================================================= + @property + def settings(self): + settings = super().settings + settings["show_thrust"] = self.show_thrust + settings["show_thrust_vertices"] = self.show_thrust_vertices + settings["show_thrust_edges"] = self.show_thrust_edges + settings["show_thrust_faces"] = self.show_thrust_faces + settings["show_thrust_supports"] = self.show_thrust_supports + settings["show_thrust_fixed"] = self.show_thrust_fixed + settings["show_thrust_free"] = self.show_thrust_free + return settings + + # ============================================================================= + # Envelope helpers + # ============================================================================= + + def envelope(self): + return self.session.find_envelope(warn=False) + + def vertex_bound(self, vertex): + ub = self.diagram.vertex_attribute(vertex, "ub") + lb = self.diagram.vertex_attribute(vertex, "lb") + if ub is None or lb is None: + return + point = self.diagram.vertex_point(vertex) + a = point.copy() + a.z = ub + b = point.copy() + b.z = lb + return Line(a, b) + + def vertex_is_on_upper_bound(self, vertex, tol=1e-6): + ub = self.diagram.vertex_attribute(vertex, "ub") + if ub is None: + return False + point = self.diagram.vertex_point(vertex) + return abs(point.z - ub) < tol + + def vertex_is_on_lower_bound(self, vertex, tol=1e-6): + lb = self.diagram.vertex_attribute(vertex, "lb") + if lb is None: + return False + point = self.diagram.vertex_point(vertex) + return abs(point.z - lb) < tol + + def vertex_bound_name(self, vertex): + return f"{self.diagram.name}.vertex.{vertex}.bound" + + def vertex_crack_name(self, vertex): + return f"{self.diagram.name}.vertex.{vertex}.crack" + def edges(self, **kwargs): return self.diagram.edges_where(_is_edge=True) def faces(self, **kwargs): return self.diagram.faces_where(_is_loaded=True) + # ============================================================================= + # Select + # ============================================================================= + + @contextmanager + def _selection_context(self, representation, vertices=False, edges=False, faces=False): + state = { + "show_vertices": self.show_vertices, + "show_edges": self.show_edges, + "show_faces": self.show_faces, + "show_thrust": self.show_thrust, + "selection_thrust_vertices": self._selection_thrust_vertices, + "selection_thrust_edges": self._selection_thrust_edges, + "selection_active": self._selection_active, + } + + try: + self._selection_active = True + if representation == "form": + self.show_vertices = vertices + self.show_edges = edges + self.show_faces = faces + self.show_thrust = False + elif representation == "thrust": + self.show_vertices = False + self.show_edges = False + self.show_faces = False + self.show_thrust = True + self._selection_thrust_vertices = vertices + self._selection_thrust_edges = edges + else: + raise ValueError("Unknown diagram representation: {}".format(representation)) + + self.redraw() + yield + finally: + self.show_vertices = state["show_vertices"] + self.show_edges = state["show_edges"] + self.show_faces = state["show_faces"] + self.show_thrust = state["show_thrust"] + self._selection_thrust_vertices = state["selection_thrust_vertices"] + self._selection_thrust_edges = state["selection_thrust_edges"] + self._selection_active = state["selection_active"] + rs.UnselectAllObjects() + self.redraw() + + def select_form_vertices(self, vertices=None, message="Select Form Vertices", use_edges=True): + vertices = list(self.diagram.vertices()) if vertices is None else list(vertices) + edges = list(self.edges()) if use_edges else False + allowed = set(vertices) + + with self._selection_context("form", vertices=vertices, edges=edges): + selected = super().select_vertices(message=message, use_edges=use_edges) + + if selected is None: + return + return list(dict.fromkeys(vertex for vertex in selected if vertex in allowed)) + + def select_thrust_vertices(self, vertices=None, message="Select Thrust Vertices", use_edges=True): + vertices = list(self.diagram.vertices()) if vertices is None else list(vertices) + edges = list(self.edges()) if use_edges else False + allowed = set(vertices) + + with self._selection_context("thrust", vertices=vertices, edges=edges): + selected = super().select_vertices(message=message, use_edges=use_edges) + + if selected is None: + return + return list(dict.fromkeys(vertex for vertex in selected if vertex in allowed)) + + def select_form_edges(self, edges=None, message="Select Form Edges"): + edges = list(self.edges()) if edges is None else list(edges) + allowed = set(edges) + + with self._selection_context("form", edges=edges): + selected = super().select_edges(message=message) + + if selected is None: + return + return list(dict.fromkeys(edge for edge in selected if edge in allowed)) + + def select_thrust_edges(self, edges=None, message="Select Thrust Edges"): + edges = list(self.edges()) if edges is None else list(edges) + allowed = set(edges) + + with self._selection_context("thrust", edges=edges): + selected = super().select_edges(message=message) + + if selected is None: + return + return list(dict.fromkeys(edge for edge in selected if edge in allowed)) + + def select_form_faces(self, faces=None): + faces = list(self.faces()) if faces is None else list(faces) + allowed = set(faces) + + with self._selection_context("form", faces=faces): + selected = super().select_faces_manual() + + if selected is None: + return + return list(dict.fromkeys(face for face in selected if face in allowed)) + + def select_edges_loop(self): + guids = compas_rhino.objects.select_lines(message="Select Loop Edges") + edges = [] + for guid in guids or []: + edge = self._guid_edge.get(guid) + if edge is not None: + edges += list(self.diagram.edge_loop(edge)) + return edges + + def select_edges_strip(self): + guids = compas_rhino.objects.select_lines(message="Select Strip Edges") + edges = [] + for guid in guids or []: + edge = self._guid_edge.get(guid) + if edge is not None: + edges += list(self.diagram.edge_strip(edge)) + return edges + # ============================================================================= # Clear # ============================================================================= + # ============================================================================= + # Draw Planar + # ============================================================================= + + def draw_formdiagram(self): + """Draw the form diagram in planar mode (z=0 for all vertices).""" + self.layer = self.form_layer + # Store original z coordinates + original_z = {} + for vertex in self.diagram.vertices(): + original_z[vertex] = self.diagram.vertex_attribute(vertex, "z") + self.diagram.vertex_attribute(vertex, "z", 0) + + # Use existing planar colors + for vertex in self.diagram.vertices(): + if self.diagram.vertex_attribute(vertex, "is_support"): + self.vertexcolor[vertex] = self.anchorcolor + elif self.diagram.vertex_attribute(vertex, "is_fixed"): + self.vertexcolor[vertex] = self.fixedcolor + else: + self.vertexcolor[vertex] = self.freecolor + + # Draw using parent class method + guids = super().draw() + + # Restore original z coordinates + for vertex, z in original_z.items(): + self.diagram.vertex_attribute(vertex, "z", z) + + return guids + + # ============================================================================= + # Draw Thrust Diagram + # ============================================================================= + + def compute_pipe_colors(self, tol=1e-3) -> None: + edges = list(self.edges()) + forces = [self.diagram.edge_attribute(edge, "_f") for edge in edges] + if not forces or any(force is None for force in forces): + return + magnitudes = [abs(f) for f in forces] + fmin = min(magnitudes) + fmax = max(magnitudes) + + if fmax - fmin < tol: + # the size of the range is already checked here + # no need to do this again in the loop + return + + colors = [] + for force, magnitude in zip(forces, magnitudes): + # this will need to be updated when we include tension edges + colors.append(Color.from_i((magnitude - fmin) / (fmax - fmin))) + + return dict(zip(edges, colors)) + + def draw_thrustdiagram(self): + self.layer = self.thrust_layer + if self.session.settings.drawing.show_thrust_faces: + self.draw_thrust_faces() + self.draw_thrust_vertices() + self.draw_thrust_edges() + + if self._selection_active: + return self.guids + + if self.session.settings.drawing.show_reactions: + self.draw_thrust_reactions() + if self.session.settings.drawing.show_loads: + self.draw_thrust_loads() + if self.session.settings.drawing.show_support_displacements: + self.draw_support_displacements() + if self.session.settings.drawing.show_selfweight: + self.draw_thrust_selfweight() + if self.session.settings.drawing.show_pipes: + self.draw_thrust_pipes() + if self.session.settings.drawing.show_force_labels: + self.draw_thrust_force_labels() + if self.envelope() and self.session.settings.envelope.show_bounds: + self.draw_bounds() + if self.envelope() and self.session.settings.envelope.show_cracks: + self.draw_cracks() + + return self.guids + + def draw_thrust_vertices(self): + settings = self.session.settings.drawing + if self._selection_thrust_vertices is not None: + vertices = self._selection_thrust_vertices + else: + vertices = [] + if settings.show_thrust_vertices: + if settings.show_thrust_free: + vertices += list(self.diagram.vertices_where(is_support=False, is_fixed=False)) + if settings.show_thrust_fixed: + vertices += list(self.diagram.vertices_where(is_fixed=True)) + if settings.show_thrust_supports: + vertices += list(self.diagram.vertices_where(is_support=True)) + + show_vertices = self.show_vertices + self.show_vertices = vertices + try: + guids = super().draw_vertices( + anchorcolor=self.thrust_anchorcolor, + fixedcolor=self.thrust_fixedcolor, + freecolor=self.thrust_freecolor, + ) + finally: + self.show_vertices = show_vertices + + if guids: + if self.thrust_vertexgroup: + self.add_to_group(self.thrust_vertexgroup, guids) + elif self.group: + self.add_to_group(self.group, guids) + + self._guids += guids + return guids + + def draw_thrust_edges(self): + if self._selection_thrust_edges is not None: + edges = self._selection_thrust_edges + else: + edges = [] + if self.session.settings.drawing.show_thrust_edges: + edges = list(self.diagram.edges_where(_is_edge=True)) + + if edges: + for edge in edges: + self.edgecolor[edge] = self.thrust_edgecolor + + show_edges = self.show_edges + self.show_edges = edges + try: + guids = RUIMeshObject.draw_edges(self) + finally: + self.show_edges = show_edges + + if guids: + if self.thrust_edgegroup: + self.add_to_group(self.thrust_edgegroup, guids) + elif self.group: + self.add_to_group(self.group, guids) + + self._guids += guids + return guids + + def draw_thrust_faces(self): + faces = list(self.diagram.faces_where(_is_loaded=True)) + for face in faces: + self.facecolor[face] = self.thrust_facecolor + + show_faces = self.show_faces + self.show_faces = faces + try: + guids = RUIMeshObject.draw_faces(self) + finally: + self.show_faces = show_faces + + if guids: + if self.thrust_facegroup: + self.add_to_group(self.thrust_facegroup, guids) + elif self.group: + self.add_to_group(self.group, guids) + + self._guids += guids + return guids + + def draw_thrust_reactions(self): + guids = [] + + scale = self.session.settings.drawing.scale_reactions + tol = self.session.settings.drawing.tol_vectors + + for vertex in self.diagram.vertices_where(is_support=True): + residual = Vector(*self.diagram.vertex_attributes(vertex, ["_rx", "_ry", "_rz"])) + vector = residual * scale + + if vector.length > tol: + name = "{}.vertex.{}.reaction".format(self.diagram.name, vertex) + attr = self.compile_attributes(name=name, color=Color.green(), arrow="start") + point = self.diagram.vertex_point(vertex) + line = Line.from_point_and_vector(point, vector) + guid = sc.doc.Objects.AddLine(compas_rhino.conversions.line_to_rhino(line), attr) + guids.append(guid) + + if self.session.settings.drawing.show_reaction_labels and residual.length >= self.session.settings.drawing.tol_labels: + text = "{0:.1f}".format(residual.length) + attr = self.compile_attributes(name=name + ".label", color=self.reactioncolor) + guid = sc.doc.Objects.AddTextDot(text, compas_rhino.conversions.point_to_rhino(line.midpoint), attr) + guids.append(guid) + + if guids: + if self.reactiongroup: + self.add_to_group(self.reactiongroup, guids) + elif self.group: + self.add_to_group(self.group, guids) + + self._guids += guids + return guids + + def draw_thrust_loads(self): + guids = [] + + scale = self.session.settings.drawing.scale_loads + color = self.loadcolor + tol = self.session.settings.drawing.tol_vectors + + for vertex in self.diagram.vertices_where(is_support=False): + load = self.diagram.vertex_attributes(vertex, ["px", "py", "pz"]) + pzext = self.diagram.vertex_attribute(vertex, "pzext") + if pzext is not None: + load[2] += pzext + + if load is not None: + vector = Vector(*load) * scale + if vector.length > tol: + name = "{}.vertex.{}.load".format(self.diagram.name, vertex) + attr = self.compile_attributes(name=name, color=color, arrow="start") + point = self.diagram.vertex_point(vertex) + line = Line.from_point_and_vector(point, vector) + guid = sc.doc.Objects.AddLine(compas_rhino.conversions.line_to_rhino(line), attr) + guids.append(guid) + + if guids: + if self.loadgroup: + self.add_to_group(self.loadgroup, guids) + elif self.group: + self.add_to_group(self.group, guids) + + self._guids += guids + return guids + + def draw_support_displacements(self): + guids = [] + + scale = self.session.settings.drawing.scale_support_displacements + tol = self.session.settings.drawing.tol_vectors + + for vertex in self.diagram.vertices_where(is_support=True): + displacement = self.diagram.vertex_attributes(vertex, ["ux", "uy", "uz"]) + if displacement is None: + continue + + vector = Vector(*displacement) * scale + if vector.length <= tol: + continue + + name = "{}.vertex.{}.supportdisplacement".format(self.diagram.name, vertex) + attr = self.compile_attributes(name=name, color=self.displacementcolor, arrow="end") + point = self.diagram.vertex_point(vertex) + line = Line.from_point_and_vector(point, vector) + guid = sc.doc.Objects.AddLine(compas_rhino.conversions.line_to_rhino(line), attr) + guids.append(guid) + + if guids: + if self.displacementgroup: + self.add_to_group(self.displacementgroup, guids) + elif self.group: + self.add_to_group(self.group, guids) + + self._guids += guids + return guids + + def draw_thrust_selfweight(self): + guids = [] + + scale = self.session.settings.drawing.scale_selfweight + color = self.selfweightcolor + tol = self.session.settings.drawing.tol_vectors + + for vertex in self.diagram.vertices_where(is_support=False): + thickness = self.diagram.vertex_attribute(vertex, "t") + + if thickness: + area = self.diagram.vertex_area(vertex) + weight = area * thickness + point = self.diagram.vertex_point(vertex) + vector = Vector(0, 0, -weight * scale) + if vector.length > tol: + line = Line.from_point_and_vector(point, vector) + name = "{}.vertex.{}.selfweight".format(self.diagram.name, vertex) + attr = self.compile_attributes(name=name, color=color, arrow="end") + guid = sc.doc.Objects.AddLine(compas_rhino.conversions.line_to_rhino(line), attr) + guids.append(guid) + + if guids: + if self.selfweightgroup: + self.add_to_group(self.selfweightgroup, guids) + elif self.group: + self.add_to_group(self.group, guids) + + self._guids += guids + return guids + + def draw_thrust_pipes(self): + guids = [] + + scale = self.session.settings.drawing.scale_pipes + tol = self.session.settings.drawing.tol_pipes + + pipe_colors = self.compute_pipe_colors() + + for edge in self.edges(): + force = self.diagram.edge_attribute(edge, "_f") + + if force: + line = self.diagram.edge_line(edge) + radius = abs(force) * scale + + color = self.compressioncolor + if self.session.settings.drawing.show_forces and pipe_colors: + color = pipe_colors[edge] + + if radius > tol: + pipe = Cylinder.from_line_and_radius(line, radius) + name = "{}.edge.{}.force".format(self.diagram.name, edge) + attr = self.compile_attributes(name=name, color=color) + guid = sc.doc.Objects.AddBrep(compas_rhino.conversions.cylinder_to_rhino_brep(pipe), attr) + guids.append(guid) + + if guids: + if self.forcegroup: + self.add_to_group(self.forcegroup, guids) + elif self.group: + self.add_to_group(self.group, guids) + + self._guids += guids + return guids + + def draw_thrust_force_labels(self): + guids = [] + + for edge in self.diagram.edges_where(_is_edge=True): + q = self.diagram.edge_attribute(edge, "q") + if q is None: + continue + + force = q * self.diagram.edge_length(edge) + if abs(force) < self.session.settings.drawing.tol_labels: + continue + + name = "{}.edge.{}.force.label".format(self.diagram.name, edge) + attr = self.compile_attributes(name=name, color=self.compressioncolor) + text = "{0:.1f}".format(force) + point = self.diagram.edge_midpoint(edge) + guid = sc.doc.Objects.AddTextDot(text, compas_rhino.conversions.point_to_rhino(point), attr) + guids.append(guid) + + if guids: + if self.labelgroup: + self.add_to_group(self.labelgroup, guids) + elif self.group: + self.add_to_group(self.group, guids) + + self._guids += guids + return guids + + def draw_bounds(self): + guids = [] + layer = self.layer + self.layer = self.envelope_layer + + try: + for vertex in self.diagram.vertices(): + bound = self.vertex_bound(vertex) + if bound: + name = self.vertex_bound_name(vertex) + attr = self.compile_attributes(name=name, color=self.boundscolor) + guid = sc.doc.Objects.AddLine(compas_rhino.conversions.line_to_rhino(bound), attr) + guids.append(guid) + guid = sc.doc.Objects.AddPoint(compas_rhino.conversions.point_to_rhino(bound.start), attr) + guids.append(guid) + guid = sc.doc.Objects.AddPoint(compas_rhino.conversions.point_to_rhino(bound.end), attr) + guids.append(guid) + finally: + self.layer = layer + + if guids: + if self.boundsgroup: + self.add_to_group(self.boundsgroup, guids) + elif self.group: + self.add_to_group(self.group, guids) + + self._guids += guids + return guids + + def draw_cracks(self): + guids = [] + layer = self.layer + self.layer = self.envelope_layer + + try: + for vertex in self.diagram.vertices(): + if self.vertex_is_on_lower_bound(vertex): + name = self.vertex_crack_name(vertex) + attr = self.compile_attributes(name=name, color=self.icrackcolor) + elif self.vertex_is_on_upper_bound(vertex): + name = self.vertex_crack_name(vertex) + attr = self.compile_attributes(name=name, color=self.ecrackcolor) + else: + continue + + point = self.diagram.vertex_point(vertex) + radius = self.session.settings.envelope.crack_radius + sphere = Sphere(radius, point=point) + guid = sc.doc.Objects.AddSphere(compas_rhino.conversions.sphere_to_rhino(sphere), attr) + guids.append(guid) + finally: + self.layer = layer + + if guids: + if self.crackgroup: + self.add_to_group(self.crackgroup, guids) + elif self.group: + self.add_to_group(self.group, guids) + + self._guids += guids + return guids + # ============================================================================= # Draw # ============================================================================= + def draw(self): + """Draw method shows 2D and 3D if enabled, otherwise shows 2D only.""" + self.draw_formdiagram() + if self.show_thrust: + self.draw_thrustdiagram() + return self.guids + # ============================================================================= # Redraw # ============================================================================= + + def redraw(self): + rs.EnableRedraw(False) + self.clear() + self.draw() + rs.EnableRedraw(True) + rs.Redraw() + + def redraw_vertices(self): + self.redraw() + + def redraw_edges(self): + self.redraw() + + def redraw_faces(self): + self.redraw() diff --git a/src/compas_rv/scene/thrustobject.py b/src/compas_rv/scene/thrustobject.py deleted file mode 100644 index dffe17b..0000000 --- a/src/compas_rv/scene/thrustobject.py +++ /dev/null @@ -1,356 +0,0 @@ -import rhinoscriptsyntax as rs # type: ignore -import scriptcontext as sc # type: ignore - -import compas_rhino.conversions -from compas.colors import Color -from compas.geometry import Cylinder -from compas.geometry import Line -from compas.geometry import Vector -from compas.scene.descriptors.color import ColorAttribute -from compas.scene.descriptors.colordict import ColorDictAttribute -from compas_rui.scene import RUIMeshObject -from compas_rv.datastructures import ThrustDiagram -from compas_rv.session import RVSession - - -class RhinoThrustObject(RUIMeshObject): - session = RVSession() - mesh: ThrustDiagram - - vertexcolor = ColorDictAttribute(default=Color.purple()) - edgecolor = ColorDictAttribute(default=Color.purple().darkened(50)) - facecolor = ColorDictAttribute(default=Color.purple().lightened(25)) - freecolor = ColorAttribute(default=Color.purple()) - anchorcolor = ColorAttribute(default=Color.red()) - fixedcolor = ColorAttribute(default=Color.cyan()) - residualcolor = ColorAttribute(default=Color.cyan()) - reactioncolor = ColorAttribute(default=Color.green()) - loadcolor = ColorAttribute(default=Color.green().darkened(50)) - selfweightcolor = ColorAttribute(default=Color.white()) - compressioncolor = ColorAttribute(default=Color.blue()) - tensioncolor = ColorAttribute(default=Color.red()) - - def __init__( - self, - disjoint=True, - show_supports=True, - show_fixed=True, - show_free=False, - vertexgroup="RhinoVAULT::ThrustDiagram::Vertices", - edgegroup="RhinoVAULT::ThrustDiagram::Edges", - facegroup="RhinoVAULT::ThrustDiagram::Faces", - loadgroup="RhinoVAULT::ThrustDiagram::Loads", - selfweightgroup="RhinoVAULT::ThrustDiagram::Selfweight", - forcegroup="RhinoVAULT::ThrustDiagram::Forces", - reactiongroup="RhinoVAULT::ThrustDiagram::Reactions", - residualgroup="RhinoVAULT::ThrustDiagram::Residuals", - **kwargs, - ): - super().__init__( - disjoint=disjoint, - vertexgroup=vertexgroup, - edgegroup=edgegroup, - facegroup=facegroup, - **kwargs, - ) - - self.show_faces = True - self.show_edges = False - self.show_supports = show_supports - self.show_fixed = show_fixed - self.show_free = show_free - self.loadgroup = loadgroup - self.selfweightgroup = selfweightgroup - self.forcegroup = forcegroup - self.reactiongroup = reactiongroup - self.residualgroup = residualgroup - - @property - def settings(self): - settings = super().settings - settings["show_supports"] = self.show_supports - settings["show_fixed"] = self.show_fixed - settings["show_free"] = self.show_free - return settings - - @property - def diagram(self) -> ThrustDiagram: - return self.mesh - - @diagram.setter - def diagram(self, diagram: ThrustDiagram) -> None: - self.mesh = diagram - - def compute_pipe_colors(self, tol=1e-3) -> None: - edges = list(self.diagram.edges()) - forces = [self.diagram.edge_attribute(edge, "_f") for edge in edges] - magnitudes = [abs(f) for f in forces] - fmin = min(magnitudes) - fmax = max(magnitudes) - - if fmax - fmin < tol: - # the size of the range is already checked here - # no need to do this again in the loop - return - - colors = [] - for force, magnitude in zip(forces, magnitudes): - # this will need to be updated when we include tension edges - colors.append(Color.from_i((magnitude - fmin) / (fmax - fmin))) - - return dict(zip(edges, colors)) - - # ============================================================================= - # Clear - # ============================================================================= - - # ============================================================================= - # Draw - # ============================================================================= - - def draw(self): - faces = [] - if self.show_faces: - faces += list(self.diagram.faces_where(_is_loaded=True)) - if faces: - self.show_faces = faces - - for vertex in self.diagram.vertices(): - if self.diagram.vertex_attribute(vertex, "is_support"): - self.vertexcolor[vertex] = self.anchorcolor - elif self.diagram.vertex_attribute(vertex, "is_fixed"): - self.vertexcolor[vertex] = self.fixedcolor - else: - self.vertexcolor[vertex] = self.freecolor - - super().draw() - - if self.session.settings.drawing.show_reactions: - self.draw_reactions() - if self.session.settings.drawing.show_loads: - self.draw_loads() - if self.session.settings.drawing.show_selfweight: - self.draw_selfweight() - if self.session.settings.drawing.show_pipes: - self.draw_pipes() - - return self.guids - - def draw_vertices(self): - if self.show_vertices is True: - vertices = [] - if self.show_free: - vertices += list(self.diagram.vertices_where(is_support=False, is_fixed=False)) - if self.show_fixed: - vertices += list(self.diagram.vertices_where(is_fixed=True)) - if self.show_supports: - vertices += list(self.diagram.vertices_where(is_support=True)) - self.show_vertices = vertices - - for vertex in self.diagram.vertices(): - if self.diagram.vertex_attribute(vertex, "is_support"): - self.vertexcolor[vertex] = self.anchorcolor - elif self.diagram.vertex_attribute(vertex, "is_fixed"): - self.vertexcolor[vertex] = self.fixedcolor - else: - self.vertexcolor[vertex] = self.freecolor - - return super().draw_vertices() - - def draw_edges(self): - if self.show_edges is True: - edges = list(self.diagram.edges_where(_is_edge=True)) - if edges: - self.show_edges = edges - - return super().draw_edges() - - def draw_faces(self): - faces = [] - if self.show_faces: - faces += list(self.diagram.faces_where(_is_loaded=True)) - if faces: - self.show_faces = faces - - return super().draw_faces() - - def draw_loads(self): - guids = [] - - scale = self.session.settings.drawing.scale_loads - color = self.loadcolor - tol = self.session.settings.drawing.tol_vectors - - for vertex in self.diagram.vertices_where(is_support=False): - load = self.diagram.vertex_attributes(vertex, ["px", "py", "pz"]) - - if load is not None: - vector = Vector(*load) * scale - if vector.length > tol: - name = "{}.vertex.{}.load".format(self.diagram.name, vertex) - attr = self.compile_attributes(name=name, color=color, arrow="start") - point = self.diagram.vertex_point(vertex) - line = Line.from_point_and_vector(point, vector) - guid = sc.doc.Objects.AddLine(compas_rhino.conversions.line_to_rhino(line), attr) - guids.append(guid) - - if guids: - if self.loadgroup: - self.add_to_group(self.loadgroup, guids) - elif self.group: - self.add_to_group(self.group, guids) - - self._guids += guids - return guids - - def draw_selfweight(self): - guids = [] - - scale = self.session.settings.drawing.scale_selfweight - color = self.selfweightcolor - tol = self.session.settings.drawing.tol_vectors - - for vertex in self.diagram.vertices_where(is_support=False): - thickness = self.diagram.vertex_attribute(vertex, "t") - - if thickness: - area = self.diagram.vertex_area(vertex) - weight = area * thickness - point = self.diagram.vertex_point(vertex) - vector = Vector(0, 0, -weight * scale) - if vector.length > tol: - line = Line.from_point_and_vector(point, vector) - name = "{}.vertex.{}.selfweight".format(self.diagram.name, vertex) - attr = self.compile_attributes(name=name, color=color, arrow="end") - guid = sc.doc.Objects.AddLine(compas_rhino.conversions.line_to_rhino(line), attr) - guids.append(guid) - - if guids: - if self.selfweightgroup: - self.add_to_group(self.selfweightgroup, guids) - elif self.group: - self.add_to_group(self.group, guids) - - self._guids += guids - return guids - - def draw_pipes(self): - guids = [] - - scale = self.session.settings.drawing.scale_pipes - tol = self.session.settings.drawing.tol_pipes - - pipe_colors = self.compute_pipe_colors() - - for edge in self.diagram.edges(): - force = self.diagram.edge_attribute(edge, "_f") - - if force != 0: - line = self.diagram.edge_line(edge) - radius = abs(force) * scale - - color = self.compressioncolor - if self.session.settings.drawing.show_forces: - color = pipe_colors[edge] - - if radius > tol: - pipe = Cylinder.from_line_and_radius(line, radius) - name = "{}.edge.{}.force".format(self.diagram.name, edge) - attr = self.compile_attributes(name=name, color=color) - guid = sc.doc.Objects.AddBrep(compas_rhino.conversions.cylinder_to_rhino_brep(pipe), attr) - guids.append(guid) - - if guids: - if self.forcegroup: - self.add_to_group(self.forcegroup, guids) - elif self.group: - self.add_to_group(self.group, guids) - - self._guids += guids - return guids - - def draw_reactions(self): - guids = [] - - scale = self.session.settings.drawing.scale_reactions - tol = self.session.settings.drawing.tol_vectors - - for vertex in self.diagram.vertices_where(is_support=True): - residual = Vector(*self.diagram.vertex_attributes(vertex, ["_rx", "_ry", "_rz"])) - vector = residual * scale - - if vector.length > tol: - name = "{}.vertex.{}.reaction".format(self.diagram.name, vertex) - attr = self.compile_attributes(name=name, color=self.reactioncolor, arrow="start") - point = self.diagram.vertex_point(vertex) - line = Line.from_point_and_vector(point, vector) - guid = sc.doc.Objects.AddLine(compas_rhino.conversions.line_to_rhino(line), attr) - guids.append(guid) - - if guids: - if self.reactiongroup: - self.add_to_group(self.reactiongroup, guids) - elif self.group: - self.add_to_group(self.group, guids) - - self._guids += guids - return guids - - def draw_residuals(self): - guids = [] - - scale = self.session.settings.drawing.scale_residuals - tol = self.session.settings.drawing.tol_vectors - - for vertex in self.diagram.vertices_where(is_support=False): - residual = Vector(*self.diagram.vertex_attributes(vertex, ["_rx", "_ry", "_rz"])) - - vector = residual * scale - if vector.length > tol: - name = "{}.vertex.{}.residual".format(self.diagram.name, vertex) - attr = self.compile_attributes(name=name, color=self.residualcolor, arrow="end") - point = self.diagram.vertex_point(vertex) - line = Line.from_point_and_vector(point, vector) - guid = sc.doc.Objects.AddLine(compas_rhino.conversions.line_to_rhino(line), attr) - guids.append(guid) - - if guids: - if self.residualgroup: - self.add_to_group(self.residualgroup, guids) - elif self.group: - self.add_to_group(self.group, guids) - - self._guids += guids - return guids - - # ============================================================================= - # Redraw - # ============================================================================= - - def redraw_vertices(self): - rs.EnableRedraw(False) - self.clear_vertices() - self.draw_vertices() - rs.EnableRedraw(True) - rs.Redraw() - - def redraw_edges(self): - rs.EnableRedraw(False) - self.clear_edges() - self.draw_edges() - rs.EnableRedraw(True) - rs.Redraw() - - def redraw_faces(self): - rs.EnableRedraw(False) - self.clear_faces() - self.draw_faces() - rs.EnableRedraw(True) - rs.Redraw() - - def redraw(self): - rs.EnableRedraw(False) - self.clear() - self.draw() - rs.EnableRedraw(True) - rs.Redraw() diff --git a/src/compas_rv/session.py b/src/compas_rv/session.py index 91a964d..dfc6880 100644 --- a/src/compas_rv/session.py +++ b/src/compas_rv/session.py @@ -14,6 +14,14 @@ def find_all_by_itemtype(scene: Scene, itemtype) -> list[RhinoSceneObject]: return sceneobjects +def find_all_by_items(scene: Scene, items) -> list[RhinoSceneObject]: + sceneobjects = [] + for obj in scene.objects: + if any(obj.item is item for item in items): + sceneobjects.append(obj) + return sceneobjects + + class RVSession(Session): settings: RVSettings # type: ignore @@ -32,6 +40,7 @@ def clear(self, clear_scene=True, clear_context=True): if hasattr(sceneobject, "clear_conduits"): sceneobject.clear_conduits() # type: ignore self.scene.clear(clear_scene=clear_scene, clear_context=clear_context) + self.data.clear() def clear_conduits(self): for sceneobject in self.scene.objects: @@ -68,15 +77,12 @@ def find_forcediagram(self, warn=True): if warn: rs.MessageBox("There is no ForceDiagram.", title="Warning") - def find_thrustdiagram(self, warn=True): - from compas_rv.datastructures import ThrustDiagram - from compas_rv.scene import RhinoThrustObject - - thrust: RhinoThrustObject = self.scene.find_by_itemtype(ThrustDiagram) # type: ignore - if thrust: - return thrust + def find_envelope(self, warn=True): + envelope = self.get("envelope") + if envelope: + return envelope if warn: - rs.MessageBox("There is no ThrustDiagram.", title="Warning") + rs.MessageBox("There is no Envelope.", title="Warning") def clear_all_patterns(self, redraw=True): from compas_rv.datastructures import Pattern @@ -91,7 +97,6 @@ def clear_all_patterns(self, redraw=True): def clear_all_diagrams(self, redraw=True): self.clear_all_formdiagrams(redraw=False) self.clear_all_forcediagrams(redraw=False) - self.clear_all_thrustdiagrams(redraw=False) if redraw: self.scene.redraw() rs.Redraw() @@ -116,12 +121,23 @@ def clear_all_forcediagrams(self, redraw=True): self.scene.redraw() rs.Redraw() - def clear_all_thrustdiagrams(self, redraw=True): - from compas_rv.datastructures import ThrustDiagram + def clear_envelope(self, redraw=True): + formobject = self.find_formdiagram(warn=False) + if formobject: + formobject.diagram.attributes["loads_from_envelope"] = False + + envelope = self.get("envelope") + if not envelope: + return - for obj in find_all_by_itemtype(self.scene, ThrustDiagram): + items = [mesh for mesh in [envelope.intrados, envelope.middle, envelope.extrados, getattr(envelope, "fill", None)] if mesh] + for obj in find_all_by_items(self.scene, items): obj.clear() self.scene.remove(obj) + + if "envelope" in self: + del self.data["envelope"] + if redraw: self.scene.redraw() rs.Redraw() diff --git a/src/compas_rv/settings.py b/src/compas_rv/settings.py index 5782bea..c2c5bfe 100644 --- a/src/compas_rv/settings.py +++ b/src/compas_rv/settings.py @@ -14,14 +14,41 @@ class TNASettings(BaseModel): vertical_zmax: float = 4.0 +class TNOSettings(BaseModel): + solver: str = "SLSQP" + max_iter: int = 500 + starting_point: str = "loadpath" + printout: bool = True + + +class EnvelopeSettings(BaseModel): + show_intrados: bool = True + show_middle: bool = False + show_extrados: bool = True + show_fill: bool = True + show_bounds: bool = False + show_cracks: bool = True + crack_radius: float = 0.05 + + class DrawingSettings(BaseModel): show_angles: bool = True show_forces: bool = False + show_thrust_vertices: bool = True + show_thrust_edges: bool = True + show_thrust_faces: bool = True + show_thrust_supports: bool = True + show_thrust_fixed: bool = True + show_thrust_free: bool = False + show_reactions: bool = True show_residuals: bool = False show_pipes: bool = False + show_force_labels: bool = False + show_reaction_labels: bool = False show_loads: bool = False + show_support_displacements: bool = True show_selfweight: bool = False show_thickness: bool = False @@ -30,10 +57,12 @@ class DrawingSettings(BaseModel): scale_residuals: float = 1.0 scale_pipes: float = 0.01 scale_loads: float = 1.0 + scale_support_displacements: float = 1.0 scale_selfweight: float = 1.0 tol_vectors: float = 1e-3 tol_pipes: float = 1e-2 + tol_labels: float = 0.1 class RVSettings(Settings): @@ -41,4 +70,6 @@ class RVSettings(Settings): autosave: bool = True tna: TNASettings = TNASettings() + tno: TNOSettings = TNOSettings() + envelope: EnvelopeSettings = EnvelopeSettings() drawing: DrawingSettings = DrawingSettings() diff --git a/src/compas_rv/solvers/scalehorizonal.py b/src/compas_rv/solvers/scalehorizonal.py index ce0b054..970155d 100644 --- a/src/compas_rv/solvers/scalehorizonal.py +++ b/src/compas_rv/solvers/scalehorizonal.py @@ -5,7 +5,7 @@ import compas_rhino.conversions from compas_fd.solvers.fd_numerical_data import FDNumericalData from compas_rv.conduits import EdgesConduit -from compas_rv.datastructures import ThrustDiagram +from compas_rv.datastructures import FormDiagram from compas_tna.equilibrium.diagrams import update_z from compas_tna.loads import LoadUpdater @@ -13,9 +13,9 @@ class InteractiveScaleHorizontal: def __init__( self, - thrust: ThrustDiagram, + form: FormDiagram, ): - self.thrust = thrust + self.form = form self.scale = 1.0 self._numdata = None @@ -42,12 +42,12 @@ def conduit_edges(self) -> EdgesConduit: @property def numdata(self) -> FDNumericalData: if self._numdata is None: - vertex_index = self.thrust.vertex_index() - vertices: list[list[float]] = self.thrust.vertices_attributes("xyz") # type: ignore - loads: list[list[float]] = [self.thrust.vertex_attributes(vertex, ["px", "py", "pz"]) or [0, 0, 0] for vertex in self.thrust.vertices()] # type: ignore - fixed = [vertex_index[vertex] for vertex in self.thrust.vertices_where(is_support=True)] - edges = list(self.thrust.edges_where(_is_edge=True)) - forcedensities: list[float] = list(self.thrust.edges_attribute(name="q", keys=edges)) # type: ignore + vertex_index = self.form.vertex_index() + vertices: list[list[float]] = self.form.vertices_attributes("xyz") # type: ignore + loads: list[list[float]] = [self.form.vertex_attributes(vertex, ["px", "py", "pz"]) or [0, 0, 0] for vertex in self.form.vertices()] # type: ignore + fixed = [vertex_index[vertex] for vertex in self.form.vertices_where(is_support=True)] + edges = list(self.form.edges_where(_is_edge=True)) + forcedensities: list[float] = list(self.form.edges_attribute(name="q", keys=edges)) # type: ignore edges = [(vertex_index[u], vertex_index[v]) for u, v in edges] self._numdata = FDNumericalData.from_params(vertices, fixed, edges, forcedensities, loads) return self._numdata @@ -56,11 +56,12 @@ def numdata(self) -> FDNumericalData: @property def loadupdater(self) -> LoadUpdater: if self._loadupdater is None: + density = 0.0 if self.form.attributes.get("loads_from_envelope") else 1.0 self._loadupdater = LoadUpdater( - self.thrust, + self.form, array(self.numdata.p, copy=True), - array(self.thrust.vertices_attribute("t"), dtype=float64).reshape((-1, 1)), # type: ignore - 1.0, + array(self.form.vertices_attribute("t"), dtype=float64).reshape((-1, 1)), # type: ignore + density, ) return self._loadupdater diff --git a/tests/test_conventions.py b/tests/test_conventions.py new file mode 100644 index 0000000..c5319e0 --- /dev/null +++ b/tests/test_conventions.py @@ -0,0 +1,44 @@ +from compas_rv.conventions import invert_formdiagram_signs + + +class FormDiagram: + def __init__(self): + self.vertex = { + 0: {"px": 1.0, "py": 2.0, "pz": 3.0, "pzext": 7.0, "_rx": 4.0, "_ry": 5.0, "_rz": 6.0}, + 1: {"px": 0.0, "py": 0.0, "pz": 7.0, "pzext": None, "_rx": 0.0, "_ry": 0.0, "_rz": 0.0}, + } + self.edge = {(0, 1): {"q": 8.0, "_f": 9.0, "_is_edge": True}} + + def vertices(self): + return iter(self.vertex) + + def edges_where(self, **conditions): + return (edge for edge, attributes in self.edge.items() if all(attributes[name] == value for name, value in conditions.items())) + + def vertex_attributes(self, vertex, names, values=None): + if values is None: + return [self.vertex[vertex][name] for name in names] + for name, value in zip(names, values): + self.vertex[vertex][name] = value + + def edge_attributes(self, edge, names, values=None): + if values is None: + return [self.edge[edge][name] for name in names] + for name, value in zip(names, values): + self.edge[edge][name] = value + + +def test_invert_formdiagram_signs_is_involutive(): + formdiagram = FormDiagram() + + invert_formdiagram_signs(formdiagram) + + assert formdiagram.vertex[0] == {"px": -1.0, "py": -2.0, "pz": -3.0, "pzext": -7.0, "_rx": -4.0, "_ry": -5.0, "_rz": -6.0} + assert formdiagram.vertex[1] == {"px": -0.0, "py": -0.0, "pz": -7.0, "pzext": None, "_rx": -0.0, "_ry": -0.0, "_rz": -0.0} + assert formdiagram.edge[(0, 1)] == {"q": -8.0, "_f": -9.0, "_is_edge": True} + + invert_formdiagram_signs(formdiagram) + + assert formdiagram.vertex[0] == {"px": 1.0, "py": 2.0, "pz": 3.0, "pzext": 7.0, "_rx": 4.0, "_ry": 5.0, "_rz": 6.0} + assert formdiagram.vertex[1] == {"px": 0.0, "py": 0.0, "pz": 7.0, "pzext": None, "_rx": 0.0, "_ry": 0.0, "_rz": 0.0} + assert formdiagram.edge[(0, 1)] == {"q": 8.0, "_f": 9.0, "_is_edge": True} diff --git a/tests/test_single_formdiagram.py b/tests/test_single_formdiagram.py new file mode 100644 index 0000000..6ece753 --- /dev/null +++ b/tests/test_single_formdiagram.py @@ -0,0 +1,37 @@ +import ast +from pathlib import Path + + +HERE = Path(__file__).parent.parent + + +def attribute_names(filepath): + tree = ast.parse(filepath.read_text()) + return {node.attr for node in ast.walk(tree) if isinstance(node, ast.Attribute)} + + +def test_commands_do_not_use_deleted_thrustdiagram_lookup(): + for filepath in (HERE / "commands").glob("RV_*.py"): + assert "find_thrustdiagram" not in attribute_names(filepath), filepath.name + + +def test_commands_do_not_use_obsolete_thrust_visibility_attributes(): + obsolete = { + "show_vertices_3d", + "show_edges_3d", + "show_faces_3d", + "show_supports_3d", + "show_fixed_3d", + "show_free_3d", + } + + for filepath in (HERE / "commands").glob("RV_*.py"): + assert not obsolete.intersection(attribute_names(filepath)), filepath.name + + +def test_block_export_uses_the_formdiagram_as_thrust_geometry(): + source = (HERE / "commands" / "RV_dem_blocks.py").read_text() + + assert "session.find_formdiagram()" in source + assert "form.diagram.copy()" in source + assert "faces_where(_is_loaded=False)" in source