{
"cells": [
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"%matplotlib widget"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"import matplotlib.pyplot as plt"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"import numpy as np"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"fig, ax = plt.subplots()\n",
"fig.canvas.width = '7in'\n",
"fig.canvas.height= '5in'\n",
"\n",
"# if I hide the header here, I get a libpng error\n",
"# fig.canvas.header_visible = False\n",
"\n",
"ax.plot([1,2,3], [4,5,3])"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# hiding after rendering works\n",
"fig.canvas.header_visible = False"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# hiding together with calls to toolbar options, work.\n",
"fig, ax = plt.subplots()\n",
"fig.canvas.width = '7in'\n",
"fig.canvas.height= '5in'\n",
"\n",
"fig.canvas.toolbar_visible = False\n",
"fig.canvas.header_visible = False\n",
"\n",
"ax.plot([1,2,3], [4,5,3])"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# When using the `widget` backend from ipympl,\n",
"# fig.canvas is a proper Jupyter interactive widget, which can be embedded in\n",
"# an ipywidgets layout. See https://ipywidgets.readthedocs.io/en/stable/examples/Layout%20Templates.html\n",
"\n",
"# One can bound figure attributes to other widget values.\n",
"from ipywidgets import AppLayout, FloatSlider\n",
"\n",
"plt.ioff()\n",
"\n",
"slider = FloatSlider(\n",
" orientation='horizontal',\n",
" description='Factor:',\n",
" value=1.0,\n",
" min=0.02,\n",
" max=2.0\n",
")\n",
"\n",
"slider.layout.margin = '0px 30% 0px 30%'\n",
"slider.layout.width = '40%'\n",
"\n",
"fig = plt.figure()\n",
"fig.canvas.header_visible = False\n",
"fig.canvas.layout.min_height = '400px'\n",
"plt.title('Plotting: y=sin({} * x)'.format(slider.value))\n",
"\n",
"x = np.linspace(0, 20, 500)\n",
"\n",
"lines = plt.plot(x, np.sin(slider.value * x))\n",
"\n",
"def update_lines(change):\n",
" plt.title('Plotting: y=sin({} * x)'.format(change.new))\n",
" lines[0].set_data(x, np.sin(change.new * x))\n",
" fig.canvas.draw()\n",
" fig.canvas.flush_events()\n",
"\n",
"slider.observe(update_lines, names='value')\n",
"\n",
"AppLayout(\n",
" center=fig.canvas,\n",
" footer=slider,\n",
" pane_heights=[0, 6, 1]\n",
")"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"import matplotlib.pyplot as plt\n",
"from matplotlib.patches import Shadow\n",
"\n",
"# make a square figure and axes\n",
"fig = plt.figure(figsize=(6, 6))\n",
"ax = fig.add_axes([0.1, 0.1, 0.8, 0.8])\n",
"\n",
"labels = 'Frogs', 'Hogs', 'Dogs', 'Logs'\n",
"fracs = [15, 30, 45, 10]\n",
"\n",
"explode = (0, 0.05, 0, 0)\n",
"\n",
"# We want to draw the shadow for each pie but we will not use \"shadow\"\n",
"# option as it does'n save the references to the shadow patches.\n",
"pies = ax.pie(fracs, explode=explode, labels=labels, autopct='%1.1f%%')\n",
"\n",
"for w in pies[0]:\n",
" # set the id with the label.\n",
" w.set_gid(w.get_label())\n",
"\n",
" # we don't want to draw the edge of the pie\n",
" w.set_edgecolor(\"none\")\n",
"\n",
"for w in pies[0]:\n",
" # create shadow patch\n",
" s = Shadow(w, -0.01, -0.01)\n",
" s.set_gid(w.get_gid() + \"_shadow\")\n",
" s.set_zorder(w.get_zorder() - 0.1)\n",
" ax.add_patch(s)\n",
"\n",
"\n",
"# save\n",
"from io import BytesIO\n",
"f = BytesIO()\n",
"plt.savefig(f, format=\"svg\")\n",
"\n",
"import xml.etree.cElementTree as ET\n",
"\n",
"\n",
"# filter definition for shadow using a gaussian blur\n",
"# and lightening effect.\n",
"# The lightening filter is copied from http://www.w3.org/TR/SVG/filters.html\n",
"\n",
"# I tested it with Inkscape and Firefox3. \"Gaussian blur\" is supported\n",
"# in both, but the lightening effect only in the Inkscape. Also note\n",
"# that, Inkscape's exporting also may not support it.\n",
"\n",
"filter_def = \"\"\"\n",
" \n",
" \n",
" \n",
" \n",
"\n",
" \n",
" \n",
" \n",
" \n",
" \n",
" \n",
" \n",
" \n",
" \n",
" \n",
"\"\"\"\n",
"\n",
"\n",
"tree, xmlid = ET.XMLID(f.getvalue())\n",
"\n",
"# insert the filter definition in the svg dom tree.\n",
"tree.insert(0, ET.XML(filter_def))\n",
"\n",
"for i, pie_name in enumerate(labels):\n",
" pie = xmlid[pie_name]\n",
" pie.set(\"filter\", 'url(#MyFilter)')\n",
"\n",
" shadow = xmlid[pie_name + \"_shadow\"]\n",
" shadow.set(\"filter\", 'url(#dropshadow)')\n",
"\n",
"fn = \"svg_filter_pie.svg\"\n",
"print(\"Saving '%s'\" % fn)\n",
"ET.ElementTree(tree).write(fn)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"%matplotlib widget\n",
"import ipywidgets as widgets\n",
"import matplotlib.pyplot as plt\n",
"import numpy as np\n",
"# set up plot\n",
"fig, ax = plt.subplots(figsize=(6, 4))\n",
"ax.set_ylim([-4, 4])\n",
"ax.grid(True)\n",
" \n",
"# generate x values\n",
"x = np.linspace(0, 2 * np.pi, 100)\n",
" \n",
" \n",
"def my_sine(x, w, amp, phi):\n",
" \"\"\"\n",
" Return a sine for x with angular frequeny w and amplitude amp.\n",
" \"\"\"\n",
" return amp*np.sin(w * (x-phi))\n",
" \n",
" \n",
"@widgets.interact(w=(0, 10, 1), amp=(0, 4, .1), phi=(0, 2*np.pi+0.01, 0.01))\n",
"def update(w = 1.0, amp=1, phi=0):\n",
" \"\"\"Remove old lines from plot and plot new one\"\"\"\n",
" [l.remove() for l in ax.lines]\n",
" ax.plot(x, my_sine(x, w, amp, phi), color='C0')\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"%matplotlib inline\n",
"import time\n",
"import pylab as pl\n",
"from IPython import display\n",
"for i in range(10):\n",
" pl.plot(pl.randn(100))\n",
" display.clear_output(wait=True)\n",
" display.display(pl.gcf())\n",
" time.sleep(1.0)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"!pip install drawsvg"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"import drawSvg as draw"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"from IPython.display import SVG, display"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"d = draw.Drawing(200, 200, origin='center')"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"c = draw.Circle(0, 0, 20, fill='red')"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"d.append(c)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"d"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"c0 = d.allElements()[0]"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"c0.args"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"c0.args={'cx': 0, 'cy': 0, 'r': 25, 'fill': 'red'}"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"r = draw.Rectangle(5,5,5,3,fill='blue')"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"d.append(r)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"r.args"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"r.args={'x': 25, 'y': 25, 'width': 25, 'height': 20, 'fill': 'blue'}"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"!pip3 install hyperbolic"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"import drawSvg as draw\n",
"from drawSvg.widgets import DrawingWidget\n",
"import hyperbolic.poincare.shapes as hyper # pip3 install hyperbolic\n",
"\n",
"# Create drawing\n",
"d = draw.Drawing(2, 2, origin='center')\n",
"d.setRenderSize(500)\n",
"d.append(draw.Circle(0, 0, 1, fill='orange'))\n",
"group = draw.Group()\n",
"d.append(group)\n",
"\n",
"# Update the drawing based on user input\n",
"click_list = []\n",
"def redraw(points):\n",
" group.children.clear()\n",
" for x1, y1 in points:\n",
" for x2, y2 in points:\n",
" if (x1, y1) == (x2, y2): continue\n",
" p1 = hyper.Point.fromEuclid(x1, y1)\n",
" p2 = hyper.Point.fromEuclid(x2, y2)\n",
" if p1.distanceTo(p2) <= 2:\n",
" line = hyper.Line.fromPoints(*p1, *p2, segment=True)\n",
" group.draw(line, hwidth=0.2, fill='white')\n",
" for x, y in points:\n",
" p = hyper.Point.fromEuclid(x, y)\n",
" group.draw(hyper.Circle.fromCenterRadius(p, 0.1),\n",
" fill='green')\n",
"redraw(click_list)\n",
"\n",
"# Create interactive widget and register mouse events\n",
"widget = DrawingWidget(d)\n",
"@widget.mousedown\n",
"def mousedown(widget, x, y, info):\n",
" if (x**2 + y**2) ** 0.5 + 1e-5 < 1:\n",
" click_list.append((x, y))\n",
" redraw(click_list)\n",
" widget.refresh()\n",
"@widget.mousemove\n",
"def mousemove(widget, x, y, info):\n",
" if (x**2 + y**2) ** 0.5 + 1e-5 < 1:\n",
" redraw(click_list + [(x, y)])\n",
" widget.refresh()\n",
"widget"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
""
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"!pip install sympy"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"!pip install pydy"
]
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {},
"outputs": [],
"source": [
"from __future__ import print_function, division\n",
"from sympy.physics.mechanics import *\n",
"from sympy.physics.vector import time_derivative\n",
"from sympy import symbols\n",
"from numpy import array, linspace, rad2deg, deg2rad\n",
"from scipy.integrate import odeint\n",
"from pydy.codegen.ode_function_generators import generate_ode_function\n",
"# number of links in the mechanism\n",
"n = 3\n",
"# generalized speeds and coordinates\n",
"theta = dynamicsymbols('theta:{}'.format(n))\n",
"theta_d = dynamicsymbols('theta:{}'.format(n), 1)\n",
"omega = dynamicsymbols('omega:{}'.format(n))\n",
"omega_d = dynamicsymbols('omega:{}'.format(n), 1)\n",
"# the extra symbol thanks to n+1 stands for the distance\n",
"# between the grounding joints\n",
"length_bars = symbols('L_B:{}'.format(n+1))\n",
"g = symbols('g') # gravity"
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {},
"outputs": [],
"source": [
"# reference frames\n",
"inertial_frame = ReferenceFrame('I')\n",
"bar0_frame = inertial_frame.orientnew('B0', 'Axis', (theta[0],\n",
" inertial_frame.z))\n",
"bar1_frame = inertial_frame.orientnew('B1', 'Axis', (theta[1],\n",
" inertial_frame.z))\n",
"bar2_frame = inertial_frame.orientnew('B2', 'Body', [0, 0, theta[2]],\n",
" 'XYZ')\n",
"# angular velocities\n",
"bar0_frame.set_ang_vel(inertial_frame, omega[0]*inertial_frame.z)\n",
"bar1_frame.set_ang_vel(inertial_frame, omega[1]*inertial_frame.z)\n",
"bar2_frame.set_ang_vel(inertial_frame, omega[2]*inertial_frame.z)"
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {},
"outputs": [],
"source": [
"# joints\n",
"joint0 = Point('j0')\n",
"joint1 = joint0.locatenew('j1', length_bars[0] * bar0_frame.x)\n",
"joint2 = joint1.locatenew('j2', length_bars[1] * bar1_frame.x)\n",
"joint3 = joint2.locatenew('j3', -length_bars[2] * bar2_frame.x)\n",
"# cm positions\n",
"bar0_cm = joint0.locatenew('b0cm', length_bars[0]/2 * bar0_frame.x)\n",
"bar1_cm = joint1.locatenew('b1cm', length_bars[1]/2 * bar1_frame.x)\n",
"bar2_cm = joint3.locatenew('b2cm', length_bars[2]/2 * bar2_frame.x)"
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {},
"outputs": [
{
"data": {
"text/latex": [
"$\\displaystyle L_{B0} \\omega_{0}\\mathbf{\\hat{b0}_y} + L_{B1} \\omega_{1}\\mathbf{\\hat{b1}_y} - \\frac{L_{B2} \\omega_{2}}{2}\\mathbf{\\hat{b2}_y}$"
],
"text/plain": [
"L_B0*omega0*B0.y + L_B1*omega1*B1.y - L_B2*omega2/2*B2.y"
]
},
"execution_count": 4,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# velocity of the grounding joints is 0\n",
"joint0.set_vel(inertial_frame, 0)\n",
"joint3.set_vel(inertial_frame, 0)\n",
"# velocity if the remaining joints\n",
"joint1.v2pt_theory(joint0, inertial_frame, bar0_frame)\n",
"joint2.v2pt_theory(joint1, inertial_frame, bar1_frame)\n",
"# velocity if centres of mass\n",
"bar0_cm.v2pt_theory(joint0, inertial_frame, bar0_frame)\n",
"bar1_cm.v2pt_theory(joint1, inertial_frame, bar1_frame)\n",
"bar2_cm.v2pt_theory(joint2, inertial_frame, bar2_frame) "
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {},
"outputs": [],
"source": [
"# configuration constraint\n",
"zero = joint3.pos_from(joint0) + length_bars[3] * inertial_frame.x\n",
"f_c = [zero & inertial_frame.x, zero & inertial_frame.y]\n",
"# velocity constraint\n",
"dzero = time_derivative(zero, inertial_frame)\n",
"f_v = [dzero & inertial_frame.x, dzero & inertial_frame.y] "
]
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {},
"outputs": [],
"source": [
"# mass and inertia\n",
"mass_bars = symbols('m_B:{}'.format(n))\n",
"inertia_bars = symbols('I_B:{}'.format(n))\n",
"# inertia(frame, ixx=0, iyy=0, izz, ixy=0, iyz=0, izx=0)\n",
"bar0_indyad = inertia(bar0_frame, 0, 0, inertia_bars[0])\n",
"bar1_indyad = inertia(bar1_frame, 0, 0, inertia_bars[1])\n",
"bar2_indyad = inertia(bar2_frame, 0, 0, inertia_bars[2])\n",
"bar0_inertia = (bar0_indyad, bar0_cm)\n",
"bar1_inertia = (bar1_indyad, bar1_cm)\n",
"bar2_inertia = (bar2_indyad, bar2_cm)\n",
"# bodies\n",
"bar0 = RigidBody('Bar 0', bar0_cm, bar0_frame, mass_bars[0],\n",
" bar0_inertia)\n",
"bar1 = RigidBody('Bar 1', bar1_cm, bar0_frame, mass_bars[1],\n",
" bar1_inertia)\n",
"bar2 = RigidBody('Bar 1', bar2_cm, bar0_frame, mass_bars[2],\n",
" bar2_inertia)\n",
"bodies = [bar0, bar1, bar2] "
]
},
{
"cell_type": "code",
"execution_count": 7,
"metadata": {},
"outputs": [],
"source": [
"# forces\n",
"bar0_force = (bar0_cm, -mass_bars[0] * g * inertial_frame.y)\n",
"bar1_force = (bar1_cm, -mass_bars[1] * g * inertial_frame.y)\n",
"bar2_force = (bar2_cm, -mass_bars[2] * g * inertial_frame.y)\n",
"loads = [bar0_force, bar1_force, bar2_force] "
]
},
{
"cell_type": "code",
"execution_count": 8,
"metadata": {},
"outputs": [],
"source": [
"# kinematic differential equations\n",
"KDE = [theta_d[0] - omega[0], theta_d[1] - omega[1],\n",
" theta_d[2] - omega[2]]\n",
"# Kanes Method\n",
"kane = KanesMethod(inertial_frame, q_ind=[theta[0]],\n",
" u_ind=[omega[0]],\n",
" q_dependent=[theta[1],theta[2]],\n",
" u_dependent=[omega[1],omega[2]],\n",
" configuration_constraints=f_c,\n",
" velocity_constraints=f_v,\n",
" kd_eqs=KDE)\n",
"fr, frstar = kane.kanes_equations(bodies, loads) "
]
},
{
"cell_type": "code",
"execution_count": 15,
"metadata": {},
"outputs": [],
"source": [
"# list of constants\n",
"constants = [g,\n",
"mass_bars[0],\n",
"mass_bars[1],\n",
"mass_bars[2],\n",
"length_bars[0],\n",
"length_bars[1],\n",
"length_bars[2],\n",
"length_bars[3],\n",
"inertia_bars[0],\n",
"inertia_bars[1],\n",
"inertia_bars[2]]\n",
"kdd = kane.kindiffdict()\n",
"mass_matrix = kane.mass_matrix_full.subs(kdd)\n",
"forcing_vector = kane.forcing_full.subs(kdd)\n",
"right_hand_side = generate_ode_function(forcing_vector,\n",
"theta, omega, constants, mass_matrix=mass_matrix)\n",
"# list of numerical values\n",
"numerical_constants = [9.81,\n",
"2.0,\n",
"5.0,\n",
"4.0,\n",
"2.0,\n",
"5.0,\n",
"5.0,\n",
"4.0,\n",
"1.0,\n",
"1.0,\n",
"1.0]\n",
"# inital conditions\n",
"x0 = array([deg2rad(135), deg2rad(41.3340), deg2rad(109.3884), 0.0,\n",
"0.0, 0.0])\n",
"# timeframe\n",
"frames_per_sec = 100\n",
"final_time = 20.0\n",
"t = linspace(0.0, final_time, int(final_time * frames_per_sec))\n",
"# integration\n",
"y = odeint(right_hand_side, x0, t,\n",
"args=(dict(zip(constants, numerical_constants)),))"
]
},
{
"cell_type": "code",
"execution_count": 20,
"metadata": {},
"outputs": [],
"source": [
"from matplotlib import pyplot as plt"
]
},
{
"cell_type": "code",
"execution_count": 21,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"[,\n",
" ,\n",
" ,\n",
" ,\n",
" ,\n",
" ]"
]
},
"execution_count": 21,
"metadata": {},
"output_type": "execute_result"
},
{
"data": {
"image/png": "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\n",
"text/plain": [
""
]
},
"metadata": {
"needs_background": "light"
},
"output_type": "display_data"
}
],
"source": [
"plt.plot(t,y)"
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {},
"outputs": [],
"source": [
"car = \"\"\"\\\n",
"!!omap\n",
"- name: car\n",
"- parts:\n",
" - name: head\n",
" shapes:\n",
" libraries: ['from math import tan, radians, sin, cos', 'from pysketcher import *']\n",
" - name: constants\n",
" shapes:\n",
" R: 1.0 # radius of wheel\n",
" L: 4.0 # distance between wheels\n",
" H: 2.0 # height of vehicle body\n",
" w_1: 5.0 # position of front wheel\n",
" - name: frame\n",
" shapes:\n",
" xmax: w_1 + 2*L + 3*R\n",
" setframe:\n",
" action: drawing_tool.set_coordinate_system(xmin=0, xmax=xmax,\n",
" ymin=-1, ymax=2*R + 3*H,\n",
" axis=False)\n",
" wheel1: |\n",
" Composition({'wheel': Circle(center=(w_1, R), radius=R),\n",
" 'cross': Composition({'cross1': Line((w_1,0),(w_1,2*R)),\n",
" 'cross2': Line((w_1-R,R), (w_1+R,R))})})\n",
" wheel2: \n",
" formula: wheel1.copy()\n",
" transform: translate((L,0))\n",
"\n",
" under: Rectangle(lower_left_corner=(w_1-2*R, 2*R),\n",
" width=2*R + L + 2*R, height=H)\n",
" over: Rectangle(lower_left_corner=(w_1, 2*R + H),\n",
" width=2.5*R, height=1.25*H)\n",
"\n",
" wheels: | \n",
" Composition({'wheel1': wheel1, 'wheel2': wheel2})\n",
" body: |\n",
" Composition({'under': under, 'over': over})\n",
"\n",
" vehicle: |\n",
" Composition({'wheels': wheels, 'body': body})\n",
" ground: Wall(x=[R, xmax], y=[0, 0], thickness=-0.3*R)\n",
"\n",
" car: |\n",
" Composition({'vehicle': vehicle, 'ground': ground})\n",
"\"\"\""
]
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {},
"outputs": [],
"source": [
"from ruamel.yaml import YAML"
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {},
"outputs": [],
"source": [
"from pysketcher import *"
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {},
"outputs": [],
"source": [
"yaml = YAML()"
]
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {},
"outputs": [],
"source": [
"ycar = yaml.load(car)"
]
},
{
"cell_type": "code",
"execution_count": 18,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"\"Composition({'wheel': Circle(center=(w_1, R), radius=R),'cross': Composition({'cross1': Line((w_1,0),(w_1,2*R)),'cross2': Line((w_1-R,R), (w_1+R,R))})})\""
]
},
"execution_count": 18,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"\"\".join([s.strip() for s in ycar['parts'][2]['shapes']['wheel1'].split(\"\\n\")])"
]
},
{
"cell_type": "code",
"execution_count": 14,
"metadata": {},
"outputs": [
{
"ename": "NameError",
"evalue": "name 'w_1' is not defined",
"output_type": "error",
"traceback": [
"\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
"\u001b[1;31mNameError\u001b[0m Traceback (most recent call last)",
"\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mwheel1\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mexec\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34mf\"wheel1 = {ycar['parts'][2]['shapes']['wheel1']}\"\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
"\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m\u001b[0m\n",
"\u001b[1;31mNameError\u001b[0m: name 'w_1' is not defined"
]
}
],
"source": [
"wheel1 = exec(f\"wheel1 = {ycar['parts'][2]['shapes']['wheel1']}\")"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.8.5"
}
},
"nbformat": 4,
"nbformat_minor": 4
}