migrate_params copy.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pyautogui as gui\n",
    "import pywinauto as wind\n",
    "import pytesseract\n",
    "from time import sleep\n",
    "import time\n",
    "from pywinauto.application import Application\n",
    "import path_location\n",
    "import re\n",
    "from PIL import ImageFilter\n",
    "from IPython.display import display as disp_img_inline\n",
    "\n",
    "pytesseract.pytesseract.tesseract_cmd = path_location.TESSERACT_LOC\n",
    "RST_LOCATION = path_location.RST_LOCATION\n",
    "\n",
    "if RST_LOCATION is None:\n",
    "    print('Path to RST cannot be found')\n",
    "    quit()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def click_here(x=None, y=None, pause=None, debug=False):\n",
    "    gui.moveTo(x, y, pause=pause)\n",
    "    if debug:\n",
    "        gui.press('ctrl', presses=2, interval=.7)\n",
    "    gui.click()\n",
    "\n",
    "def get_app_prop(app):\n",
    "    app_prop = app.rectangle()\n",
    "    return (app_prop.left, app_prop.top, app_prop.width(), app_prop.height())\n",
    "\n",
    "def get_app_prop2(app):\n",
    "    app_prop = app.client_rect()\n",
    "    return app_prop.width(), app_prop.height()\n",
    "\n",
    "def get_sreenshot(app=None, wind_stat=None, screenname=None):\n",
    "    if screenname is not None:\n",
    "        screenname = 'screenshots/'+screenname\n",
    "        if not screenname.endswith('.png'):\n",
    "            screenname+='.png'\n",
    "    else:\n",
    "        screenname = str(time.time())+'.png'\n",
    "\n",
    "    if app != None:\n",
    "        app.set_focus()\n",
    "        app_prop = get_app_prop(app)\n",
    "        wind_stat = (app_prop[0], app_prop[1], app_prop[2], app_prop[3])\n",
    "    elif wind_stat == None:\n",
    "        print('[ERROR] Either app object or custom box has to be passed')\n",
    "        return None\n",
    "    return gui.screenshot(imageFilename=screenname, region=wind_stat)\n",
    "\n",
    "def image_convert(image):\n",
    "    greyscale = image.convert('L')\n",
    "    blackwhite = greyscale.point(lambda x: 0 if x < 200 else 255, '1')\n",
    "    return image\n",
    "    # return blackwhite"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "def app_get_region(app, x, y, width=10, height=10, use_ratio=False, draw_outline=True):\n",
    "    # PCARS 2 options change based on windows size (resolution)\n",
    "    if use_ratio:\n",
    "        app_h = app.client_rect().height()\n",
    "        app_w = app.client_rect().width()\n",
    "        x = x * app_w/1768\n",
    "        y = y * app_h/992\n",
    "        width = width * app_w/1768\n",
    "        height = height * app_h/992\n",
    "    x,y,width,height = int(x),int(y),int(width),int(height)\n",
    "    x, y = app.client_to_screen((x,y))\n",
    "    \n",
    "    if draw_outline:\n",
    "        class cusrect:\n",
    "            left=x\n",
    "            top=y\n",
    "            right=left+width\n",
    "            bottom=top+height\n",
    "\n",
    "        for _ in range(25):\n",
    "            app.draw_outline(rect=cusrect)\n",
    "    # gui.moveTo(x, y)\n",
    "    return x, y, width, height"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def ocr(img, v1=False, raw=False):\n",
    "    if v1:\n",
    "        return pytesseract.image_to_string(img).split('\\n')\n",
    "    else:\n",
    "        import io\n",
    "        import json\n",
    "        import cv2\n",
    "        import numpy as np\n",
    "        import requests\n",
    "\n",
    "        img.save(\"screenshot.jpg\")\n",
    "        img = cv2.imread(\"screenshot.jpg\")\n",
    "        url_api = \"https://api.ocr.space/parse/image\"\n",
    "        _, compressedimage = cv2.imencode(\".jpg\", img, [1, 90])\n",
    "        file_bytes = io.BytesIO(compressedimage)\n",
    "\n",
    "        result = requests.post(url_api,\n",
    "                    files = {\"screenshot.jpg\": file_bytes},\n",
    "                    data = {\"apikey\": path_location.OCR_SPACE_API_KEY,\n",
    "                            \"language\": \"eng\",'isOverlayRequired':raw})\n",
    "        result = result.content.decode()\n",
    "        result = json.loads(result)\n",
    "        if raw:\n",
    "            return result\n",
    "        parsed_results = result.get(\"ParsedResults\")[0]\n",
    "        return parsed_results.get(\"ParsedText\").split()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": "D:\\Users\\GV\\Anaconda3\\lib\\site-packages\\pywinauto\\application.py:1087: UserWarning: 32-bit application should be automated using 32-bit Python (you use 64-bit Python)\n  UserWarning)\n"
    }
   ],
   "source": [
    "try:\n",
    "    pc2 = Application().connect(title_re='.*Project CARS 2.*')['Project Cars 2']\n",
    "except wind.findwindows.ElementNotFoundError:\n",
    "    print('[ERROR] Launch PCARS 2 first')\n",
    "    \n",
    "try:\n",
    "    rst = Application().connect(title_re='MainWindow').MainWindow\n",
    "except wind.findwindows.ElementNotFoundError:\n",
    "    rst = Application().start(RST_LOCATION+'\\\\RST Software.exe').MainWindow\n",
    "except wind.findwindows.ElementAmbiguousError:\n",
    "    print('[ERROR] Sad, but for now, close the params child window.')\n",
    "\n",
    "try:\n",
    "    pc2\n",
    "    rst\n",
    "except NameError:\n",
    "    print('[ERROR] An aplication failed to run')\n",
    "    quit()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "outputs": [],
   "source": [
    "## RST"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def open_rst_params():\n",
    "    rst.set_focus()\n",
    "    RST_FILE_OFFSET_X = 350\n",
    "    RST_FILE_OFFSET_Y = 10\n",
    "    RST_NEXT_OFFSET_X = RST_FILE_OFFSET_X+10\n",
    "    RST_NEXT_OFFSET_Y = RST_FILE_OFFSET_Y+75\n",
    "\n",
    "    #Select file\n",
    "    x, y, width, height = app_get_region(rst, RST_FILE_OFFSET_X, RST_FILE_OFFSET_Y, 60, 40, draw_outline=True)\n",
    "    click_here(x=x+width/2, y=y+height/2, pause=0.5)\n",
    "    \n",
    "    #Select next car parameters\n",
    "    x, y, width, height = app_get_region(rst, RST_NEXT_OFFSET_X, RST_NEXT_OFFSET_Y, 280, 30, draw_outline=True)\n",
    "    click_here(x=x+width/2, y=y+height/2, pause=0.5)\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "def open_rst_settings(settings):\n",
    "    def find_rst_settings(pos):\n",
    "        setup_bar_width = get_app_prop2(rst)[0]\n",
    "        mid_op = setup_bar_width/4\n",
    "        return (int(mid_op*pos), int(setup_bar_width/4))\n",
    "        \n",
    "    settings_type = {'suspension':1, 'dampers':2, 'gearing':3}\n",
    "    rst.set_focus()\n",
    "    x, width = find_rst_settings(settings_type[settings])\n",
    "    x, y, width, height = app_get_region(rst, x, 70, width, 40, draw_outline=True)\n",
    "    click_here(x+width/2, y+height/2, pause=.5, debug=True)\n",
    "\n",
    "open_rst_params()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "outputs": [],
   "source": [
    "## PCARS2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_stats_gear_pc2():\n",
    "    # Select ECU menu\n",
    "    rst.set_focus()\n",
    "    pc2.set_focus()\n",
    "    pos = app_get_region(pc2, x=int(get_app_prop2(pc2)[0]/2)+250, y=250, use_ratio=True)\n",
    "    click_here(pos[0], pos[1])\n",
    "\n",
    "    x, y, width, height = app_get_region(pc2, x=949, y=520,  width=70, height=210, use_ratio=True)\n",
    "    content = image_convert(get_sreenshot(wind_stat=(x, y, width, height), screenname='Gear.png'))\n",
    "    return ocr(content)\n",
    "\n",
    "def set_stats_gear_rst(gears):\n",
    "    rst.set_focus()\n",
    "    rst_pos_x, rst_pos_y = rst.rectangle().left, rst.rectangle().top\n",
    "    rst_pos_height, rst_pos_width = rst.rectangle().height(), rst.rectangle().width()\n",
    "    rst_width_mid = rst_pos_x+rst_pos_width/2\n",
    "    rst_y_firstfield = rst_pos_y+180\n",
    "    for gear, val in enumerate(gears):\n",
    "        gui.click((rst_width_mid, rst_y_firstfield+55*gear))\n",
    "        try:\n",
    "            float(val)\n",
    "            gui.typewrite(val)\n",
    "        except ValueError:\n",
    "            print(f'[ERROR] Gear {gear} ({val}) not a number')\n",
    "            gui.typewrite('0')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "outputs": [],
   "source": [
    "gears = get_stats_gear_pc2()\n",
    "open_rst_settings('gearing')\n",
    "set_stats_gear_rst(gears)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def retriev_ocr(content, debug=True):\n",
    "    img=content\n",
    "    results = ocr(content)\n",
    "    content = []\n",
    "    if len(results) == 0:\n",
    "        content.append('1')\n",
    "    else:\n",
    "        for val in results:\n",
    "            try:\n",
    "                content.append(re.match('\\\\d+', val).group())\n",
    "            except:\n",
    "                content.append('0')\n",
    "    if debug:\n",
    "        disp_img_inline(img)\n",
    "        print(f'{results}\\t->\\t{content}')\n",
    "        print()\n",
    "    return content\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_stats_sus_pc2():\n",
    "    # Select suspension menu\n",
    "    pc2.set_focus()\n",
    "    pos = app_get_region(pc2, x=int(get_app_prop2(pc2)[0]/2)-200, y=250, use_ratio=True)\n",
    "    click_here(pos[0], pos[1])\n",
    "\n",
    "    # Get front spring\n",
    "    x, y, width, height = app_get_region(pc2, x=600, y=497,  width=90, height=23, use_ratio=True)\n",
    "    content = image_convert(get_sreenshot(wind_stat=(x, y, width, height), screenname='sus_front_spring'))\n",
    "    f_spring = retriev_ocr(content)[0]\n",
    "\n",
    "    # Get rear spring\n",
    "    x, y, width, height = app_get_region(pc2, x=600, y=737,  width=90, height=23, use_ratio=True)\n",
    "    content = image_convert(get_sreenshot(wind_stat=(x, y, width, height), screenname='sus_rear_spring.png'))\n",
    "    r_spring = retriev_ocr(content)[0]\n",
    "    \n",
    "    # Get front antirollbar\n",
    "    x, y, width, height = app_get_region(pc2, 935, y=470,  width=90, height=26, use_ratio=True)\n",
    "    content = image_convert(get_sreenshot(wind_stat=(x, y, width, height), screenname='sus_front_arb.png'))\n",
    "    f_ar = retriev_ocr(content)[0]\n",
    "    \n",
    "    # Get rear antirollbar\n",
    "    x, y, width, height = app_get_region(pc2, 935, y=710,  width=90, height=26, use_ratio=True)\n",
    "    content = image_convert(get_sreenshot(wind_stat=(x, y, width, height), screenname='sus_rear_arb.png'))\n",
    "    r_ar = retriev_ocr(content)[0]\n",
    "    \n",
    "    return f_spring, r_spring, f_ar, r_ar\n",
    "\n",
    "def set_stats_sus_rst(stats):\n",
    "    rst.set_focus()\n",
    "    \n",
    "    prop= get_app_prop2(rst)\n",
    "    seperator = prop[0]/3\n",
    "    start = seperator/2\n",
    "\n",
    "    pos = app_get_region(rst, x=start, y=230)\n",
    "    gui.click(pos[0], pos[1])\n",
    "    gui.typewrite(stats[0])\n",
    "\n",
    "    pos = app_get_region(rst, x=start+seperator, y=230)\n",
    "    gui.click(pos[0], pos[1])\n",
    "    gui.typewrite(stats[2])\n",
    "\n",
    "    pos = app_get_region(rst, x=start, y=435)\n",
    "    gui.click(pos[0], pos[1])\n",
    "    gui.typewrite(stats[1])\n",
    "\n",
    "    pos = app_get_region(rst, x=start+seperator, y=435)\n",
    "    gui.click(pos[0], pos[1])\n",
    "    gui.typewrite(stats[3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": "<PIL.Image.Image image mode=RGB size=90x23 at 0x295A7596F88>"
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": "['158N', 'Imm']\t->\t['158', '0']\n\n"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": "<PIL.Image.Image image mode=RGB size=90x23 at 0x295C1E59908>"
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": "['16bNjmm']\t->\t['16']\n\n"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": "<PIL.Image.Image image mode=RGB size=90x26 at 0x295C0FBA088>"
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": "['130', 'N/mm']\t->\t['130', '0']\n\n"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAFoAAAAaCAIAAAC4ktw5AAAFL0lEQVR4nO2ZS0gbXRTHj87YiJmqFU2QWqVplPogik3whVLUWrTGjWhppVpE3fhAaZFKRBeCQq2PjRXSFEWLEBpqhSgqgaDgQuxCpaRJSFWslBrj6JiHxjjOtxjIp7U+Oim1i/xWM/f+751z/nNy53LjARS4cYICAIIilx3G5UMekADgedlh/Fu47TjGv2hHamqqSqVqbm7++4921Y7MzEyZTKZUKjs7O/l8vrO9srJSLpcPDg6WlJQAQFRUlFwur66uPjq2tLS0v7+fw+H8NGdRUZFAIHA4HC7GxggKEKYUFxdvbGxYLJbV1dX9/X29Xn/nzh0EQaRS6dbWlslkMplMBEG0tLQUFxdTFGU0GgUCgXO4QqHY3t6+e/fu0TmvXr06Pz+/urqakJDAODAGAAVAuVAdCILU19djGCaRSHJycqRSKY/He/bsmUgkys3NXV9ff/LkSVVV1c7OTklJCYIgAODv79/Q0HD2tPfu3YuJiVlbW/v06RPj2BiDMh7p7+9vtVonJyd7e3tJknz79m1FRUVERASfz/f29lYoFJOTkwDw9OnTjIwMX19fAPj69Wt+fv7MzExvb+9p0+bl5REEoVQqASAxMdFms2EYxuVytVrtly9fAgMDk5OTWSyWSqXa2tq6oOZv2LG5uZmamgoAJEkCgEAgAICTj6d7afR6fWhoaG1t7fv3700m08k5WSxWbGzszs7O+Ph4UlLShw8fvn37xuPxUBTFcXxqakooFAYHB3t5eRkMhrq6OofDca5menr64km5tJSSJEmSZFRU1Lt37xobG7e3t0dGRs7Q22y2iYkJDofz4sWLGzdunBSkp6fzeDyDwbCwsMBmswMCAkJDQz9+/Dg4OOjl5fX48eMrV65IpVKFQnHz5k2JRHIRzW9lxLw6nHC53OTkZF9fX6PRqNPpuFzuacq9vb3W1laRSFRWVvbLpaGgoMBut4+Pj9O3FEVpNJqysjIAQFH04cOHcrm8qanJx8cnKSkpJSWlp6fnXA2fzzcYDBfM5Q/sO9RqdXZ29ps3b8LCwurr689QOhwOjUYjk8koiqqoqLh+/frRXgzD4uPj6V+Ks9FqtdIXOI6TJLm+vg4ANpuNIAgEQTw8PM7VoOhvvHKX7BCLxbdv3wYAnU738uXL79+/h4eH0x+RM2hra1tYWIiLiwsJCTnafv/+/ZCQEL1er9VqTxtLUdRPF8w0p8HcjvDw8Pb29tevX7NYLAC4du0ahmGenp4EQRweHjo3V2w2e3d39+ieiiTJ9vZ2FEWDgoI8Pf8PQCwWHxwcqNVqxiG5DvO1Y2lpCcfx6Ojo7u7uz58/p6en+/j4zM3Nzc7O/vjxIyUlRSKRYBgWFxen0+mc9UwzOjoqk8lqamqcpeTn5ycUCs1ms0qlcikh12BeHfRLXllZyc3NbWhoEIlEc3Nzz58/NxqNPT09ZrO5vLz80aNHOI53dHTY7fbDw0ObzeYc3tLSsri4iOO43W4HgLy8PA6HYzAYFhcXacH+/r7VajWbzfQtfe201WKxmM1mu91+rua3NvseQLl03hEcHJydnR0UFLS8vKxUKp0JR0dHp6WlAYBardZqtX5+fg8ePNBoNPPz886xQqEwMjJyaGiIJMmBgYGMjIxXr151dXXRvSwWq7CwUK/Xz87OAkBYWFhaWtrw8LDFYgGArKwsNps9NjZ2rmZ4ePgiidDnHa7a8acQi8W3bt3q6+sjCOJSAvi37Lh03Kdhv8BtxzHcdhzDbccxPNz/sxzFXR3H+A+FRamMRlB4BgAAAABJRU5ErkJggg==\n",
      "text/plain": "<PIL.Image.Image image mode=RGB size=90x26 at 0x295C239E248>"
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": "[]\t->\t['0']\n\n"
    }
   ],
   "source": [
    "stats = get_stats_sus_pc2()\n",
    "open_rst_settings('suspension')\n",
    "set_stats_sus_rst(stats)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "def image_convert(image, apply_correcttion = False, ifilter=None):\n",
    "    greyscale = image.convert('L')\n",
    "    blackwhite = greyscale.point(lambda x: 0 if x < 200 else 255, '1')\n",
    "    if ifilter is not None:\n",
    "        if ifilter not in [ImageFilter.SHARPEN,ImageFilter.DETAIL,ImageFilter.EDGE_ENHANCE,ImageFilter.EDGE_ENHANCE_MORE]:\n",
    "            ifilter = ImageFilter.EDGE_ENHANCE_MORE\n",
    "        blackwhite = blackwhite.filter(ifilter)\n",
    "    return blackwhite if apply_correcttion else image\n",
    "\n",
    "# Select dampers menu\n",
    "rst.set_focus()\n",
    "pc2.set_focus()\n",
    "\n",
    "# Get front damp\n",
    "x, y, width, height = app_get_region(pc2, x=595, y=415,  width=95, height=183, use_ratio=True)\n",
    "content = image_convert(get_sreenshot(wind_stat=(x, y, width, height), screenname='sus_front_damp'), apply_correcttion=1)\n",
    "f_damp = retriev_ocr(content)\n",
    "content"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "from PIL import Image\n",
    "for ifilter_type in [ImageFilter.SHARPEN,ImageFilter.DETAIL,ImageFilter.EDGE_ENHANCE,ImageFilter.EDGE_ENHANCE_MORE]:\n",
    "    content =  image_convert(Image.open('screenshots/sus_front_damp.png'), ifilter=ifilter_type)\n",
    "    f_damp = retriev_ocr(content)\n",
    "    content.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_stats_damp_pc2():\n",
    "    # Select dampers menu\n",
    "    pc2.set_focus()\n",
    "    pc2.set_focus()\n",
    "    pos = app_get_region(pc2, x=int(get_app_prop2(pc2)[0]/2), y=250, use_ratio=True)\n",
    "    gui.click(pos[0], pos[1])\n",
    "\n",
    "    # Get front damp\n",
    "    x, y, width, height = app_get_region(pc2, x=595, y=445,  width=95, height=105, use_ratio=True)\n",
    "    content = image_convert(get_sreenshot(wind_stat=(x, y, width, height), screenname='sus_front_damp'))\n",
    "    f_damp = retriev_ocr(content)\n",
    "\n",
    "    # Get rear damp\n",
    "    x, y, width, height = app_get_region(pc2, x=595, y=710,  width=95, height=105, use_ratio=True)\n",
    "    content = image_convert(get_sreenshot(wind_stat=(x, y, width, height), screenname='sus_rear_damp'))\n",
    "    r_damp = retriev_ocr(content)\n",
    "    \n",
    "    return f_damp, r_damp\n",
    "\n",
    "def set_stats_sus_rst(stats):\n",
    "    print(stats)\n",
    "    rst.set_focus()\n",
    "    \n",
    "    prop= get_app_prop2(rst)\n",
    "    x_seperator_width = int(prop[0]/3)\n",
    "    x_start = int(x_seperator_width/2)\n",
    "\n",
    "    y_seperator_width = 50\n",
    "    y_start_front = 230\n",
    "    y_start_rear = 485\n",
    "\n",
    "    front_damp = stats[0]\n",
    "    rear_damp = stats[1]\n",
    "\n",
    "    if len(front_damp) < 4:\n",
    "        front_damp.extend(['1']*(4-len(front_damp)))\n",
    "\n",
    "    if len(rear_damp) < 4:\n",
    "        rear_damp.extend(['1']*(4-len(rear_damp)))\n",
    "\n",
    "    for pos, stat in enumerate(front_damp):\n",
    "        gui_pos = app_get_region(rst, x=x_start, y=pos*y_seperator_width+y_start_front)\n",
    "        gui.click(gui_pos[0], gui_pos[1])\n",
    "        gui.typewrite(stat)\n",
    "\n",
    "    for pos, stat in enumerate(rear_damp):\n",
    "        gui_pos = app_get_region(rst, x=x_start, y=pos*y_seperator_width+y_start_rear)\n",
    "        gui.click(gui_pos[0], gui_pos[1])\n",
    "        gui.typewrite(stat)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": "<PIL.Image.Image image mode=RGB size=95x105 at 0x295C1A0A448>"
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": "['1000mq/m/s', '1350m', '/m/s', '5050N/m/s']\t->\t['1000', '1350', '0', '5050']\n\n"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": "<PIL.Image.Image image mode=RGB size=95x105 at 0x295C32A0CC8>"
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": "['8000N/m/s', '11500N/m/s', '3100N/m/s', '535(N/m/s']\t->\t['8000', '11500', '3100', '535']\n\n(['1000', '1350', '0', '5050'], ['8000', '11500', '3100', '535'])\n"
    }
   ],
   "source": [
    "stats = get_stats_damp_pc2()\n",
    "open_rst_settings('dampers')\n",
    "set_stats_sus_rst(stats)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.7.5 64-bit ('base': conda)",
   "language": "python",
   "name": "python37564bitbaseconda5950fb8ebac345108099a9618627f470"
  },
  "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.7.5-final"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}