Cairo - Canvas and intermediate output - 6.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "%reload_ext cairo_jupyter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAIAAAACACAYAAADDPmHLAAAABmJLR0QA/wD/AP+gvaeTAAAAuklEQVR4nO3SMRHAMBDAsE/5c06HgsillhB48Nozey6zZtbphr94TgdwlgHiDBBngDgDxBkgzgBxBogzQJwB4gwQZ4A4A8QZIM4AcQaIM0CcAeIMEGeAOAPEGSDOAHEGiDNAnAHiDBBngDgDxBkgzgBxBogzQJwB4gwQZ4A4A8QZIM4AcQaIM0CcAeIMEGcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD4vMlBAlqLYgb6AAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import asyncio\n",
    "import cairo\n",
    "\n",
    "from contextlib import contextmanager\n",
    "from io import BytesIO\n",
    "from pathlib import Path\n",
    "\n",
    "from IPython.display import display\n",
    "\n",
    "FORMAT_PS = 'ps'\n",
    "FORMAT_PDF = 'pdf'\n",
    "FORMAT_PNG = 'png'\n",
    "FORMAT_SVG = 'svg'\n",
    "FORMAT_SVG_XML = 'svg_xml'\n",
    "\n",
    "VALID_FORMATS = [FORMAT_PNG, FORMAT_SVG, FORMAT_SVG_XML]\n",
    "\n",
    "ERROR_UNSUPPORTED_FORMAT = \"Format must be FORMAT_PDF, FORMAT_PNG, FORMAT_PS, FORMAT_SVG or FORMAT_SVG_XML\"\n",
    "\n",
    "class BufferedCanvas:\n",
    "    \"\"\"\n",
    "    Uses a RecordingSurface to keep track of the draw state on the current frame/page,\n",
    "    and allowing it to be copied to various outputs as needed.\n",
    "    \"\"\"\n",
    "    def __init__(self, extents=None):\n",
    "        \"\"\"\n",
    "        :param dimensions: Extents of recording surface, or None for unbounded.\n",
    "        \"\"\"\n",
    "        self.surface = cairo.RecordingSurface(cairo.CONTENT_COLOR_ALPHA, extents) \n",
    "    \n",
    "    def copy_to_surface(self, surface):\n",
    "        # Draw self.surface onto another surface\n",
    "        ctx = cairo.Context(surface)\n",
    "        ctx.set_source_surface(self.surface)\n",
    "        ctx.paint()\n",
    "        del ctx\n",
    "\n",
    "    def save(self, f, format=None, *args, **kwargs):\n",
    "        \"\"\"\n",
    "        Output current canvas frame, using cairo to save.\n",
    "        \n",
    "        :param f: buffer or filename.\n",
    "        \"\"\"\n",
    "        if not format:\n",
    "            if isinstance(f, str):\n",
    "                suffix = Path(f).suffix\n",
    "                format = suffix.rsplit('.')[-1] or FORMAT_PNG\n",
    "            else:\n",
    "                format = FORMAT_PNG\n",
    "        \n",
    "        extents = self.surface.ink_extents()  # TODO: handle ink_extents that don't start at 0, 0\n",
    "        dimensions = extents[2], extents[3]\n",
    "        if format == FORMAT_PNG:\n",
    "            # PNG is special: write_to_png is called after drawing.\n",
    "            surface = cairo.ImageSurface(cairo.FORMAT_ARGB32, int(dimensions[0]), int(dimensions[1]))\n",
    "            self.copy_to_surface(surface)\n",
    "            surface.write_to_png(f)\n",
    "            return\n",
    "        elif format == FORMAT_PDF:\n",
    "            surface = cairo.PDFSurface(f, *dimensions)\n",
    "        elif format == FORMAT_PS:\n",
    "            surface = cairo.PDFSurface(f, *dimensions)\n",
    "        elif format in (FORMAT_SVG, FORMAT_SVG_XML):\n",
    "            surface = cairo.SVGSurface(f, *dimensions)\n",
    "        else:\n",
    "            raise ValueError(ERROR_UNSUPPORTED_FORMAT)\n",
    "            \n",
    "        self.copy_to_surface(surface)\n",
    "        surface.flush()  # Ensure data written to file or buffer.\n",
    "\n",
    "    def display(self, format=None, *args, **kwargs):\n",
    "        \"\"\"\n",
    "        \"\"\"\n",
    "        from IPython.display import Image, SVG, display as _display\n",
    "\n",
    "        if format in (FORMAT_PDF, FORMAT_PS):\n",
    "            raise NotImplementedError(f\"{format} is not yet supported.\")\n",
    "        \n",
    "        if format is None:\n",
    "            if not args and self.surface.ink_extents() == (.0, .0, .0, .0):\n",
    "                format = FORMAT_SVG  # 0 size images are legal in SVG.\n",
    "            else:\n",
    "                format = FORMAT_PNG\n",
    "        \n",
    "        with BytesIO() as buffer:\n",
    "            self.save(buffer, format, *args)\n",
    "            if format == FORMAT_PNG:\n",
    "                _display(Image(data=buffer.getvalue()))\n",
    "            elif format == FORMAT_SVG:\n",
    "                _display(SVG(buffer.getvalue()))\n",
    "            elif format == FORMAT_SVG_XML:\n",
    "                try:\n",
    "                    from display_xml import XML\n",
    "                except ImportError:\n",
    "                    raise ImportError('Install display_xml to output as XML:  $ pip3 install display_xml')\n",
    "\n",
    "                _display(XML(buffer.getvalue()))\n",
    "            else:\n",
    "                # Included for completeness, should have been caught by the call to save().\n",
    "                raise ValueError(ERROR_UNSUPPORTED_FORMAT)\n",
    "    \n",
    "    @contextmanager\n",
    "    def recording_surface(self, extents=None):\n",
    "        _surface = self.surface\n",
    "        self.surface = surface = cairo.RecordingSurface(cairo.CONTENT_COLOR_ALPHA, extents)\n",
    "        try:\n",
    "            yield surface\n",
    "        except:\n",
    "            self.surface = _surface\n",
    "            raise\n",
    "        \n",
    "        # No exceptions were raised, draw\n",
    "        cr = cairo.Context(_surface)\n",
    "        cr.set_source_surface(surface)\n",
    "        cr.paint()\n",
    "        \n",
    "        self.surface = _surface\n",
    "\n",
    "# TODO\n",
    "# class AnimationState:\n",
    "#     def __init__(self, speed = None):\n",
    "#         self.speed = speed\n",
    "    \n",
    "#     def is_animation(self):\n",
    "#         return self.speed is None\n",
    "\n",
    "class SourceStateWatcher:\n",
    "    \"\"\"\n",
    "    SourceStateWatcher is the base class for different ways of accepting source\n",
    "    and state.\n",
    "    \n",
    "    This makes it possible to build APIs that update source, and get feedback if\n",
    "    there are issues with it.\n",
    "    \"\"\"\n",
    "    def get_updated_source(self):\n",
    "        \"\"\"\n",
    "        :return:   New source if source updated, otherwise None\n",
    "        \"\"\"\n",
    "        pass\n",
    "    \n",
    "    def get_updated_state(self):\n",
    "        \"\"\"\n",
    "        :return  Dict of updated states if any were updated, otherwise None.\n",
    "        \"\"\"\n",
    "        pass\n",
    "    \n",
    "    def source_error(self, source, error):\n",
    "        \"\"\"\n",
    "        If there was an error with the source, runner will call this so that\n",
    "        the watcher can optionally propogate the error back to it's source.\n",
    "        \"\"\"\n",
    "        pass\n",
    "    \n",
    "    def state_error(self, ns, error):\n",
    "        \"\"\"\n",
    "        If there was an error with the state, runner will call this so that\n",
    "        the watcher can optionally propogate the error back to it's source.\n",
    "        \"\"\"\n",
    "        pass\n",
    "    \n",
    "    def source_updated(self, code):\n",
    "        \"\"\"\n",
    "        :param code: If code was successfully run ny the runner this method is called.\n",
    "        \"\"\"\n",
    "        pass\n",
    "    \n",
    "    def state_updated(self, ns):\n",
    "        \"\"\"\n",
    "        :param ns: If state was updated successfully this method is called by the runner.\n",
    "        \"\"\"\n",
    "        pass\n",
    "\n",
    "\n",
    "class SourceStateFileWatcher(SourceStateWatcher):\n",
    "    \"\"\"\n",
    "    Watch files for source, and optionally state.\n",
    "    \"\"\"\n",
    "    def __init__(self, source_path, ns_path):\n",
    "        \"\"\"\n",
    "        \"\"\"\n",
    "        SourceStateWatcher.__init__()\n",
    "        self.source_path = source_path\n",
    "        self.ns_path = ns_path\n",
    "        \n",
    "    def get_updated_source(self):\n",
    "        \"\"\"\n",
    "        :return:   New source if source updated, otherwise None\n",
    "        \"\"\"\n",
    "        pass\n",
    "    \n",
    "    def get_updated_state(self):\n",
    "        \"\"\"\n",
    "        :return  Dict of updated states if any were updated, otherwise None.\n",
    "        \"\"\"\n",
    "        pass\n",
    "    \n",
    "\n",
    "class SourceStateHttpServer(SourceStateWatcher):\n",
    "    \"\"\"\n",
    "    Provide an HTTP server that editors and other apps can\n",
    "    connect to do update source or state.\n",
    "    \"\"\"\n",
    "    # TODO work out how to build this using async, would probably need some restructuring.\n",
    "    def __init__(self, key):\n",
    "        self.key = key\n",
    "        \n",
    "class SourceState:\n",
    "    def __init__(self, source=None, ns=None):\n",
    "        if source is None:\n",
    "            source = \"\\n\\n\"\n",
    "        if ns is None:\n",
    "            ns = {}\n",
    "        \n",
    "        self.source = source\n",
    "        self.ns = ns\n",
    "    \n",
    "    def update(self, watchers):\n",
    "        for watcher in self.watchers:\n",
    "            pass\n",
    "        \n",
    "    def do_exec(self):\n",
    "        pass\n",
    "    \n",
    "    \n",
    "\n",
    "class ShoebotContext:\n",
    "    def __init__(self, canvas, ns=None):\n",
    "        if ns is not None:\n",
    "            self._ns = {}\n",
    "        else:\n",
    "            self._ns = ns\n",
    "            \n",
    "        self._canvas = canvas\n",
    "        self._fillcolor = (1., 0., 0.)\n",
    "            \n",
    "    def rect(self, x, y, w, h):\n",
    "        ctx = cairo.Context(self._canvas.surface)\n",
    "        ctx.set_source_rgb(*self._fillcolor)\n",
    "        ctx.rectangle(x, y, x+w, y+h)\n",
    "        ctx.fill()\n",
    "        \n",
    "def context_as_dict(context):\n",
    "    return {\n",
    "        name: getattr(context, name)\n",
    "        for name in dir(context) \n",
    "        if not name.startswith('_')\n",
    "    }\n",
    "        \n",
    "\n",
    "class ShoebotRunner:\n",
    "    def __init__(self, **kwargs):\n",
    "        self.canvas = BufferedCanvas(**kwargs)\n",
    "        self.context = ShoebotContext(self.canvas)\n",
    "    \n",
    "    async def run_once(self, code):\n",
    "        # TODO: During first frame canvas is already cleared.\n",
    "                \n",
    "        # TODO: During subsequent frames if canvas should be\n",
    "        # cleared use show_page, otherwise copy_page  for outputs.\n",
    "        with self.canvas.recording_surface() as surface:\n",
    "            _vars = dict(context_as_dict(self.context))\n",
    "            exec(code, _vars, _vars)\n",
    "        self.canvas.display()\n",
    "    \n",
    "    async def run_multiple(self, code):\n",
    "        await asyncio.sleep(0)\n",
    "    \n",
    "    async def run(self, code):\n",
    "        await self.run_once(code)\n",
    "\n",
    "# # Draw on surface\n",
    "# canvas = BufferedCanvas()\n",
    "# ctx = cairo.Context(canvas.surface)\n",
    "# ctx.set_source_rgb(.5, .5, 1.)\n",
    "# ctx.rectangle(10, 10, 90, 90)\n",
    "# ctx.fill()\n",
    "\n",
    "# # intermediate ImageSurface 1\n",
    "# print(\"ImageSurface\")\n",
    "# canvas.display(format=FORMAT_PNG, dimensions=(128, 128))\n",
    "\n",
    "# # intermediate SVGSurface to buffer\n",
    "# print(\"SVG to buffer\")\n",
    "# canvas.display(format=FORMAT_SVG)\n",
    "# canvas.display(format=FORMAT_SVG_XML)\n",
    "\n",
    "\n",
    "# # continue drawing\n",
    "# print(\"continue drawing...\")\n",
    "# ctx.set_source_rgb(1., .5, .5)\n",
    "# ctx.rectangle(100, 10, 90, 90)\n",
    "# ctx.fill()\n",
    "\n",
    "# del ctx\n",
    "\n",
    "# print(\"Display final surface\")\n",
    "\n",
    "# canvas.surface.ink_extents()\n",
    "\n",
    "# print(\"Canvas display as bitmap\")\n",
    "# canvas.display(FORMAT_PNG, dimensions=(180, 40))\n",
    "\n",
    "# print(\"Canvas display svg\")\n",
    "# canvas.display(FORMAT_SVG)\n",
    "\n",
    "code = \"\"\"\\\n",
    "import cairo\n",
    "\n",
    "#int(\"oops\")\n",
    "\n",
    "#ctx = cairo.Context(surface)\n",
    "#ctx.set_source_rgb(1., .5, .1)\n",
    "#ctx.translate(65, 65)\n",
    "#ctx.rotate(.7)\n",
    "#ctx.rectangle(-50, -50, 100, 100)\n",
    "#ctx.fill()\n",
    "\n",
    "rect(0, 0, 45, 45)\n",
    "\n",
    "\"\"\"\n",
    "\n",
    "runner = ShoebotRunner(extents=(0, 0, 128, 128))\n",
    "\n",
    "# Draw on surface\n",
    "canvas = runner.canvas\n",
    "# ctx = cairo.Context(canvas.surface)\n",
    "# ctx.set_source_rgb(.5, .5, 1.)\n",
    "# ctx.rectangle(10, 10, 90, 90)\n",
    "# ctx.fill()\n",
    "\n",
    "#print(canvas.surface.ink_extents())\n",
    "\n",
    "\n",
    "await runner.run(code)\n",
    "#runner.canvas.display()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'cairo': <module 'cairo' from '/home/stu/.virtualenvs/shoebot/lib/python3.8/site-packages/cairo/__init__.py'>,\n",
       " 'rect': <bound method ShoebotContext.rect of <__main__.ShoebotContext object at 0x7ff699ebc520>>}"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import inspect\n",
    "\n",
    "dir(runner.context)\n",
    "\n",
    "#runner.context.__dict__.keys()\n",
    "\n",
    "{name: getattr(runner.context, name) for name in dir(runner.context) if not name.startswith('_')}"
   ]
  }
 ],
 "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.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}