sandbox.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import tnetwork as tn"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "from streamfig.StreamFig import StreamFig"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = StreamFig(streaming=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "a.addNode(\"a\")\n",
    "a.addNode(\"b\")\n",
    "a.addLink(\"a\",\"b\",1,2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4 0 0 50 -1 0 30 0.0000 4 135 120 3050 5375 a\\001\n",
      "2 1 2 2 0 7 50 -1 -1 6.000 0 0 7 0 0 2\n",
      "           3450 5250 8450 5250\n",
      "4 0 0 50 -1 0 30 0.0000 4 135 120 3050 5975 b\\001\n",
      "2 1 2 2 0 7 50 -1 -1 6.000 0 0 7 0 0 2\n",
      "           3450 5850 8450 5850\n"
     ]
    }
   ],
   "source": [
    "for u in a._nodes:\n",
    "    a.printNode(u)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 3 0 3 0 0 49 -1 20 0.000 1 0.0000 3950 5250 45 45 -6525 -2025 -6480 -2025\n",
      "1 3 0 3 0 0 49 -1 20 0.000 1 0.0000 3950 5850 45 45 -6525 -2025 -6480 -2025\n",
      "3 2 0 3 0 7 50 -1 -1 0.000 0 0 0 3\n",
      "\n",
      "3950 5250 3950 5550 3950 5850\n",
      "0.000 -1.000 0.000\n",
      "2 1 0 3 0 7 50 -1 -1 0.000 0 0 -1 0 0 2\n",
      "3950 5550 4450 5550.0\n"
     ]
    }
   ],
   "source": [
    "for u in a._links:\n",
    "    a.printLink(u)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from matplotlib import plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "ename": "TabError",
     "evalue": "inconsistent use of tabs and spaces in indentation (<ipython-input-28-1fe5f93c4d95>, line 2057)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-28-1fe5f93c4d95>\"\u001b[0;36m, line \u001b[0;32m2057\u001b[0m\n\u001b[0;31m    params = line.split()\u001b[0m\n\u001b[0m                         ^\u001b[0m\n\u001b[0;31mTabError\u001b[0m\u001b[0;31m:\u001b[0m inconsistent use of tabs and spaces in indentation\n"
     ]
    }
   ],
   "source": [
    "\"\"\"'fig' module - object-oriented interface to XFig files.\n",
    "\n",
    "You can read fig files into a `File` object 'f' with::\n",
    "\n",
    "  import fig\n",
    "  f = fig.File(filename) # or pass a file-like object\"\"\"\n",
    "\n",
    "__author__ = \"Hans Meine <hans_meine@gmx.net>\"\n",
    "__version__ = \"0.9\"\n",
    "\n",
    "import sys, re, math, os, operator, copy\n",
    "\n",
    "from named_constants import Constants\n",
    "\n",
    "class FigConstants(Constants):\n",
    "    @classmethod\n",
    "    def read(cls, i):\n",
    "        return cls(int(i))\n",
    "\n",
    "class ObjectType(FigConstants):\n",
    "    CustomColor   = 0\n",
    "    Ellipse       = 1\n",
    "    Polygon       = 2\n",
    "    Spline        = 3\n",
    "    Text          = 4\n",
    "    Arc           = 5\n",
    "    CompoundBegin = 6\n",
    "    CompoundEnd   = -6\n",
    "\n",
    "class PolygonType(FigConstants):\n",
    "    \"\"\"cf. `PolylineBase.changeType()`\"\"\"\n",
    "    Polyline    = 1\n",
    "    Box         = 2\n",
    "    Polygon     = 3\n",
    "    ArcBox      = 4\n",
    "    PictureBBox = 5\n",
    "\n",
    "class EllipseType(FigConstants):\n",
    "    \"\"\"cf. `EllipseBase.changeType()`\"\"\"\n",
    "    EllipseRadii    = 1\n",
    "    EllipseDiameter = 2\n",
    "    CircleRadius    = 3\n",
    "    CircleDiameter  = 4\n",
    "\n",
    "class SplineType(FigConstants):\n",
    "    \"\"\"cf. `SplineBase.changeType()`\"\"\"\n",
    "    OpenApproximated   = 0\n",
    "    ClosedApproximated = 1\n",
    "    OpenInterpolated   = 2\n",
    "    ClosedInterpolated = 3\n",
    "    OpenXSpline        = 4\n",
    "    ClosedXSpline      = 5\n",
    "\n",
    "class ArcType(FigConstants):\n",
    "    \"\"\"cf. `ArcBase.changeType()`\"\"\"\n",
    "    Open = 1\n",
    "    Pie  = 2\n",
    "\n",
    "class ArcDirection(FigConstants):\n",
    "    \"\"\"cf. ArcBase.direction property\"\"\"\n",
    "    Clockwise = 0\n",
    "    CounterClockwise = 1\n",
    "\n",
    "class FillStyle(FigConstants):\n",
    "    \"\"\"cf. `Object.fillStyle` property\"\"\"\n",
    "    None_                = -1\n",
    "    Black                = 0\n",
    "    Shaded5              = 1\n",
    "    Shaded10             = 2\n",
    "    Shaded15             = 3\n",
    "    Shaded20             = 4\n",
    "    Shaded25             = 5\n",
    "    Shaded30             = 6\n",
    "    Shaded35             = 7\n",
    "    Shaded40             = 8\n",
    "    Shaded45             = 9\n",
    "    Shaded50             = 10\n",
    "    Shaded55             = 11\n",
    "    Shaded60             = 12\n",
    "    Shaded65             = 13\n",
    "    Shaded70             = 14\n",
    "    Shaded75             = 15\n",
    "    Shaded80             = 16\n",
    "    Shaded85             = 17\n",
    "    Shaded90             = 18\n",
    "    Shaded95             = 19\n",
    "    Solid                = 20\n",
    "    Tinted95             = 21\n",
    "    Tinted90             = 22\n",
    "    Tinted85             = 23\n",
    "    Tinted80             = 24\n",
    "    Tinted75             = 25\n",
    "    Tinted70             = 26\n",
    "    Tinted65             = 27\n",
    "    Tinted60             = 28\n",
    "    Tinted55             = 29\n",
    "    Tinted50             = 30\n",
    "    Tinted45             = 31\n",
    "    Tinted40             = 32\n",
    "    Tinted35             = 33\n",
    "    Tinted30             = 34\n",
    "    Tinted25             = 35\n",
    "    Tinted20             = 36\n",
    "    Tinted15             = 37\n",
    "    Tinted10             = 38\n",
    "    Tinted5              = 39\n",
    "    White                = 40\n",
    "    Left30               = 41\n",
    "    \"30 degree left diagonal pattern\"\n",
    "    Right30              = 42\n",
    "    \"30 degree right diagonal pattern\"\n",
    "    Crossed30            = 43\n",
    "    \"30 degree cross-hatched pattern\"\n",
    "    Left45               = 44\n",
    "    \"45 degree left diagonal pattern\"\n",
    "    Right45              = 45\n",
    "    \"45 degree right diagonal pattern\"\n",
    "    Crossed45            = 46\n",
    "    \"45 degree cross-hatched pattern\"\n",
    "    HorizontalBricks     = 47\n",
    "    \"horizontal bricks pattern\"\n",
    "    VerticalBricks       = 48\n",
    "    \"vertical bricks pattern\"\n",
    "    HorizontalLines      = 49\n",
    "    \"horizontal lines pattern\"\n",
    "    VerticalLines        = 50\n",
    "    \"vertical lines pattern\"\n",
    "    Crosshatch           = 51\n",
    "    \"crosshatch pattern\"\n",
    "    HorizontalShingles1  = 52\n",
    "    \"horizontal \\\"shingles\\\" pattern skewed to the right\"\n",
    "    HorizontalShingles2  = 53\n",
    "    \"horizontal \\\"shingles\\\" pattern skewed to the left\"\n",
    "    VerticalShingles1    = 54\n",
    "    \"vertical \\\"shingles\\\" pattern skewed one way\"\n",
    "    VerticalShingles2    = 55\n",
    "    \"vertical \\\"shingles\\\" pattern skewed the other way\"\n",
    "    FishScales           = 56\n",
    "    \"fish scales pattern\"\n",
    "    SmallFishScales      = 57\n",
    "    \"small fish scales pattern\"\n",
    "    Circles              = 58\n",
    "    \"circles pattern\"\n",
    "    Hexagons             = 59\n",
    "    \"hexagons pattern\"\n",
    "    Octagons             = 60\n",
    "    \"octagons pattern\"\n",
    "    HorizontalTireTreads = 61\n",
    "    \"horizontal \\\"tire treads\\\" pattern\"\n",
    "    VerticalTireTreads   = 62\n",
    "    \"vertical \\\"tire treads\\\" pattern\"\n",
    "\n",
    "    def shaded(percent):\n",
    "        \"\"\"Return a fillStyle for dark shades of the fill color.\n",
    "        `percent` decides between 0 = black .. 100 = fillColor (5% steps)\"\"\"\n",
    "        return FillStyle(int(round(percent / 5.0)))\n",
    "\n",
    "    def tinted(percent):\n",
    "        \"\"\"Return a fillStyle for light tinted fill colors.\n",
    "        `percent` decides between 0 = white .. 100 = fillColor (5% steps)\"\"\"\n",
    "        return FillStyle(40 - int(round(percent / 5.0)))\n",
    "\n",
    "class ArrowType(FigConstants):\n",
    "    \"\"\"cf. `Arrow` class\"\"\"\n",
    "    Stick = 0\n",
    "    \"stick-type, three-stroke arrow head (default in xfig 2.1 and earlier)\"\n",
    "    Closed = 1\n",
    "    \"closed triangle\"\n",
    "    ClosedIndented = 2\n",
    "    \"closed with 'indented' butt\"\n",
    "    ClosedPointed = 3\n",
    "    \"closed with 'pointed' butt\"\n",
    "    ClosedDiamond = 4\n",
    "    \"closed parallelogram\"\n",
    "    ClosedCircle = 5\n",
    "    \"closed circle\"\n",
    "    HalfCircle = 6\n",
    "    \"open half-circle\"\n",
    "    ClosedRectangle = 7\n",
    "    \"closed rectangle\"\n",
    "    ClosedReverse = 8\n",
    "    \"closed reverse triangle\"\n",
    "    HalfFilled = 9\n",
    "    \"half-filled triangle (side determined by arrow style)\"\n",
    "    RightHalf = 10\n",
    "    \"right half of closed triangle\"\n",
    "    RightHalfIndented = 11\n",
    "    \"right half of triangle with 'indented' butt\"\n",
    "    RightHalfIndented = 12\n",
    "    \"right half of triangle with 'pointed' butt\"\n",
    "    ReversedStick = 13\n",
    "    \"open reversed triangle (alternate style: perpendicular line)\"\n",
    "    OpenRectangle = 14\n",
    "    \"open rectangle (direction determined by arrow style)\"\n",
    "\n",
    "class ArrowStyle(FigConstants):\n",
    "    \"\"\"cf. `Arrow` class\"\"\"\n",
    "    Hollow = 0\n",
    "    \"filled with white\"\n",
    "    Filled = 1\n",
    "    \"filled with penColor\"\n",
    "\n",
    "class LineStyle(FigConstants):\n",
    "    \"\"\"cf. `Object.lineStyle` property\"\"\"\n",
    "    Default          = -1\n",
    "    Solid            = 0\n",
    "    Dashed           = 1\n",
    "    Dotted           = 2\n",
    "    DashDotted       = 3\n",
    "    DashDoubleDotted = 4\n",
    "    DashTripleDotted = 5\n",
    "\n",
    "class CapStyle(FigConstants):\n",
    "    \"\"\"cf. `Object.capStyle` property, used by Polyline, OpenArc, and open splines\"\"\"\n",
    "    Butt = 0\n",
    "    Round = 1\n",
    "    Projecting = 2\n",
    "\n",
    "class JoinStyle(FigConstants):\n",
    "    \"\"\"cf. `Object.joinStyle` property, used for `Polyline` objects only\"\"\"\n",
    "    Miter = 0\n",
    "    Round = 1\n",
    "    Bevel = 2\n",
    "\n",
    "standardColors = [\n",
    "\t# pure colors:\n",
    "\t(0, 0, 0),\n",
    "\t(0, 0, 255),\n",
    "\t(0, 255, 0),\n",
    "\t(0, 255, 255),\n",
    "\t(255, 0, 0),\n",
    "\t(255, 0, 255),\n",
    "\t(255, 255, 0),\n",
    "\t(255, 255, 255),\n",
    "\t# four blues:\n",
    "\t(0, 0, 144),\n",
    "\t(0, 0, 176),\n",
    "\t(0, 0, 208),\n",
    "\t(135, 206, 255),\n",
    "\t# three greens:\n",
    "\t(0, 144, 0),\n",
    "\t(0, 176, 0),\n",
    "\t(0, 208, 0),\n",
    "\t# three cyans:\n",
    "\t(0, 144, 144),\n",
    "\t(0, 176, 176),\n",
    "\t(0, 208, 208),\n",
    "\t# three reds:\n",
    "\t(144, 0, 0),\n",
    "\t(176, 0, 0),\n",
    "\t(208, 0, 0),\n",
    "\t# three magentas:\n",
    "\t(144, 0, 144),\n",
    "\t(176, 0, 176),\n",
    "\t(208, 0, 208),\n",
    "\t# three browns:\n",
    "\t(128, 48, 0),\n",
    "\t(160, 64, 0),\n",
    "\t(192, 96, 0),\n",
    "\t# four pinks:\n",
    "\t(255, 128, 128),\n",
    "\t(255, 160, 160),\n",
    "\t(255, 192, 192),\n",
    "\t(255, 224, 224),\n",
    "\t# gold:\n",
    "\t(255, 215, 0),\n",
    "\t]\n",
    "\"Mapping of the standard colors to RGB triples.\"\n",
    "\n",
    "class Color(Constants):\n",
    "    \"\"\"cf. `Object.penColor` and `Object.fillColor` properties\"\"\"\n",
    "    Default   = -1\n",
    "    Black     = 0\n",
    "    Blue      = 1\n",
    "    Green     = 2\n",
    "    Cyan      = 3\n",
    "    Red       = 4\n",
    "    Magenta   = 5\n",
    "    Yellow    = 6\n",
    "    White     = 7\n",
    "    Blue4     = 8\n",
    "    Blue3     = 9\n",
    "    Blue2     = 10\n",
    "    LightBlue = 11\n",
    "    Green4    = 12\n",
    "    Green3    = 13\n",
    "    Green2    = 14\n",
    "    Cyan4     = 15\n",
    "    Cyan3     = 16\n",
    "    Cyan2     = 17\n",
    "    Red4      = 18\n",
    "    Red3      = 19\n",
    "    Red2      = 20\n",
    "    Magenta4  = 21\n",
    "    Magenta3  = 22\n",
    "    Magenta2  = 23\n",
    "    Brown4    = 24\n",
    "    Brown3    = 25\n",
    "    Brown2    = 26\n",
    "    Pink4     = 27\n",
    "    Pink3     = 28\n",
    "    Pink2     = 29\n",
    "    LightPink = 30\n",
    "    Gold      = 31\n",
    "    Custom0   = 32\n",
    "\n",
    "    @classmethod\n",
    "    def read(cls, i):\n",
    "        i = int(i)\n",
    "        if i <= Color.Custom0:\n",
    "            return Color(i)\n",
    "        return i\n",
    "    \n",
    "class Alignment(FigConstants):\n",
    "    \"\"\"cf. `Text.alignment` property\"\"\"\n",
    "    Left     = 0\n",
    "    Centered = 1\n",
    "    Right    = 2\n",
    "\n",
    "class Font(FigConstants):\n",
    "    \"\"\"cf. `Text.font` property, only valid if `Text.fontFlags` & FontFlag.PostScript\"\"\"\n",
    "    Default                        = -1\n",
    "    TimesRoman                     = 0\n",
    "    TimesItalic                    = 1\n",
    "    TimesBold                      = 2\n",
    "    TimesBoldItalic                = 3\n",
    "    AvantGardeBook                 = 4\n",
    "    AvantGardeBookOblique          = 5\n",
    "    AvantGardeDemi                 = 6\n",
    "    AvantGardeDemiOblique          = 7\n",
    "    BookmanLight                   = 8\n",
    "    BookmanLightItalic             = 9\n",
    "    BookmanDemi                    = 10\n",
    "    BookmanDemiItalic              = 11\n",
    "    Courier                        = 12\n",
    "    CourierOblique                 = 13\n",
    "    CourierBold                    = 14\n",
    "    CourierBoldOblique             = 15\n",
    "    Helvetica                      = 16\n",
    "    HelveticaOblique               = 17\n",
    "    HelveticaBold                  = 18\n",
    "    HelveticaBoldOblique           = 19\n",
    "    HelveticaNarrow                = 20\n",
    "    HelveticaNarrowOblique         = 21\n",
    "    HelveticaNarrowBold            = 22\n",
    "    HelveticaNarrowBoldOblique     = 23\n",
    "    NewCenturySchoolbookRoman      = 24\n",
    "    NewCenturySchoolbookItalic     = 25\n",
    "    NewCenturySchoolbookBold       = 26\n",
    "    NewCenturySchoolbookBoldItalic = 27\n",
    "    PalatinoRoman                  = 28\n",
    "    PalatinoItalic                 = 29\n",
    "    PalatinoBold                   = 30\n",
    "    PalatinoBoldItalic             = 31\n",
    "    Symbol                         = 32\n",
    "    ZapfChanceryMediumItalic       = 33\n",
    "    ZapfDingbats                   = 34\n",
    "\n",
    "class LaTeXFont(FigConstants):\n",
    "    \"\"\"cf. `Text.font` property, only valid if `Text.fontFlags` & FontFlag.PostScript == 0\"\"\"\n",
    "    LaTeXDefault = 0\n",
    "    LaTeXRoman = 1\n",
    "    LaTeXBold = 2\n",
    "    LaTeXItalic = 3\n",
    "    LaTeXSansSerif = 4\n",
    "    LaTeXTypewriter = 5\n",
    "\n",
    "class FontFlag(Constants):\n",
    "    \"\"\"cf. `Text.fontFlags` property\"\"\"\n",
    "    Rigid      = 1\n",
    "    Special    = 2\n",
    "    PostScript = 4\n",
    "    Hidden     = 8\n",
    "\n",
    "paperSizes = [\"Letter\", \"Legal\", \"Ledger\", \"Tabloid\",\n",
    "\t\t\t  \"A\", \"B\", \"C\", \"D\", \"E\",\n",
    "\t\t\t  \"A4\", \"A3\", \"A2\", \"A1\", \"A0\", \"B5\"]\n",
    "\"\"\"Valid paper sizes, cf. `File.paperSize`.\"\"\"\n",
    "\n",
    "unitCM = 450\n",
    "\"\"\"fig units per centimeter (used for positions, radii, ...)\"\"\"\n",
    "\n",
    "# --------------------------------------------------------------------\n",
    "#                              helpers\n",
    "# --------------------------------------------------------------------\n",
    "\n",
    "def _join(*sequence):\n",
    "\t\"\"\"Helper function to bring internal object parameters into XFig\n",
    "\tstring format.  Attention: floating point numbers are rounded and\n",
    "\tconverted to integer - if floats are to be output, call str() on\n",
    "\tthem before passing to this function.\"\"\"\n",
    "\tparts = []\n",
    "\tfor item in sequence:\n",
    "\t\tif isinstance(item, float):\n",
    "\t\t\tparts.append(str(int(round(item))))\n",
    "\t\telif isinstance(item, bool):\n",
    "\t\t\tparts.append(str(int(item)))\n",
    "\t\telse:\n",
    "\t\t\tparts.append(str(item))\n",
    "\treturn \" \".join(parts)\n",
    "\n",
    "def _formatComment(comment):\n",
    "\tif not comment:\n",
    "\t\treturn \"\"\n",
    "\tresult = [\"#\" + c for c in comment.split(\"\\n\")]\n",
    "\tif result[-1] == \"#\":\n",
    "\t\tresult[-1] = \"\"\n",
    "\telse:\n",
    "\t\tresult.append(\"\")\n",
    "\treturn \"\\n\".join(result)\n",
    "\n",
    "_re_size = re.compile(\"([0-9]+)x([0-9]+)\")\n",
    "_re_geometry = re.compile(\"([0-9]+)[:,]([0-9]+)([+-:,])([0-9]+)([x:,])([0-9]+)\")\n",
    "\n",
    "def parseSize(sizeStr):\n",
    "\t\"\"\"Convenience function for parsing size strings into tuples:\n",
    "\t\n",
    "\t  >>> fig.parseSize('640x480')\n",
    "\t  (640, 480)\n",
    "\t\"\"\"\n",
    "\tma = _re_size.match(sizeStr)\n",
    "\tif ma:\n",
    "\t\tw = int(ma.group(1))\n",
    "\t\th = int(ma.group(2))\n",
    "\t\treturn (w, h)\n",
    "\n",
    "def parseGeometry(geometryString):\n",
    "\t\"\"\"Convenience function for parsing geometry strings of various\n",
    "\tformats.  Example usage:\n",
    "\n",
    "\t>>> import fig\n",
    "\t>>> fig.parseGeometry(\"320,240-640,480\")\n",
    "\tfig.Rect(320,240,640,480)\n",
    "\t>>> fig.parseGeometry(\"50,50+50,50\")\n",
    "\tfig.Rect(50,50,100,100)\n",
    "\t>>> fig.parseGeometry(\"40,40,320,240\")\n",
    "\tfig.Rect(40,40,320,240)\n",
    "\t>>> r = fig.Rect(0,0,320,240)\n",
    "\t>>> fig.parseGeometry(str(r)) == r\n",
    "\tTrue\n",
    "\t\"\"\"\n",
    "\tma = _re_geometry.match(geometryString)\n",
    "\tif ma:\n",
    "\t\tx1 = int(ma.group(1))\n",
    "\t\ty1 = int(ma.group(2))\n",
    "\t\tvx2 = int(ma.group(4))\n",
    "\t\tvy2 = int(ma.group(6))\n",
    "\t\tif ma.group(3) == \"+\" or ma.group(5) == \"x\":\n",
    "\t\t\tassert ma.group(3) != \"-\", \"invalid geometry string format 'X,Y-WxH': %s (use either x1,y2-x2,y2 *or* x1,y1+WxH)\" % geometryString\n",
    "\t\t\treturn Rect(x1, y1, x1+vx2, y1+vy2)\n",
    "\t\telse:\n",
    "\t\t\treturn Rect(x1, y1, vx2, vy2)\n",
    "\n",
    "class Vector(object):\n",
    "\t__slots__ = (\"x\", \"y\")\n",
    "\t\n",
    "\tdef __init__(self, x, y):\n",
    "\t\tself.x = x\n",
    "\t\tself.y = y\n",
    "\n",
    "\tdef __getitem__(self, index):\n",
    "\t\tif index == 0 or index == -2:\n",
    "\t\t\treturn self.x\n",
    "\t\tif index == 1 or index == -1:\n",
    "\t\t\treturn self.y\n",
    "\t\traise IndexError(\"Vector only has two components\")\n",
    "\n",
    "\tdef __setitem__(self, index, value):\n",
    "\t\tif index == 0 or index == -2:\n",
    "\t\t\tself.x = value\n",
    "\t\telif index == 1 or index == -1:\n",
    "\t\t\tself.y = value\n",
    "\t\telse:\n",
    "\t\t\traise IndexError(\"Vector only has two components\")\n",
    "\n",
    "\tdef __mul__(self, s):\n",
    "\t\treturn Vector(self[0]*s, self[1]*s)\n",
    "\n",
    "\t__rmul__ = __mul__\n",
    "\n",
    "\tdef __div__(self, s):\n",
    "\t\treturn Vector(self[0]/s, self[1]/s)\n",
    "\n",
    "\tdef __add__(self, other):\n",
    "\t\treturn Vector(self[0]+other[0], self[1]+other[1])\n",
    "\n",
    "\tdef __sub__(self, other):\n",
    "\t\treturn Vector(self[0]-other[0], self[1]-other[1])\n",
    "\n",
    "\tdef dot(self, other):\n",
    "\t\treturn self[0]*other[0] + self[1]*other[1]\n",
    "\n",
    "\tdef length2(self):\n",
    "\t\treturn self.dot(self)\n",
    "\n",
    "\tdef length(self):\n",
    "\t\treturn math.sqrt(self.length2())\n",
    "\n",
    "\tdef normalized(self):\n",
    "\t\treturn self / self.length()\n",
    "\n",
    "\tdef dist(self, other):\n",
    "\t\treturn (self - other).length()\n",
    "\n",
    "\tdef __len__(self):\n",
    "\t\treturn 2\n",
    "\n",
    "\tdef __eq__(self, other):\n",
    "\t\ttry:\n",
    "\t\t\tif len(other) != 2:\n",
    "\t\t\t\treturn False\n",
    "\t\texcept TypeError: # \"len() of unsized object\"\n",
    "\t\t\treturn False\n",
    "\t\treturn self[0] == other[0] and self[1] == other[1]\n",
    "\n",
    "\tdef __ne__(self, other):\n",
    "\t\treturn not self.__eq__(other)\n",
    "\n",
    "\tdef __repr__(self):\n",
    "\t\treturn \"fig.Vector(%s, %s)\" % (self.x, self.y)\n",
    "\n",
    "class Rect(object):\n",
    "\t\"\"\"This is a simple, half-internal helper class for handling\n",
    "\tRectangles (e.g. used for bounding boxes).  If you are looking for\n",
    "\ta rectangular figure object, `PolyBox` is your friend.\n",
    "\n",
    "\tA Rect object has the properties `x1`, `x2`, `y1`, `y2` carrying\n",
    "\tthe coordinates, and accessor functions `width()`, `height()`,\n",
    "\t`upperLeft()`, `lowerRight()`, `center()`, `size()`.  (The latter\n",
    "\treturn pairs of coordinates.)\n",
    "\n",
    "\tA special facility is the __call__ operator for adding\n",
    "\tpoints/rects (sort of a UNION operation).\n",
    "\n",
    "\tFinally, it is possible to do::\n",
    "\t\n",
    "\t  x1, y1, x2, y2 = someRect\"\"\"\n",
    "\n",
    "\t__slots__ = (\"x1\", \"y1\", \"x2\", \"y2\",\n",
    "\t\t\t\t \"_empty\")\n",
    "\t\n",
    "\tdef __init__(self, *args):\n",
    "\t\tassert len(args) in (0, 4), \\\n",
    "\t\t\t   \"Rect.__init__() expecting zero or four parameters!\"\n",
    "\t\tif len(args) == 4:\n",
    "\t\t\tself.x1, self.y1, self.x2, self.y2 = args\n",
    "\t\t\tself._empty = False\n",
    "\t\telse:\n",
    "\t\t\tself._empty = True\n",
    "\t\n",
    "\tdef __call__(self, other):\n",
    "\t\tif isinstance(other, Rect):\n",
    "\t\t\tif other._empty:\n",
    "\t\t\t\treturn\n",
    "\t\t\tself.__call__((other.x1, other.y1))\n",
    "\t\t\tself.__call__((other.x2, other.y2))\n",
    "\t\telse:\n",
    "\t\t\tif self._empty:\n",
    "\t\t\t\tself.x1 = other[0]\n",
    "\t\t\t\tself.x2 = other[0]\n",
    "\t\t\t\tself.y1 = other[1]\n",
    "\t\t\t\tself.y2 = other[1]\n",
    "\t\t\t\tself._empty = False\n",
    "\t\t\telse:\n",
    "\t\t\t\tself.x1 = min(self.x1, other[0])\n",
    "\t\t\t\tself.y1 = min(self.y1, other[1])\n",
    "\t\t\t\tself.x2 = max(self.x2, other[0])\n",
    "\t\t\t\tself.y2 = max(self.y2, other[1])\n",
    "\n",
    "\tdef contains(self, other):\n",
    "\t\t\"\"\"Return True iff other is a Rect or point that is entirely\n",
    "\t\twithin this Rect.  (Points on the border are considered to be\n",
    "\t\tcontained.)\"\"\"\n",
    "\t\tif isinstance(other, Rect):\n",
    "\t\t\treturn other.empty() or (\n",
    "\t\t\t\tself.contains(other.upperLeft()) and\n",
    "\t\t\t\tself.contains(other.lowerRight()))\n",
    "\t\treturn ((self.x1 <= other[0]) and (self.y1 <= other[1]) and\n",
    "\t\t\t\t(other[0] <= self.x2) and (other[1] <= self.y2))\n",
    "\t\n",
    "\tdef width(self):\n",
    "\t\treturn self.x2 - self.x1\n",
    "\t\n",
    "\tdef height(self):\n",
    "\t\treturn self.y2 - self.y1\n",
    "\n",
    "\tdef left(self):\n",
    "\t\treturn self.x1\n",
    "\n",
    "\tdef right(self):\n",
    "\t\treturn self.x2\n",
    "\n",
    "\tdef top(self):\n",
    "\t\treturn self.y1\n",
    "\n",
    "\tdef bottom(self):\n",
    "\t\treturn self.y2\n",
    "\n",
    "\tdef upperLeft(self):\n",
    "\t\treturn Vector(self.x1, self.y1)\n",
    "\t\n",
    "\tdef lowerRight(self):\n",
    "\t\treturn Vector(self.x2, self.y2)\n",
    "\t\n",
    "\tdef center(self):\n",
    "\t\treturn Vector((self.x2 + self.x1) / 2,\n",
    "\t\t\t\t\t  (self.y2 + self.y1) / 2)\n",
    "\t\n",
    "\tdef size(self):\n",
    "\t\treturn Vector(self.width(), self.height())\n",
    "\n",
    "\tdef empty(self):\n",
    "\t\treturn self._empty\n",
    "\n",
    "\tdef __mul__(self, factor):\n",
    "\t\treturn Rect(*map(lambda x: x*factor, self))\n",
    "\n",
    "\tdef addBorder(self, w, h = None):\n",
    "\t\tif h is None:\n",
    "\t\t\th = w\n",
    "\t\tself.x1 -= w\n",
    "\t\tself.y1 -= h\n",
    "\t\tself.x2 += w\n",
    "\t\tself.y2 += h\n",
    "\t\n",
    "\tdef __repr__(self):\n",
    "\t\treturn \"fig.Rect(%d,%d,%d,%d)\" % (self.x1, self.y1, self.x2, self.y2)\n",
    "\t\n",
    "\tdef __str__(self):\n",
    "\t\treturn \"%d,%d-%d,%d\" % (self.x1, self.y1, self.x2, self.y2)\n",
    "\n",
    "\tdef __eq__(self, other):\n",
    "\t\tif not isinstance(other, Rect):\n",
    "\t\t\treturn False\n",
    "\t\treturn str(self) == str(other)\n",
    "\t\n",
    "\tdef __ne__(self, other):\n",
    "\t\tif isinstance(other, Rect):\n",
    "\t\t\treturn False\n",
    "\t\treturn str(self) != str(other)\n",
    "\t\n",
    "\tdef __iter__(self):\n",
    "\t\t\"\"\"Make Rect objects assignable like::\n",
    "\t\tx1, y1, x2, y2 = someRect\"\"\"\n",
    "\t\tyield self.x1\n",
    "\t\tyield self.y1\n",
    "\t\tyield self.x2\n",
    "\t\tyield self.y2\n",
    "\n",
    "# --------------------------------------------------------------------\n",
    "# \t\t\t\t\t\t\tcustom colors\n",
    "# --------------------------------------------------------------------\n",
    "\n",
    "class CustomColor(object):\n",
    "\tdef __init__(self, index, hexCode):\n",
    "\t\tassert len(hexCode) == 7 and hexCode.startswith(\"#\"), \\\n",
    "\t\t\t   \"invalid hexCode given to CustomColor(), should look like '#fe0d00'\"\n",
    "\t\tself.index = index\n",
    "\t\tself.hexCode = hexCode\n",
    "\t\t#sys.stderr.write(\"CustomColor(%d, '%s') -> %s\" % (index, hexCode, repr(self)))\n",
    "\n",
    "\tdef __repr__(self):\n",
    "\t\treturn _join(ObjectType.CustomColor, self.index, self.hexCode) + \"\\n\"\n",
    "\n",
    "\tdef __str__(self):\n",
    "\t\treturn str(self.index)\n",
    "\n",
    "\tdef __int__(self):\n",
    "\t\treturn self.index\n",
    "\n",
    "\tdef __cmp__(self, other):\n",
    "\t\tif other == None:\n",
    "\t\t\treturn 1\n",
    "\t\tif isinstance(other, CustomColor):\n",
    "\t\t\treturn cmp(self.index, other.index)\n",
    "\t\tif isinstance(other, str):\n",
    "\t\t\treturn cmp(self.hexCode, other)\n",
    "\t\treturn cmp(self.index, other)\n",
    "\n",
    "\tdef __sub__(self, other):\n",
    "\t\t\"\"\"Return RGB vector difference as (dr,dg,db) tuple.\"\"\"\n",
    "\t\treturn map(operator.sub, self, other)\n",
    "\n",
    "\tdef __getitem__(self, index):\n",
    "\t\tif index > 2:\n",
    "\t\t\traise IndexError(\"CustomColor.__getitem__: Only three components (r,g,b)!\")\n",
    "\t\treturn int(self.hexCode[2*index+1:2*index+3], 16)\n",
    "\n",
    "\tdef __len__(self):\n",
    "\t\treturn 3\n",
    "\t\n",
    "\tdef rgb(self):\n",
    "\t\treturn (self[0], self[1], self[2])\n",
    "\n",
    "\tdef setRGB(self, r, g, b):\n",
    "\t\tself.hexCode = \"#%02x%02x%02x\" % (r, g, b)\n",
    "\n",
    "# --------------------------------------------------------------------\n",
    "# \t\t\t\tObject: base class for all fig objects\n",
    "# --------------------------------------------------------------------\n",
    "\n",
    "class Object(object):\n",
    "\t\"\"\"Base class of all fig objects.  Handles common properties like\n",
    "\t\n",
    "\t- lineStyle (see `LineStyle.XXX` constants)\n",
    "\t- lineWidth (1/80th inch)\n",
    "\t- styleValue (dash length / dot gap ratio), in 1/80th inches\n",
    "\t- penColor, fillColor (see `Color.XXX` constants)\n",
    "\t- fillStyle (see `FillStyle.XXX` constants)\n",
    "\t- depth (0-999)\n",
    "\t- joinStyle (see `JoinStyle.XXX` constants)\n",
    "\t- capStyle (see `CapStyle.XXX` constants)\n",
    "\t- forwardArrow/backwardArrow (`Arrow` objects)\"\"\"\n",
    "\n",
    "\t__slots__ = (\"lineStyle\", \"lineWidth\", \"penColor\", \"fillColor\", \"depth\",\n",
    "\t\t\t\t \"penStyle\", \"fillStyle\", \"styleValue\", \"joinStyle\", \"capStyle\",\n",
    "\t\t\t\t \"forwardArrow\", \"backwardArrow\", \"comment\")\n",
    "\n",
    "\tdef __init__(self):\n",
    "\t\tself.lineStyle = LineStyle.Default\n",
    "# Line thicknesses are given in 1/80 inch (0.3175mm) or 1 screen pixel.\n",
    "# When exporting to EPS, PostScript or any bitmap format (e.g. GIF),  the\n",
    "# line thickness is reduced to 1/160 inch (0.159mm) to \"lighten\" the look.\n",
    "\t\tself.lineWidth = 1\n",
    "\t\tself.penColor = Color.Default\n",
    "\t\tself.fillColor = Color.Default\n",
    "\t\tself.depth = 50\n",
    "\t\tself.penStyle = 0 # not used\n",
    "\t\tself.fillStyle = FillStyle.None_\n",
    "\t\tself.styleValue = 3.0\n",
    "\t\tself.joinStyle = JoinStyle(0)\n",
    "\t\tself.capStyle = CapStyle(0)\n",
    "\t\tself.forwardArrow = None\n",
    "\t\tself.backwardArrow = None\n",
    "\t\tself.comment = \"\"\n",
    "\n",
    "\tdef _joinWithProperties(self, figType, subType, *rest):\n",
    "\t\treturn _formatComment(self.comment) + _join(\n",
    "\t\t\tfigType, subType,\n",
    "\t\t\tself.lineStyle, self.lineWidth,\n",
    "\t\t\tself.penColor is None and Color.Default or self.penColor,\n",
    "\t\t\tself.fillColor is None and Color.Default or self.fillColor,\n",
    "\t\t\tself.depth, self.penStyle,\n",
    "\t\t\tself.fillStyle, str(self.styleValue),\n",
    "\t\t\t*rest)\n",
    "\n",
    "class Arrow(object):\n",
    "\t\"\"\"Arrow objects store arrow parameters of open arcs, splines, or\n",
    "\tlines.  Instances of this class are usually assigned to the\n",
    "\t`forwardArrow`/`backwardArrow` properties of `fig.Object`.\n",
    "\tThe Arrow properties are\n",
    "\t\n",
    "\t- type (see `ArrowType.XXX` constants)\n",
    "\t- style (`ArrowStyle.Hollow` or `ArrowStyle.Filled`)\n",
    "\t- thickness, in 1/80th inches\n",
    "\t- width, height (in fig units)\"\"\"\n",
    "\n",
    "\t__slots__ = (\"type\", \"style\", \"thickness\", \"width\", \"height\")\n",
    "\t\n",
    "\tdef __init__(self, type = ArrowType.Stick, style = ArrowStyle.Hollow,\n",
    "\t\t\t\t thickness = 1.0, width = 60.0, height = 120.0):\n",
    "\t\tself.type = type\n",
    "\t\tself.style = style\n",
    "\t\tself.thickness = thickness\n",
    "\t\tself.width = width\n",
    "\t\tself.height = height\n",
    "\n",
    "\tdef __str__(self):\n",
    "\t\treturn _join(self.type, self.style,\n",
    "\t\t\t\t\t str(self.thickness),\n",
    "\t\t\t\t\t str(self.width), str(self.height)) + \"\\n\"\n",
    "\n",
    "def readArrow(params):\n",
    "\treturn Arrow(int(params[0]), int(params[1]),\n",
    "\t\t\t\t float(params[2]), float(params[3]), float(params[4]))\n",
    "\n",
    "# --------------------------------------------------------------------\n",
    "#                                arcs\n",
    "# --------------------------------------------------------------------\n",
    "\n",
    "class ArcBase(Object):\n",
    "\t\"\"\"Base class of Arc-like objects (`PieArc`, `OpenArc`).\"\"\"\n",
    "\n",
    "\t__slots__ = (\"points\", \"direction\", \"center\", \"_pointCount\")\n",
    "\t\n",
    "\tdef __init__(self, center = None,\n",
    "\t\t\t\t point1 = None, point2 = None,\n",
    "\t\t\t\t angle1 = None, angle2 = None, radius = None,\n",
    "\t\t\t\t direction = ArcDirection.Clockwise):\n",
    "\t\tObject.__init__(self)\n",
    "\t\tself.center = center\n",
    "\t\tself.points = None\n",
    "\t\tself.direction = direction\n",
    "\t\tif center == None:\n",
    "\t\t\tassert point1 == None and point2 == None\n",
    "\t\t\treturn\n",
    "\t\tassert ((point1 is None) == (point2 is None)) and \\\n",
    "\t\t\t   ((angle1 is None) == (angle2 is None) == (radius is None)) and \\\n",
    "\t\t\t   ((point1 is None) != (angle1 is None)), \\\n",
    "\t\t\t   \"ArcBase.__init__: give either points *or* angles+radius!\"\n",
    "\n",
    "\t\tif not angle1 is None:\n",
    "\t\t\tpoint1 = center + (radius*math.cos(angle1), -radius*math.sin(angle1))\n",
    "\t\t\tpoint2 = center + (radius*math.cos(angle2), -radius*math.sin(angle2))\n",
    "\n",
    "\t\t# calculate midpoint between start- and end-point on arc\n",
    "\t\tself.points = [point1, None, point2]\n",
    "\t\tangle1, angle2 = self.angles()\n",
    "\t\tangle12 = angle1 + self._angleDiff(angle2, angle1, direction) / 2\n",
    "\t\tc = Vector(*center)\n",
    "\t\tself.points[1] = \\\n",
    "\t\t\tc + (c - point1).length()*Vector( math.cos(angle12),\n",
    "\t\t\t\t\t\t\t\t\t\t\t -math.sin(angle12))\n",
    "\n",
    "\tdef _angleDiff(self, angle2, angle1, direction):\n",
    "\t\t\"\"\"Return (angle2 - angle1) in the range [-2pi..0) if\n",
    "\t\tdirection == ArcDirection.Clockwise, and in the range [0..2pi) otherwise.\"\"\"\n",
    "\t\tresult = angle2 - angle1\n",
    "\t\tif direction == ArcDirection.Clockwise:\n",
    "\t\t\twhile result > 0:\n",
    "\t\t\t\tresult -= 2*math.pi\n",
    "\t\t\tif result <= -2*math.pi:\n",
    "\t\t\t\tresult += 2*math.pi\n",
    "\t\telse:\n",
    "\t\t\twhile result < 0:\n",
    "\t\t\t\tresult += 2*math.pi\n",
    "\t\t\tif result > 2*math.pi:\n",
    "\t\t\t\tresult -= 2*math.pi\n",
    "\t\treturn result\n",
    "\n",
    "\tdef angles(self):\n",
    "\t\t\"\"\"Return start- and end-angle (in radians).  The second angle\n",
    "\t\tis smaller than the first iff direction is ArcDirection.Clockwise.\"\"\"\n",
    "\t\tpoint1, _, point2 = self.points\n",
    "\t\tangle1 = math.atan2(-(point1[1] - self.center[1]),\n",
    "\t\t\t\t\t\t\t  point1[0] - self.center[0])\n",
    "\t\tangle2 = math.atan2(-(point2[1] - self.center[1]),\n",
    "\t\t\t\t\t\t\t  point2[0] - self.center[0])\n",
    "\t\tangle2 = angle1 + self._angleDiff(angle2, angle1, self.direction)\n",
    "\t\treturn angle1, angle2\n",
    "\n",
    "\tdef radius(self):\n",
    "\t\t\"\"\"Return distance of first point from center\"\"\"\n",
    "\t\treturn (Vector(*self.center) - self.points[0]).length()\n",
    "\n",
    "\tdef changeType(self, arcType):\n",
    "\t\t\"Change type of this Arc. arcType may be one of ArcType.Pie or ArcType.Open\"\n",
    "\t\tif arcType == ArcType.Pie:\n",
    "\t\t\tself.__class__ = PieArc\n",
    "\t\telse:\n",
    "\t\t\tself.__class__ = OpenArc\n",
    "\n",
    "\tdef __str__(self):\n",
    "\t\tassert len(self.points) == 3\n",
    "\t\thasForwardArrow = (self.forwardArrow != None and 1 or 0)\n",
    "\t\thasBackwardArrow = (self.backwardArrow != None and 1 or 0)\n",
    "\t\t\n",
    "\t\tresult = self._joinWithProperties(\n",
    "\t\t\tObjectType.Arc, self.arcType(),\n",
    "\t\t\tself.capStyle, self.direction,\n",
    "\t\t\thasForwardArrow, hasBackwardArrow,\n",
    "\t\t\tstr(self.center[0]), str(self.center[1]),\n",
    "\t\t\tself.points[0][0], self.points[0][1],\n",
    "\t\t\tself.points[1][0], self.points[1][1],\n",
    "\t\t\tself.points[2][0], self.points[2][1]) + \"\\n\"\n",
    "\n",
    "\t\tif hasForwardArrow:\n",
    "\t\t\tresult += \"\\t\" + str(self.forwardArrow)\n",
    "\t\tif hasBackwardArrow:\n",
    "\t\t\tresult += \"\\t\" + str(self.backwardArrow)\n",
    "\t\treturn result\n",
    "\n",
    "\tdef bounds(self):\n",
    "\t\tresult = Rect()\n",
    "\t\tfor point in self.points:\n",
    "\t\t\tresult(point)\n",
    "\t\treturn result\n",
    "\n",
    "\tdef _readSub(self, params):\n",
    "\t\tif self.forwardArrow == True:\n",
    "\t\t\tself.forwardArrow = readArrow(params)\n",
    "\t\t\treturn self.backwardArrow == True\n",
    "\n",
    "\t\tif self.backwardArrow == True:\n",
    "\t\t\tself.backwardArrow = readArrow(params)\n",
    "\t\t\treturn False\n",
    "\n",
    "\t\tsys.stderr.write(\"Unhandled subline while loading arc object!\\n\")\n",
    "\t\treturn False\n",
    "\n",
    "class PieArc(ArcBase):\n",
    "\t\"\"\"Represents a closed arc object.\"\"\"\n",
    "\t\n",
    "\t__slots__ = ()\n",
    "\n",
    "\tdef arcType(self):\n",
    "\t\t\"Return type of this Arc (ArcType.Pie), see `changeType`.\"\n",
    "\t\treturn ArcType.Pie\n",
    "\n",
    "\tdef closed(self):\n",
    "\t\t\"\"\"Return whether this arc is closed (True for all\n",
    "\t\t`PieArc` objects.)\"\"\"\n",
    "\t\treturn True\n",
    "\n",
    "class OpenArc(ArcBase):\n",
    "\t\"\"\"Represents an open arc object.\"\"\"\n",
    "\n",
    "\t__slots__ = ()\n",
    "\n",
    "\tdef arcType(self):\n",
    "\t\t\"Return type of this Arc (ArcType.Open), see `changeType`.\"\n",
    "\t\treturn ArcType.Open\n",
    "\n",
    "\tdef closed(self):\n",
    "\t\t\"\"\"Return whether this arc is closed (False for all\n",
    "\t\t`OpenArc` objects.)\"\"\"\n",
    "\t\treturn False\n",
    "\n",
    "def _readArcBase(params):\n",
    "\tresult = ArcBase()\n",
    "\tresult.changeType(int(params[0]))\n",
    "\tresult.lineStyle = LineStyle.read(params[1])\n",
    "\tresult.lineWidth = int(params[2])\n",
    "\tresult.penColor = Color.read(params[3])\n",
    "\tresult.fillColor = Color.read(params[4])\n",
    "\tresult.depth = int(params[5])\n",
    "\tresult.penStyle = int(params[6])\n",
    "\tresult.fillStyle = FillStyle.read(params[7])\n",
    "\tresult.styleValue = float(params[8])\n",
    "\tresult.capStyle = CapStyle.read(params[9])\n",
    "\tresult.direction = int(params[10])\n",
    "\tsubLines = 0\n",
    "\tif int(params[11]):\n",
    "\t\tresult.forwardArrow = True\n",
    "\t\tsubLines += 1\n",
    "\tif int(params[12]):\n",
    "\t\tresult.backwardArrow = True\n",
    "\t\tsubLines += 1\n",
    "\tresult.center = (float(params[13]), float(params[14]))\n",
    "\tresult.points = [Vector(int(params[15]), int(params[16])),\n",
    "\t\t\t\t\t Vector(int(params[17]), int(params[18])),\n",
    "\t\t\t\t\t Vector(int(params[19]), int(params[20]))]\n",
    "\treturn result, subLines\n",
    "\n",
    "# --------------------------------------------------------------------\n",
    "#                              ellipses\n",
    "# --------------------------------------------------------------------\n",
    "\n",
    "class EllipseBase(Object):\n",
    "\t\"\"\"Base class of Ellipse-like objects (`Ellipse`, `Circle`).\"\"\"\n",
    "\t\n",
    "\t__slots__ = (\"angle\", \"center\", \"radius\", \"start\", \"end\")\n",
    "\n",
    "\tdef __init__(self):\n",
    "\t\tObject.__init__(self)\n",
    "\t\tself.angle = 0.0\n",
    "\t\tself.center = Vector(0, 0)\n",
    "\t\tself.radius = Vector(0, 0)\n",
    "\t\tself.start = Vector(0, 0)\n",
    "\t\tself.end = Vector(0, 0)\n",
    "\n",
    "\tdef changeType(self, ellipseType):\n",
    "\t\t\"\"\"Change type of this Ellipse object.  `ellipseType` may be one\n",
    "\t\tof the `EllipseType.XXX` constants:\n",
    "\n",
    "\t\t- EllipseType.EllipseRadii\n",
    "\t\t- EllipseType.EllipseDiameter\n",
    "\t\t- EllipseType.CircleRadius\n",
    "\t\t- EllipseType.CircleDiameter\n",
    "\n",
    "\t\tThis method may change the type of this object to another\n",
    "\t\t`EllipseBase`-derived class.\"\"\"\n",
    "\n",
    "\t\tif ellipseType in (EllipseType.EllipseRadii, EllipseType.EllipseDiameter):\n",
    "\t\t\tself.__class__ = Ellipse\n",
    "\t\telif ellipseType in (EllipseType.CircleRadius, EllipseType.CircleDiameter):\n",
    "\t\t\tself.__class__ = Circle\n",
    "\t\telse:\n",
    "\t\t\traise ValueError(\"Unknown ellipseType %d!\" % ellipseType)\n",
    "\n",
    "\tdef __str__(self):\n",
    "\t\treturn self._joinWithProperties(\n",
    "\t\t\tObjectType.Ellipse, self.ellipseType(),\n",
    "\t\t\t1, # \"1\" is self.direction\n",
    "\t\t\tstr(self.angle % (2*math.pi)),\n",
    "\t\t\tself.center[0], self.center[1],\n",
    "\t\t\tself.radius[0], self.radius[1],\n",
    "\t\t\tself.start[0], self.start[1],\n",
    "\t\t\tself.end[0], self.end[1]) + \"\\n\"\n",
    "\n",
    "\tdef bounds(self):\n",
    "\t\tresult = Rect()\n",
    "\t\tresult(((self.center[0] - self.radius[0]),\n",
    "\t\t\t\t(self.center[1] - self.radius[1])))\n",
    "\t\tresult(((self.center[0] + self.radius[0]),\n",
    "\t\t\t\t(self.center[1] + self.radius[1])))\n",
    "\t\treturn result\n",
    "\n",
    "\tdef setRadius(self, radius):\n",
    "\t\t\"\"\"Change radius.  `radius` may be either a tuple of x/y\n",
    "\t\tradii, or a single radius, convertible to float(s).\"\"\"\n",
    "\t\tif not isinstance(radius, tuple):\n",
    "\t\t\tassert float(radius) != None, \"radius must be either a tuple of x/y radii, or a single radius, convertible to float(s)\"\n",
    "\t\t\tself.radius = (radius, radius)\n",
    "\t\telse:\n",
    "\t\t\tassert len(radius) == 2 and float(radius[0]) != None and float(radius[1]) != None, \"radius must be either a tuple of x/y radii, or a single radius, convertible to float(s)\"\n",
    "\t\t\tself.radius = radius\n",
    "\t\t# FIXME: depend on ellipseType (currently, ellipseType may change)\n",
    "\t\tself.start = self.center\n",
    "\t\tself.end = (self.center[0] + self.radius[0],\n",
    "\t\t\t\t\tself.center[1] + self.radius[1])\n",
    "\n",
    "\tdef setCenterRadius(self, center, radius):\n",
    "\t\t\"\"\"Set center and radius, see `setRadius`.\"\"\"\n",
    "\t\tself.center = center\n",
    "\t\tself.setRadius(radius)\n",
    "\n",
    "def _readEllipseBase(params):\n",
    "\tresult = EllipseBase()\n",
    "\tresult.changeType(int(params[0]))\n",
    "\tresult.lineStyle = LineStyle.read(params[1])\n",
    "\tresult.lineWidth = int(params[2])\n",
    "\tresult.penColor = Color.read(params[3])\n",
    "\tresult.fillColor = Color.read(params[4])\n",
    "\tresult.depth = int(params[5])\n",
    "\tresult.penStyle = int(params[6])\n",
    "\tresult.fillStyle = FillStyle.read(params[7])\n",
    "\tresult.styleValue = float(params[8])\n",
    "\tresult.angle = float(params[10])\n",
    "\tresult.center = Vector(int(params[11]), int(params[12]))\n",
    "\tresult.radius = Vector(int(params[13]), int(params[14]))\n",
    "\tresult.start = Vector(int(params[15]), int(params[16]))\n",
    "\tresult.end = Vector(int(params[17]), int(params[18]))\n",
    "\treturn result, 0\n",
    "\n",
    "class Ellipse(EllipseBase):\n",
    "\t\"\"\"Represents an ellipse object.  Ellipse objects have an\n",
    "\tattribute `radius` that is a tuple of two radii in x- and\n",
    "\ty-direction.\"\"\"\n",
    "\t\n",
    "\t__slots__ = ()\n",
    "\n",
    "\tdef __init__(self, center = None, radii = None, angle = 0.0,\n",
    "\t\t\t\t start = None, end = None):\n",
    "\t\tEllipseBase.__init__(self)\n",
    "\t\tself.angle = angle\n",
    "\t\tif center != None and radii != None:\n",
    "\t\t\tself.setCenterRadius(center, radii)\n",
    "\t\telse:\n",
    "\t\t\tself.setStartEnd(start, end)\n",
    "\n",
    "\tdef ellipseType(self):\n",
    "\t\t\"\"\"Return type of this ellipse (one of EllipseType.EllipseRadii,\n",
    "\t\tEllipseType.EllipseDiameter for `Ellipse` objects), see `changeType`.\"\"\"\n",
    "\n",
    "\t\tif self.center == self.start:\n",
    "\t\t\treturn EllipseType.EllipseRadii\n",
    "\t\telse:\n",
    "\t\t\treturn EllipseType.EllipseDiameter\n",
    "\n",
    "\tdef setStartEnd(self, start, end):\n",
    "\t\tself.start = start\n",
    "\t\tself.end = end\n",
    "\t\t# FIXME: depend on ellipseType\n",
    "\t\tself.center = ((start[0] + end[0])/2,\n",
    "\t\t\t\t\t   (start[1] + end[1])/2)\n",
    "\t\tself.radius = ((end[0] - self.center[0]),\n",
    "\t\t\t\t\t   (end[1] - self.center[1]))\n",
    "\n",
    "class Circle(EllipseBase):\n",
    "\t\"\"\"Represents a circle object.  Circle objects have an\n",
    "\tattribute `radius` that is a single float.\"\"\"\n",
    "\t\n",
    "\t__slots__ = ()\n",
    "\n",
    "\tdef __init__(self, center = None, radius = None,\n",
    "\t\t\t\t start = None, end = None):\n",
    "\t\tEllipseBase.__init__(self)\n",
    "\t\tif center != None and radius != None:\n",
    "\t\t\tself.setCenterRadius(center, (radius, radius))\n",
    "\t\telse:\n",
    "\t\t\tself.setStartEnd(start, end)\n",
    "\n",
    "\tdef ellipseType(self):\n",
    "\t\t\"\"\"Return type of this ellipse (one of EllipseType.CircleRadius,\n",
    "\t\tEllipseType.CircleDiameter for `Circle` objects), see `changeType`.\"\"\"\n",
    "\n",
    "\t\tif self.center == self.start:\n",
    "\t\t\treturn EllipseType.CircleRadius\n",
    "\t\telse:\n",
    "\t\t\treturn EllipseType.CircleDiameter\n",
    "\n",
    "\tdef setStartEnd(self, start, end):\n",
    "\t\tself.start = start\n",
    "\t\tself.end = end\n",
    "\t\t# FIXME: depend on ellipseType?\n",
    "\t\tself.center = ((start[0] + end[0])/2,\n",
    "\t\t\t\t\t   (start[1] + end[1])/2)\n",
    "\t\tradius = math.hypot(end[0] - self.center[0],\n",
    "\t\t\t\t\t\t\tend[1] - self.center[1])\n",
    "\t\tself.radius = (radius, radius)\n",
    "\n",
    "\tdef __str__(self):\n",
    "\t\tassert self.radius[0] == self.radius[1], \\\n",
    "\t\t\t   \"invalid circle (radii %s != %s)\" % self.radius\n",
    "\t\treturn EllipseBase.__str__(self)\n",
    "\n",
    "# --------------------------------------------------------------------\n",
    "#                             polylines\n",
    "# --------------------------------------------------------------------\n",
    "\n",
    "class PolylineBase(Object):\n",
    "\t\"\"\"Base class of Polygon-like objects (`Polygon`,\n",
    "\t`Polyline`, `PictureBBox`).\"\"\"\n",
    "\n",
    "\t__slots__ = (\"points\", \"filename\", \"flipped\", \"radius\", \"_pointCount\")\n",
    "\t\n",
    "\tdef __init__(self):\n",
    "\t\tObject.__init__(self)\n",
    "\t\tself.points = []\n",
    "\t\tself.filename = None\n",
    "\t\tself.flipped = False\n",
    "\t\tself.radius = -1\n",
    "\n",
    "\tdef changeType(self, polylineType, retainPoints = False):\n",
    "\t\t\"\"\"Change type of this Polyline object.  `polylineType` may be one\n",
    "\t\tof the `PolygonType.XXX` constants:\n",
    "\n",
    "\t\t- PolygonType.Polyline\n",
    "\t\t- PolygonType.Box\n",
    "\t\t- PolygonType.Polygon\n",
    "\t\t- PolygonType.ArcBox\n",
    "\t\t- PolygonType.PictureBBox\n",
    "\n",
    "\t\tThis method may change the type of this object to another\n",
    "\t\t`PolylineBase`-derived class.\n",
    "\n",
    "\t\tIf `retainPoints` is not set to True, this function will\n",
    "\t\tadd/remove the last point such that closed polygons do not\n",
    "\t\thave the first point repeated at the end.\"\"\"\n",
    "\n",
    "\t\twasClosed = None\n",
    "\t\tif type(self) != PolylineBase:\n",
    "\t\t\twasClosed = self.closed()\n",
    "\t\tif polylineType == PolygonType.Polyline:\n",
    "\t\t\tself.__class__ = Polyline\n",
    "\t\tif polylineType == PolygonType.Box:\n",
    "\t\t\tself.__class__ = PolyBox\n",
    "\t\tif polylineType == PolygonType.Polygon:\n",
    "\t\t\tself.__class__ = Polygon\n",
    "\t\tif polylineType == PolygonType.ArcBox:\n",
    "\t\t\tself.__class__ = ArcBox\n",
    "\t\tif polylineType == PolygonType.PictureBBox:\n",
    "\t\t\tself.__class__ = PictureBBox\n",
    "\t\tif retainPoints or wasClosed == None:\n",
    "\t\t\treturn\n",
    "\t\tif wasClosed == self.closed() or len(self.points) < 2:\n",
    "\t\t\treturn\n",
    "\t\tif not wasClosed:\n",
    "\t\t\tif self.points[-1] == self.points[0]:\n",
    "\t\t\t\tdel self.points[-1]\n",
    "\t\telse:\n",
    "\t\t\tself.points.append(copy.copy(self.points[0]))\n",
    "\n",
    "\tdef segments(self):\n",
    "\t\tit = iter(self.points)\n",
    "\t\tprev = it.next()\n",
    "\t\tfor point in it:\n",
    "\t\t\tyield (prev, point)\n",
    "\t\t\tprev = point\n",
    "\t\tif self.closed():\n",
    "\t\t\tyield (prev, self.points[0])\n",
    "\n",
    "\tdef __str__(self):\n",
    "\t\tpointCount = len(self.points)\n",
    "\t\tif self.closed():\n",
    "\t\t\tpointCount += 1\n",
    "\t\thasForwardArrow = (self.forwardArrow != None and 1 or 0)\n",
    "\t\thasBackwardArrow = (self.backwardArrow != None and 1 or 0)\n",
    "\t\t\n",
    "\t\tresult = self._joinWithProperties(\n",
    "\t\t\tObjectType.Polygon, self.polylineType(),\n",
    "\t\t\tself.joinStyle, self.capStyle, self.radius,\n",
    "\t\t\thasForwardArrow, hasBackwardArrow,\n",
    "\t\t\tpointCount) + \"\\n\"\n",
    "\n",
    "\t\tif hasForwardArrow:\n",
    "\t\t\tresult += \"\\t\" + str(self.forwardArrow)\n",
    "\t\tif hasBackwardArrow:\n",
    "\t\t\tresult += \"\\t\" + str(self.backwardArrow)\n",
    "\t\tif isinstance(self, PictureBBox):\n",
    "\t\t\tresult += \"\\t\" + _join(self.flipped, self.filename) + \"\\n\"\n",
    "\t\ti = self._savePointIter()\n",
    "\t\tfor linePoints in map(None, *(i, )*12):\n",
    "\t\t\tresult += \"\\t\" + _join(*[p for p in linePoints if p != None]) + \"\\n\"\n",
    "\t\treturn result\n",
    "\n",
    "\tdef _savePointIter(self):\n",
    "\t\tfor p in self.points:\n",
    "\t\t\tyield p[0]\n",
    "\t\t\tyield p[1]\n",
    "\t\tif self.closed():\n",
    "\t\t\tyield self.points[0][0]\n",
    "\t\t\tyield self.points[0][1]\n",
    "\n",
    "\tdef bounds(self):\n",
    "\t\tresult = Rect()\n",
    "\t\tfor point in self.points:\n",
    "\t\t\tresult(point)\n",
    "\t\treturn result\n",
    "\n",
    "\tdef _readSub(self, params):\n",
    "\t\tif self.forwardArrow == True:\n",
    "\t\t\tself.forwardArrow = readArrow(params)\n",
    "\t\t\treturn True\n",
    "\n",
    "\t\tif self.backwardArrow == True:\n",
    "\t\t\tself.backwardArrow = readArrow(params)\n",
    "\t\t\treturn True\n",
    "\n",
    "\t\tif isinstance(self, PictureBBox) and self.filename == None:\n",
    "\t\t\tself.flipped = int(params[0])\n",
    "\t\t\tself.filename = params[1]\n",
    "\t\t\treturn True\n",
    "\n",
    "\t\tpointCount = len(params) / 2\n",
    "\t\tfor pointIndex in range(pointCount):\n",
    "\t\t\tself.points.append(Vector(int(params[pointIndex * 2]),\n",
    "\t\t\t\t\t\t\t\t\t  int(params[pointIndex * 2 + 1])))\n",
    "\n",
    "\t\texpectedPoints = (self._pointCount + (self.closed() and 1 or 0))\n",
    "\t\tmoreToCome = len(self.points) < expectedPoints\n",
    "\t\tif len(self.points) > self._pointCount:\n",
    "\t\t\tif len(self.points) > expectedPoints:\n",
    "\t\t\t\tsys.stderr.write(\"WARNING: read too many points?!\\n\")\n",
    "\t\t\tdel self.points[self._pointCount:]\n",
    "\n",
    "\t\treturn moreToCome\n",
    "\n",
    "def _readPolylineBase(params):\n",
    "\tresult = PolylineBase()\n",
    "\t# retainPoints is not actually necessary for PolylineBase objects:\n",
    "\tresult.changeType(int(params[0]), retainPoints = True)\n",
    "\tresult.lineStyle = LineStyle.read(params[1])\n",
    "\tresult.lineWidth = int(params[2])\n",
    "\tresult.penColor = Color.read(params[3])\n",
    "\tresult.fillColor = Color.read(params[4])\n",
    "\tresult.depth = int(params[5])\n",
    "\tresult.penStyle = int(params[6])\n",
    "\tresult.fillStyle = FillStyle.read(params[7])\n",
    "\tresult.styleValue = float(params[8])\n",
    "\tresult.joinStyle = JoinStyle.read(params[9])\n",
    "\tresult.capStyle = CapStyle.read(params[10])\n",
    "\tresult.radius = int(params[11])\n",
    "\tsubLines = 0\n",
    "\tif int(params[12]):\n",
    "\t\tresult.forwardArrow = True\n",
    "\t\tsubLines += 1\n",
    "\tif int(params[13]):\n",
    "\t\tresult.backwardArrow = True\n",
    "\t\tsubLines += 1\n",
    "\tresult._pointCount = int(params[14])\n",
    "\tsubLines += (result._pointCount+5)/6 # sublines to read for the points\n",
    "\tif result.closed():\n",
    "\t\tresult._pointCount -= 1\n",
    "\tif isinstance(result, PictureBBox):\n",
    "\t\tsubLines += 1\n",
    "\treturn result, subLines\n",
    "\n",
    "class PolyBox(PolylineBase):\n",
    "\t\"\"\"Represents a rectangular closed box object.\"\"\"\n",
    "\t\n",
    "\t__slots__ = ()\n",
    "\n",
    "\tdef __init__(self, x1, y1, x2, y2):\n",
    "\t\tPolylineBase.__init__(self)\n",
    "\t\tself.points.append(Vector(x1, y1))\n",
    "\t\tself.points.append(Vector(x2, y1))\n",
    "\t\tself.points.append(Vector(x2, y2))\n",
    "\t\tself.points.append(Vector(x1, y2))\n",
    "\n",
    "\tdef polylineType(self):\n",
    "\t\t\"\"\"Return type of this polygon (PolygonType.Box for all `PolyBox` objects),\n",
    "\t\tsee `changeType`.\"\"\"\n",
    "\n",
    "\t\treturn PolygonType.Box\n",
    "\n",
    "\tdef closed(self):\n",
    "\t\t\"\"\"Return whether this polygon is closed (True for all\n",
    "\t\t`PolyBox` objects.)\"\"\"\n",
    "\t\treturn True\n",
    "\n",
    "\tdef center(self):\n",
    "\t\t\"\"\"Return (x, y) coordinate tuple of the midpoint of this box.\"\"\"\n",
    "\t\treturn ((self.points[0][0] + self.points[2][0])/2,\n",
    "\t\t\t\t(self.points[0][1] + self.points[2][1])/2)\n",
    "\n",
    "\tdef upperLeft(self):\n",
    "\t\t\"\"\"Return coordinates of upper left corner.\"\"\"\n",
    "\t\treturn self.points[0]\n",
    "\t\n",
    "\tdef lowerRight(self):\n",
    "\t\t\"\"\"Return coordinates of lower right corner.\"\"\"\n",
    "\t\treturn self.points[2]\n",
    "\t\n",
    "\tdef width(self):\n",
    "\t\t\"\"\"Return width of this box.\"\"\"\n",
    "\t\treturn abs(self.points[2][0] - self.points[0][0])\n",
    "\n",
    "\tdef height(self):\n",
    "\t\t\"\"\"Return height of this box.\"\"\"\n",
    "\t\treturn abs(self.points[2][1] - self.points[0][1])\n",
    "\n",
    "class ArcBox(PolyBox):\n",
    "\t\"\"\"Represents a rectangular box with rounded corners.\"\"\"\n",
    "\t\n",
    "\t__slots__ = ()\n",
    "\n",
    "\tdef polylineType(self):\n",
    "\t\t\"\"\"Return type of this polygon (PolygonType.ArcBox for all `ArcBox` objects),\n",
    "\t\tsee `changeType`.\"\"\"\n",
    "\n",
    "\t\treturn PolygonType.ArcBox\n",
    "\n",
    "class Polygon(PolylineBase):\n",
    "\t\"\"\"Represents a closed polygon object.\"\"\"\n",
    "\t\n",
    "\t__slots__ = ()\n",
    "\n",
    "\tdef __init__(self, points, closed = True):\n",
    "\t\tPolylineBase.__init__(self)\n",
    "\t\tself.points = points\n",
    "\t\tif not closed:\n",
    "\t\t\tself.changeType(PolygonType.Polyline, retainPoints = True)\n",
    "\n",
    "\tdef polylineType(self):\n",
    "\t\t\"\"\"Return type of this polygon (PolygonType.Polygon for all `Polygon` objects),\n",
    "\t\tsee `changeType`.\"\"\"\n",
    "\n",
    "\t\treturn PolygonType.Polygon\n",
    "\n",
    "\tdef closed(self):\n",
    "\t\t\"\"\"Return whether this polygon is closed (True for all\n",
    "\t\t`Polygon` objects.)\"\"\"\n",
    "\t\treturn True\n",
    "\n",
    "class Polyline(PolylineBase):\n",
    "\t\"\"\"Represents an open polygon object.\"\"\"\n",
    "\t\n",
    "\t__slots__ = ()\n",
    "\n",
    "\tdef __init__(self, points):\n",
    "\t\tPolylineBase.__init__(self)\n",
    "\t\tself.points = points\n",
    "\n",
    "\tdef polylineType(self):\n",
    "\t\t\"\"\"Return type of this polygon (PolygonType.Polyline for all `Polyline`\n",
    "\t\tobjects), see `changeType`.\"\"\"\n",
    "\n",
    "\t\treturn PolygonType.Polyline\n",
    "\n",
    "\tdef closed(self):\n",
    "\t\t\"\"\"Return whether this polygon is closed (False for all\n",
    "\t\t`Polygon` objects.)\"\"\"\n",
    "\n",
    "\t\treturn False\n",
    "\n",
    "class PictureBBox(PolyBox):\n",
    "\t\"\"\"Represents a picture embedded in an XFig file.  The filename is\n",
    "\tstored in the `filename` attribute.\"\"\"\n",
    "\t\n",
    "\t__slots__ = ()\n",
    "\n",
    "\tdef __init__(self, x1, y1, x2, y2, filename, flipped = False):\n",
    "\t\tPolyBox.__init__(self, x1, y1, x2, y2)\n",
    "\t\tself.filename = filename\n",
    "\t\tself.flipped = flipped\n",
    "\n",
    "\tdef polylineType(self):\n",
    "\t\t\"\"\"Return type of this polygon (PolygonType.PictureBBox for all\n",
    "\t\t`PictureBBox` objects), see `changeType`.\"\"\"\n",
    "\n",
    "\t\treturn PolygonType.PictureBBox\n",
    "\n",
    "\tdef closed(self):\n",
    "\t\t\"\"\"Return whether this polygon is closed (True for all\n",
    "\t\t`PictureBBox` objects.)\"\"\"\n",
    "\t\treturn True\n",
    "\n",
    "# --------------------------------------------------------------------\n",
    "#                              splines\n",
    "# --------------------------------------------------------------------\n",
    "\n",
    "class SplineBase(Object):\n",
    "\t\"\"\"Base class of Spline objects (`ApproximatedSpline`,\n",
    "\t`InterpolatedSpline`, `XSpline`).\"\"\"\n",
    "\t\n",
    "\t__slots__ = (\"points\", \"_shapeFactors\", \"_closed\", \"_pointCount\")\n",
    "\n",
    "\tdef __init__(self, points = None, shapeFactors = None, closed = True):\n",
    "\t\tObject.__init__(self)\n",
    "\t\tself.points = points or []\n",
    "\t\tself._shapeFactors = shapeFactors or []\n",
    "\t\tself._closed = closed\n",
    "\n",
    "\tdef closed(self):\n",
    "\t\t\"\"\"Return whether this spline curve is closed.\"\"\"\n",
    "\t\tassert self._closed != None, \"SplineBase.closed(): _closed not initialized!\"\n",
    "\t\treturn self._closed\n",
    "\n",
    "\tdef shapeFactors(self):\n",
    "\t\t\"\"\"Return shape factors.  The return value is fixed for\n",
    "\t\tnon-XSplines.  For XSplines, self._shapeFactors is used (no\n",
    "\t\tpublic API ATM).\"\"\"\n",
    "\t\tresult = self._shapeFactors\n",
    "\t\tif not len(result): # or self.defaultShapeFactor():\n",
    "\t\t\t# create default shapeFactors if not initialized\n",
    "\t\t\tresult = [self.defaultShapeFactor()] * len(self.points)\n",
    "\t\t\tif not self.closed():\n",
    "\t\t\t\tresult[0] = 0.0\n",
    "\t\t\t\tresult[-1] = 0.0\n",
    "\t\treturn result\n",
    "\n",
    "\tdef changeType(self, splineType):\n",
    "\t\t\"\"\"Change type of this Spline object.  `splineType` may be one\n",
    "\t\tof the `SplineType.XXX` constants:\n",
    "\n",
    "\t\t- SplineType.OpenApproximated\n",
    "\t\t- SplineType.ClosedApproximated\n",
    "\t\t- SplineType.OpenInterpolated\n",
    "\t\t- SplineType.ClosedInterpolated\n",
    "\t\t- SplineType.OpenXSpline\n",
    "\t\t- SplineType.ClosedXSpline\n",
    "\n",
    "\t\tThis method may change the type of this object to another\n",
    "\t\t`SplineBase`-derived class.\"\"\"\n",
    "\n",
    "\t\tif splineType == SplineType.OpenApproximated:\n",
    "\t\t\tself.__class__ = ApproximatedSpline\n",
    "\t\t\tself._closed = False\n",
    "\t\telif splineType == SplineType.ClosedApproximated:\n",
    "\t\t\tself.__class__ = ApproximatedSpline\n",
    "\t\t\tself._closed = True\n",
    "\t\telif splineType == SplineType.OpenInterpolated:\n",
    "\t\t\tself.__class__ = InterpolatedSpline\n",
    "\t\t\tself._closed = False\n",
    "\t\telif splineType == SplineType.ClosedInterpolated:\n",
    "\t\t\tself.__class__ = InterpolatedSpline\n",
    "\t\t\tself._closed = True\n",
    "\t\telif splineType == SplineType.OpenXSpline:\n",
    "\t\t\tself.__class__ = XSpline\n",
    "\t\t\tself._closed = False\n",
    "\t\telif splineType == SplineType.ClosedXSpline:\n",
    "\t\t\tself.__class__ = XSpline\n",
    "\t\t\tself._closed = True\n",
    "\n",
    "\tdef __str__(self):\n",
    "\t\tpointCount = len(self.points)\n",
    "\n",
    "\t\thasForwardArrow = (self.forwardArrow != None and 1 or 0)\n",
    "\t\thasBackwardArrow = (self.backwardArrow != None and 1 or 0)\n",
    "\n",
    "\t\tresult = self._joinWithProperties(\n",
    "\t\t\tObjectType.Spline, self.splineType(),\n",
    "\t\t\tself.capStyle,\n",
    "\t\t\thasForwardArrow, hasBackwardArrow,\n",
    "\t\t\tpointCount) + \"\\n\"\n",
    "\n",
    "\t\tif hasForwardArrow:\n",
    "\t\t\tresult += \"\\t\" + str(self.forwardArrow)\n",
    "\t\tif hasBackwardArrow:\n",
    "\t\t\tresult += \"\\t\" + str(self.backwardArrow)\n",
    "\n",
    "\t\ti = self._savePointIter()\n",
    "\t\tfor linePoints in map(None, *(i, )*12):\n",
    "\t\t\tresult += \"\\t\" + _join(*[p for p in linePoints if p != None]) + \"\\n\"\n",
    "\n",
    "\t\ti = iter(self.shapeFactors())\n",
    "\t\tfor lineSF in map(None, *(i, )*8):\n",
    "\t\t\tresult += \"\\t\" + _join(*[str(sf) for sf in lineSF if sf != None]) + \"\\n\"\n",
    "\n",
    "\t\treturn result\n",
    "\n",
    "\tdef _savePointIter(self):\n",
    "\t\tfor p in self.points:\n",
    "\t\t\tyield p[0]\n",
    "\t\t\tyield p[1]\n",
    "\n",
    "\tdef bounds(self):\n",
    "\t\t\"\"\"Return the bounds of this object.  This is not accurate at\n",
    "\t\tall, since it simply returns the bounding box of the support\n",
    "\t\tpoints, but the curve may well run outside of that box.\"\"\"\n",
    "\t\t# FIXME\n",
    "\t\tresult = Rect()\n",
    "\t\tfor point in self.points:\n",
    "\t\t\tresult(point)\n",
    "\t\treturn result\n",
    "\n",
    "\tdef _readSub(self, params):\n",
    "\t\tif self.forwardArrow == True:\n",
    "\t\t\tself.forwardArrow = readArrow(params)\n",
    "\t\t\treturn True\n",
    "\n",
    "\t\tif self.backwardArrow == True:\n",
    "\t\t\tself.backwardArrow = readArrow(params)\n",
    "\t\t\treturn True\n",
    "\n",
    "\t\texpectedPoints = self._pointCount\n",
    "\n",
    "\t\tif len(self.points) < expectedPoints:\n",
    "\t\t\tpointCount = len(params) / 2\n",
    "\t\t\tfor pointIndex in range(pointCount):\n",
    "\t\t\t\tself.points.append(Vector(int(params[pointIndex * 2]),\n",
    "\t\t\t\t\t\t\t\t\t\t  int(params[pointIndex * 2 + 1])))\n",
    "\t\t\tif len(self.points) > expectedPoints:\n",
    "\t\t\t\tsys.stderr.write(\"WARNING: read too many points?!\\n\")\n",
    "\t\t\t\tdel self.points[expectedPoints:]\n",
    "\t\t\treturn True\n",
    "\n",
    "\t\tif len(self._shapeFactors) < expectedPoints:\n",
    "\t\t\tsfCount = len(params)\n",
    "\t\t\tfor sfIndex in range(sfCount):\n",
    "\t\t\t\tself._shapeFactors.append(float(params[sfIndex]))\n",
    "\t\t\tmoreToCome = len(self._shapeFactors) < expectedPoints\n",
    "\t\t\tif len(self._shapeFactors) > expectedPoints:\n",
    "\t\t\t\tsys.stderr.write(\"WARNING: read too many shapeFactors?!\\n\")\n",
    "\t\t\t\tdel self._shapeFactors[expectedPoints:]\n",
    "\t\t\tif moreToCome:\n",
    "\t\t\t\treturn True\n",
    "\n",
    "\t\treturn False\n",
    "\n",
    "class ApproximatedSpline(SplineBase):\n",
    "\t\"\"\"Represents an open or closed approximated spline object.\"\"\"\n",
    "\t\n",
    "\t__slots__ = ()\n",
    "\n",
    "\tdef defaultShapeFactor(self):\n",
    "\t\treturn 1.0\n",
    "\n",
    "\tdef splineType(self):\n",
    "\t\treturn self._closed and SplineType.ClosedApproximated or SplineType.OpenApproximated\n",
    "\n",
    "class InterpolatedSpline(SplineBase):\n",
    "\t\"\"\"Represents an open or closed interpolated spline object.\"\"\"\n",
    "\t\n",
    "\t__slots__ = ()\n",
    "\n",
    "\tdef defaultShapeFactor(self):\n",
    "\t\treturn -1.0\n",
    "\n",
    "\tdef splineType(self):\n",
    "\t\treturn self._closed and SplineType.ClosedInterpolated or SplineType.OpenInterpolated\n",
    "\n",
    "class XSpline(SplineBase):\n",
    "\t\"\"\"Represents an open or closed 'x-spline' object.\"\"\"\n",
    "\t\n",
    "\t__slots__ = ()\n",
    "\n",
    "\tdef defaultShapeFactor(self):\n",
    "\t\treturn 0.0 # ATT: this value is checked in shapeFactors() ATM\n",
    "\n",
    "\tdef splineType(self):\n",
    "\t\treturn self._closed and SplineType.ClosedXSpline or SplineType.OpenXSpline\n",
    "\n",
    "def _readSplineBase(params):\n",
    "\tresult = SplineBase()\n",
    "\tresult.changeType(int(params[0]))\n",
    "\tresult.lineStyle = LineStyle.read(params[1])\n",
    "\tresult.lineWidth = int(params[2])\n",
    "\tresult.penColor = Color.read(params[3])\n",
    "\tresult.fillColor = Color.read(params[4])\n",
    "\tresult.depth = int(params[5])\n",
    "\tresult.penStyle = int(params[6])\n",
    "\tresult.fillStyle = FillStyle.read(params[7])\n",
    "\tresult.styleValue = float(params[8])\n",
    "\tresult.capStyle = CapStyle.read(params[9])\n",
    "\tsubLines = 0\n",
    "\tif int(params[10]):\n",
    "\t\tresult.forwardArrow = True\n",
    "\t\tsubLines += 1\n",
    "\tif int(params[11]):\n",
    "\t\tresult.backwardArrow = True\n",
    "\t\tsubLines += 1\n",
    "\tresult._pointCount = int(params[12])\n",
    "\tsubLines += (result._pointCount+5)/6 # sublines to read for the points\n",
    "\treturn result, subLines\n",
    "\n",
    "# --------------------------------------------------------------------\n",
    "#                            text objects\n",
    "# --------------------------------------------------------------------\n",
    "\n",
    "class Text(Object):\n",
    "\t\"\"\"Represents a text object.  Text instances have a number of\n",
    "\textra attributes:\n",
    "\n",
    "\t- text (the string)\n",
    "\t- x, y (position)\n",
    "\t- alignment (cf. `Alignment.XXX` constants)\n",
    "\t- font (cf. Font.XXX constants)\n",
    "\t- fontSize (default: 12)\n",
    "\t- fontFlags (cf. `FontFlag.XXX` constants, default: FontFlag.PostScript)\n",
    "\t- angle (default: 0.0)\n",
    "\t- length, height (dummy values, no guarantee about correctness)\n",
    "\t\"\"\"\n",
    "\n",
    "\t__slots__ = (\"text\", \"pos\", \"alignment\",\n",
    "\t\t\t\t \"font\", \"fontSize\", \"fontFlags\", \"angle\",\n",
    "\t\t\t\t \"length\", \"height\")\n",
    "\n",
    "\tdef __init__(self, pos, text,\n",
    "\t\t\t\t font = None, fontSize = 12, fontFlags = FontFlag.PostScript,\n",
    "\t\t\t\t alignment = Alignment.Left, angle = 0.0):\n",
    "\t\tObject.__init__(self)\n",
    "\t\tself.pos = pos\n",
    "\t\tself.text = text\n",
    "\t\tself.font = font\n",
    "\t\tself.fontSize = fontSize\n",
    "\t\tself.fontFlags = fontFlags\n",
    "\t\tself.alignment = alignment\n",
    "\t\tself.angle = angle\n",
    "\t\tself.height = 136\n",
    "\t\tself.length = 100 # dummy value\n",
    "\n",
    "\tdef _guessHeight(self):\n",
    "\t\t\"\"\"Guessed height of font in fig units.\"\"\"\n",
    "\t\treturn self.fontSize*34/3\n",
    "\n",
    "\tdef _length(self):\n",
    "\t\t\"\"\"FIXME: If this is corrected, remove underscore prefix.\"\"\"\n",
    "\t\treturn 100\n",
    "\n",
    "\tdef bounds(self):\n",
    "\t\tresult = Rect()\n",
    "\t\tif self.alignment == Alignment.Left:\n",
    "\t\t\tresult((self.pos[0],                 self.pos[1] - self.height))\n",
    "\t\t\tresult((self.pos[0] + self.length,   self.pos[1]))\n",
    "\t\telif self.alignment == Alignment.Centered:\n",
    "\t\t\tresult((self.pos[0] - self.length/2, self.pos[1] - self.height))\n",
    "\t\t\tresult((self.pos[0] + self.length/2, self.pos[1]))\n",
    "\t\telif self.alignment == Alignment.Right:\n",
    "\t\t\tresult((self.pos[0],                 self.pos[1] - self.height))\n",
    "\t\t\tresult((self.pos[0] + self.length,   self.pos[1]))\n",
    "\t\treturn result\n",
    "\n",
    "\tdef __str__(self):\n",
    "\t\tfont = self.font\n",
    "\t\tif self.font is None:\n",
    "\t\t\tfont = self.fontFlags & FontFlag.PostScript \\\n",
    "\t\t\t\t   and fontDefault or LaTeXFont.Default\n",
    "\t\tresult = _formatComment(self.comment) + \\\n",
    "\t\t\t\t _join(ObjectType.Text, self.alignment,\n",
    "\t\t\t\t\t   self.penColor is None and Color.Default or self.penColor,\n",
    "\t\t\t\t\t   self.depth, self.penStyle,\n",
    "\t\t\t\t\t   font, self.fontSize, str(self.angle), self.fontFlags,\n",
    "\t\t\t\t\t   self.height, self.length, self.pos[0], self.pos[1],\n",
    "\t\t\t\t\t   _escapeText(self.text+\"\\x01\")) + \"\\n\"\n",
    "\n",
    "\t\treturn result\n",
    "\n",
    "\tdef __repr__(self):\n",
    "\t\treturn \"<fig.Text at %s, '%s'>\" % ((self.pos[0], self.pos[1]), self.text)\n",
    "\n",
    "def _escapeText(text):\n",
    "\tnonPrintable = re.compile(\"[\\x00-\\x08\\x0e-\\x1f\\x80-\\xff]\")\n",
    "\treturn nonPrintable.sub(lambda ma: \"\\\\%03o\" % ord(ma.string[ma.start()]),\n",
    "\t\t\t\t\t\t\ttext.replace(\"\\\\\", \"\\\\\\\\\"))\n",
    "\n",
    "def _unescapeText(text):\n",
    "\tchunks = text.split(\"\\\\\")\n",
    "\tresult = chunks[0]\n",
    "\ti = 1\n",
    "\twhile i < len(chunks):\n",
    "\t\tif chunks[i]:\n",
    "\t\t\tresult += chr(int(chunks[i][:3], 8)) + chunks[i][3:]\n",
    "\t\t\ti += 1\n",
    "\t\telse:\n",
    "\t\t\tresult += \"\\\\\"+chunks[i+1]\n",
    "\t\t\ti += 2\n",
    "\treturn result\n",
    "\n",
    "def _readText(params, text):\n",
    "\tresult = Text(Vector(int(params[10]), int(params[11])), _unescapeText(text),\n",
    "\t\t\t\t  alignment = int(params[0]))\n",
    "\tresult.penColor = Color.read(params[1])\n",
    "\tresult.depth = int(params[2])\n",
    "\tresult.penStyle = int(params[3])\n",
    "\tresult.font = Font.read(params[4])\n",
    "\tresult.fontSize = float(params[5])\n",
    "\tresult.angle = float(params[6])\n",
    "\tresult.fontFlags = int(params[7])\n",
    "\t#print float(params[8])/result.fontSize, float(params[9])/len(result.text)\n",
    "\tresult.height = float(params[8])\n",
    "\tresult.length = float(params[9])\n",
    "\treturn result, 0\n",
    "\n",
    "# --------------------------------------------------------------------\n",
    "#              Container and ObjectProxy utility classes\n",
    "# --------------------------------------------------------------------\n",
    "\n",
    "class _AllObjectIter(object):\n",
    "\t\"helper class, see `Container.allObjects`\"\n",
    "\t\n",
    "\tdef __init__(self, container, includeCompounds):\n",
    "\t\tself.file = file\n",
    "\t\tself.iters = [iter(container)]\n",
    "\t\tself.includeCompounds = includeCompounds\n",
    "\n",
    "\tdef __iter__(self):\n",
    "\t\treturn self\n",
    "\n",
    "\tdef next(self):\n",
    "\t\tif not self.iters:\n",
    "\t\t\traise StopIteration\n",
    "\t\ttry:\n",
    "\t\t\tnext = self.iters[-1].next()\n",
    "\t\t\tif isinstance(next, Compound):\n",
    "\t\t\t\tself.iters.append(iter(next))\n",
    "\t\t\t\tif self.includeCompounds:\n",
    "\t\t\t\t\treturn next\n",
    "\t\t\telse:\n",
    "\t\t\t\treturn next\n",
    "\t\texcept StopIteration:\n",
    "\t\t\tdel self.iters[-1]\n",
    "\t\treturn self.next()\n",
    "\n",
    "class Container(list):\n",
    "\t\"\"\"Container for fig objects, derived from the standard python\n",
    "\tlist.  This is the common superclass of `File` (for the whole\n",
    "\tdocument), `Compound`, and `ObjectProxy` (for search results, see\n",
    "\t`findObjects()` or `layer()`).\"\"\"\n",
    "\t\n",
    "\t__slots__ = ()\n",
    "\n",
    "\tdef allObjects(self, includeCompounds = False):\n",
    "\t\t\"\"\"container.allObjects(includeCompounds = False) -> iterator\n",
    "\n",
    "\t\tReturns an iterator iterating over all objects in this\n",
    "\t\tcontainer, recursively entering compound objects.  You can use\n",
    "\t\tthe optional parameter includeCompounds (default: False) to\n",
    "\t\tget the compound objects themselves returned, too.\"\"\"\n",
    "\t\t\n",
    "\t\treturn _AllObjectIter(self, includeCompounds)\n",
    "\n",
    "\tdef findObjects(self, **kwargs):\n",
    "\t\t\"\"\"Return a list of objects which have attribute/value pairs\n",
    "\t\tmatching the given keyword parameters.  The key \"type\" is\n",
    "\t\ttreated special, see these useful examples::\n",
    "\n",
    "\t\t  figFile.findObjects(depth = 40)\n",
    "\t\t  figFile.findObjects(type = fig.Polygon)\n",
    "\t\t  # all conditions must be fulfilled:\n",
    "\t\t  figFile.findObjects(lineWidth = 10, depth = 100)\n",
    "\t\t  # for disjunctive conditions, use list concatenation:\n",
    "\t\t  figFile.findObjects(depth = 10) + figFile.findObjects(depth = 20)\n",
    "\n",
    "\t\tThe returned object is actually an `ObjectProxy`, which is a\n",
    "\t\tspecial `Container` (which is a special python list) and allows\n",
    "\t\tto quickly change properties on all contained objects.  See\n",
    "\t\tthe `Container` and `ObjectProxy` classes.\"\"\"\n",
    "\n",
    "\t\tresult = ObjectProxy(parent = self)\n",
    "\t\tfor o in self.allObjects(\"type\" in kwargs and kwargs[\"type\"] == Compound):\n",
    "\t\t\tmatch = True\n",
    "\t\t\tfor key, value in kwargs.items():\n",
    "\t\t\t\tif key == \"type\":\n",
    "\t\t\t\t\tif not isinstance(o, value):\n",
    "\t\t\t\t\t\tmatch = False\n",
    "\t\t\t\t\t\tbreak\n",
    "\t\t\t\telif key == \"within\":\n",
    "\t\t\t\t\tif not value.contains(o.bounds()):\n",
    "\t\t\t\t\t\tmatch = False\n",
    "\t\t\t\t\t\tbreak\n",
    "\t\t\t\telif getattr(o, key, \"attribNotPresent\") != value:\n",
    "\t\t\t\t\tmatch = False\n",
    "\t\t\t\t\tbreak\n",
    "\t\t\tif match:\n",
    "\t\t\t\tresult.append(o)\n",
    "\t\treturn result\n",
    "\n",
    "\tdef layer(self, layer):\n",
    "\t\t\"\"\"container.layer(layer) -> `ObjectProxy`\n",
    "\n",
    "\t\tReturns an `ObjectProxy` for all objects within this container\n",
    "\t\tthat have the given depth; convenience shortcut for\n",
    "\t\t``findObjects(depth = layer)``.\"\"\"\n",
    "\t\t\n",
    "\t\treturn self.findObjects(depth = layer)\n",
    "\n",
    "\tdef layers(self):\n",
    "\t\t\"\"\"container.layers() -> list\n",
    "\n",
    "\t\tReturns the list of all integer depths that are assigned to at\n",
    "\t\tleast one object within this container.\"\"\"\n",
    "\t\t\n",
    "\t\tresult = dict.fromkeys([ob.depth for ob in self.allObjects()]).keys()\n",
    "\t\tresult.sort()\n",
    "\t\treturn result\n",
    "\n",
    "\tdef __deepcopy__(self, memo):\n",
    "\t\tresult = type(self)([copy.deepcopy(o, memo) for o in self])\n",
    "\t\treturn result\n",
    "\n",
    "\tdef remove(self, obj):\n",
    "\t\t\"\"\"container.remove(obj)\n",
    "\n",
    "\t\tRemoves the given object from this `Container`.  Also works\n",
    "\t\trecursively for objects within `Compound` objects within this\n",
    "\t\t`Container`.  Raises a ValueError if `obj` is not\n",
    "\t\tcontained.\"\"\"\n",
    "\t\t\n",
    "\t\ttry:\n",
    "\t\t\tlist.remove(self, obj)\n",
    "\t\texcept ValueError:\n",
    "\t\t\tfor o in self:\n",
    "\t\t\t\tif isinstance(o, Compound):\n",
    "\t\t\t\t\ttry:\n",
    "\t\t\t\t\t\to.remove(obj)\n",
    "\t\t\t\t\t\treturn\n",
    "\t\t\t\t\texcept ValueError:\n",
    "\t\t\t\t\t\tpass\n",
    "\t\t\traise ValueError(\"remove(): Given object not found in Container.\")\n",
    "\n",
    "\tdef container(self):\n",
    "\t\t\"\"\"Return self, see `ObjectProxy.container()`.\"\"\"\n",
    "\t\treturn self\n",
    "\n",
    "\tdef bounds(self):\n",
    "\t\t\"\"\"Return the union of all bounding boxes of the contained\n",
    "\t\tobjects.  This value is not cached (because it cannot be\n",
    "\t\treliably updated if childrens change) but will be determined\n",
    "\t\ton each call.\"\"\"\n",
    "\t\t\n",
    "\t\tresult = Rect()\n",
    "\t\tfor object in self:\n",
    "\t\t\tresult(object.bounds())\n",
    "\t\treturn result\n",
    "\n",
    "class ObjectProxy(Container):\n",
    "\t\"\"\"An ObjectProxy is a special `Container` that is used for search\n",
    "\tresults (see `Container.findObjects`) which offers additional\n",
    "\tfeatures:\n",
    "\n",
    "\tremove():\n",
    "\t  Use like ``foo.findObjects(type = fig.Polyline).remove()``\n",
    "\n",
    "\t  Removes all objects within this object proxy from the parent\n",
    "\t  container (the one `findObjects` was called on).\n",
    "\n",
    "\tsetting attributes:\n",
    "\t  ``foo.findObjects(type = fig.Polyline).lineWidth = 4``\n",
    "\n",
    "\t  Setting an attribute is promoted to all contained objects which\n",
    "\t  have that attribute.  (E.g. setting fontSize will affect only\n",
    "\t  Text objects.)\n",
    "\n",
    "\tquerying attributes:\n",
    "\t  ``col = file.layer(50).penColor``\n",
    "\n",
    "\t  Objects that do not have the attribute are gracefully skipped;\n",
    "\t  `None` is returned if the objects do not all have the same value\n",
    "\t  for the requested attribute.  (An `AttributeError` is only\n",
    "\t  raised if none of the objects has the requested attribute.)\"\"\"\n",
    "\t\n",
    "\t__slots__ = (\"parent\", )\n",
    "\n",
    "\tdef __init__(self, objects = [], parent = None):\n",
    "\t\tContainer.__init__(self, objects)\n",
    "\t\tself.parent = parent\n",
    "\t\n",
    "\tdef __setattr__(self, key, value):\n",
    "\t\tif key == \"parent\":\n",
    "\t\t\tContainer.__setattr__(self, key, value)\n",
    "\t\t\treturn\n",
    "\t\tfor ob in self:\n",
    "\t\t\tif hasattr(ob, key):\n",
    "\t\t\t\tsetattr(ob, key, value)\n",
    "\n",
    "\tdef __getattr__(self, key):\n",
    "\t\t\"\"\"Forwards attribute lookup to the contained objects.\n",
    "\n",
    "\t\tIf the attribute has the same value for all objects, it is\n",
    "\t\treturned, otherwise (the attribute has different values among\n",
    "\t\tthem), `None` is returned.\n",
    "\n",
    "\t\tObjects that do not have the named attribute are simply\n",
    "\t\tignored (i.e. proxy.font will gracefully skip non-`Text`\n",
    "\t\tobjects).  An `AttributeError` is only raised of none of the\n",
    "\t\tobjects has the requested attribute.\"\"\"\n",
    "\t\t\n",
    "\t\tfound = False\n",
    "\t\tresult = None # (prevent false positive in pyflakes)\n",
    "\t\tfor ob in self:\n",
    "\t\t\tif hasattr(ob, key):\n",
    "\t\t\t\tif found:\n",
    "\t\t\t\t\tif getattr(ob, key) != result:\n",
    "\t\t\t\t\t\treturn None\n",
    "\t\t\t\telse:\n",
    "\t\t\t\t\tresult = getattr(ob, key)\n",
    "\t\t\t\t\tfound = True\n",
    "\t\tif not found:\n",
    "\t\t\traise AttributeError(\"No Object within ObjectProxy has a '%s' attribute!\" % key)\n",
    "\t\treturn result\n",
    "\n",
    "\tdef __getslice__(self, *args):\n",
    "\t\t\"\"\"Support slicing, i.e. returns an ObjectProxy with the same\n",
    "\t\tparent.\"\"\"\n",
    "\t\treturn ObjectProxy(Container.__getslice__(self, *args),\n",
    "\t\t\t\t\t\t   self.parent)\n",
    "\n",
    "\tdef remove(self, *args):\n",
    "\t\t\"\"\"When no arguments are given, remove all objects from parent\n",
    "\t\tcontainer.  Else, remove given object from this container.\"\"\"\n",
    "\t\t\n",
    "\t\tif not args:\n",
    "\t\t\tparent = self.container()\n",
    "\t\t\tassert parent is not None, \\\n",
    "\t\t\t\t   \"ObjectProxy.remove() needs access to the parent\"\n",
    "\t\t\tfor ob in self:\n",
    "\t\t\t\tparent.remove(ob)\n",
    "\t\telse:\n",
    "\t\t\tContainer.remove(self, *args)\n",
    "\n",
    "\tdef container(self):\n",
    "\t\t\"\"\"Return first non-ObjectProxy object in the parent chain.\n",
    "\t\tThis will be the object `findObjects` has originally be called\n",
    "\t\ton.\"\"\"\n",
    "\t\tresult = self.parent\n",
    "\t\twhile isinstance(result, ObjectProxy):\n",
    "\t\t\tresult = result.parent\n",
    "\t\treturn result\n",
    "\n",
    "\tdef __add__(self, other):\n",
    "\t\t\"\"\"Returns the union of two search results.  (If the two\n",
    "\t\tsource ObjectProxies being added together have different\n",
    "\t\tparents, the result will have a parent of None.)\"\"\"\n",
    "\t\tparent = self.container()\n",
    "\t\tif parent is not other.container():\n",
    "\t\t\tparent = None\n",
    "\t\tif isinstance(other, list):\n",
    "\t\t\treturn ObjectProxy(list.__add__(self, other), parent)\n",
    "\n",
    "# --------------------------------------------------------------------\n",
    "#                             compounds\n",
    "# --------------------------------------------------------------------\n",
    "\n",
    "class Compound(Container):\n",
    "\t\"\"\"Represents a group of XFig objects.\"\"\"\n",
    "\n",
    "\t__slots__ = (\"comment\", )\n",
    "\t\n",
    "\tdef __init__(self, parent = None):\n",
    "\t\tContainer.__init__(self)\n",
    "\t\tself.comment = \"\"\n",
    "\t\tif parent != None:\n",
    "\t\t\tparent.append(self)\n",
    "\n",
    "\tdef __deepcopy__(self, memo):\n",
    "\t\tresult = Compound()\n",
    "\t\tfor o in self:\n",
    "\t\t\tresult.append(copy.deepcopy(o, memo))\n",
    "\t\treturn result\n",
    "\n",
    "\tdef __str__(self):\n",
    "\t\tif len(self) < 1:\n",
    "\t\t\treturn \"\"\n",
    "\t\tcontents = \"\"\n",
    "\t\tfor o in self:\n",
    "\t\t\tcontents += str(o)\n",
    "\t\tb = self.bounds()\n",
    "\t\treturn _formatComment(self.comment) + \\\n",
    "\t\t\t   _join(ObjectType.CompoundBegin,\n",
    "\t\t\t\t\t int(b.x1), int(b.y1),\n",
    "\t\t\t\t\t int(b.x2), int(b.y2)) + \"\\n\" + \\\n",
    "\t\t\t   contents + str(ObjectType.CompoundEnd) + \"\\n\"\n",
    "\n",
    "def _readCompound(params):\n",
    "\t# ignore bounds passed in params, since we cannot guarantee proper\n",
    "\t# updating later:\n",
    "\treturn Compound()\n",
    "\n",
    "# --------------------------------------------------------------------\n",
    "#                                file\n",
    "# --------------------------------------------------------------------\n",
    "\n",
    "class File(Container):\n",
    "\t\"\"\"Main class of the `fig` module, represents an XFig document.\"\"\"\n",
    "\n",
    "\t__slots__ = (\"comment\", \"landscape\", \"centered\", \"metric\", \"paperSize\",\n",
    "\t\t\t\t \"magnification\", \"singlePage\", \"transparentColor\", \"ppi\",\n",
    "\t\t\t\t \"filename\", \"colors\", \"_colorhash\")\n",
    "\t\n",
    "\tdef __init__(self, inputFile = None):\n",
    "\t\tContainer.__init__(self)\n",
    "\t\tself.colors = []\n",
    "\t\tself._colorhash = {}\n",
    "\t\tself.filename = None\n",
    "\n",
    "\t\tif inputFile == None:\n",
    "\t\t\tself.comment = \"\"\n",
    "\t\t\tself.landscape = False\n",
    "\t\t\tself.centered = True\n",
    "\t\t\tself.metric = True\n",
    "\t\t\tself.paperSize = \"A4\"\n",
    "\t\t\tself.magnification = 100.0\n",
    "\t\t\tself.singlePage = True\n",
    "\t\t\tself.transparentColor = -2 # no transparency, -1 = background, else color#\n",
    "\t\t\tself.ppi = 1200 # figure units per inch\n",
    "\t\telse:\n",
    "\t\t\tlineIndex = 0\n",
    "\t\t\textraLineCount = 0\n",
    "\t\t\tstack = []\n",
    "\t\t\tcurrentObject = None\n",
    "\t\t\tcurrentComment = \"\"\n",
    "\t\t\tsubLineExpected = 0\n",
    "\t\t\tif isinstance(inputFile, str):\n",
    "\t\t\t\tself.filename = inputFile\n",
    "\t\t\t\tinputFile = file(inputFile).readlines()\n",
    "\t\t\telif hasattr(inputFile, \"readlines\"):\n",
    "\t\t\t\tif hasattr(inputFile, \"name\"):\n",
    "\t\t\t\t\tself.filename = inputFile.name\n",
    "\t\t\t\tinputFile = inputFile.readlines()\n",
    "\t\t\t# for error messages:\n",
    "\t\t\tfilename = self.filename and \"'%s'\" % self.filename or \"<unnamed>\"\n",
    "\t\t\tfor line in inputFile:\n",
    "\t\t\t\tif line.startswith(\"#\"):\n",
    "\t\t\t\t\tif lineIndex:\n",
    "\t\t\t\t\t\tcurrentComment += line[1:]\n",
    "\t\t\t\t\textraLineCount += 1\n",
    "\t\t\t\t\tcontinue\n",
    "\t\t\t\tline = line.strip()\n",
    "\t\t\t\tif not line:\n",
    "\t\t\t\t\textraLineCount += 1\n",
    "\t\t\t\t\tcontinue\n",
    "\t\t\t\t#print line\n",
    "\t\t\t\tif lineIndex == 0:\n",
    "\t\t\t\t\tself.landscape = (line.lower().startswith(\"landscape\"))\n",
    "\t\t\t\telif lineIndex == 1:\n",
    "\t\t\t\t\tself.centered = (line.lower().startswith(\"center\"))\n",
    "\t\t\t\telif lineIndex == 2:\n",
    "\t\t\t\t\tself.metric = (line.lower().startswith(\"metric\"))\n",
    "\t\t\t\telif lineIndex == 3:\n",
    "\t\t\t\t\tself.paperSize = line\n",
    "\t\t\t\telif lineIndex == 4:\n",
    "\t\t\t\t\tself.magnification = float(line)\n",
    "\t\t\t\telif lineIndex == 5:\n",
    "\t\t\t\t\tself.singlePage = (line.lower().startswith(\"single\"))\n",
    "\t\t\t\telif lineIndex == 6:\n",
    "\t\t\t\t\tself.transparentColor = int(line)\n",
    "\t\t\t\telif lineIndex == 7:\n",
    "\t\t\t\t\tres, sysDummy = line.split()\n",
    "\t\t\t\t\tself.ppi = int(res)\n",
    "\t\t\t\t\tself.comment = currentComment\n",
    "\t\t\t\t\tcurrentComment = \"\"\n",
    "\t\t\t\telse:\n",
    "\t\t\t\t  try:\n",
    "\t\t\t\t\tparams = line.split()\n",
    "\t\t\t\t\tif subLineExpected:\n",
    "\t\t\t\t\t\tsubLineExpected = currentObject._readSub(params)\n",
    "\t\t\t\t\telse:\n",
    "\t\t\t\t\t\tobjectType = ObjectType(int(params[0]))\n",
    "\t\t\t\t\t\tsubLineExpected = 0\n",
    "\t\t\t\t\t\tif objectType == ObjectType.CustomColor:\n",
    "\t\t\t\t\t\t\tcc = self.addColor(CustomColor(int(params[1]), params[2]))\n",
    "\t\t\t\t\t\t\tassert cc.index == Color.Custom0 + len(self.colors) - 1, \\\n",
    "\t\t\t\t\t\t\t\t   \"non-contiguous custom color indices found - not handled yet!\"\n",
    "\t\t\t\t\t\telif objectType == ObjectType.Polygon:\n",
    "\t\t\t\t\t\t\tcurrentObject, subLineExpected = _readPolylineBase(params[1:])\n",
    "\t\t\t\t\t\t\tcurrentObject.comment = currentComment\n",
    "\t\t\t\t\t\t\tcurrentComment = \"\"\n",
    "\t\t\t\t\t\telif objectType == ObjectType.Arc:\n",
    "\t\t\t\t\t\t\tcurrentObject, subLineExpected = _readArcBase(params[1:])\n",
    "\t\t\t\t\t\t\tcurrentObject.comment = currentComment\n",
    "\t\t\t\t\t\t\tcurrentComment = \"\"\n",
    "\t\t\t\t\t\telif objectType == ObjectType.Spline:\n",
    "\t\t\t\t\t\t\tcurrentObject, subLineExpected = _readSplineBase(params[1:])\n",
    "\t\t\t\t\t\t\tcurrentObject.comment = currentComment\n",
    "\t\t\t\t\t\t\tcurrentComment = \"\"\n",
    "\t\t\t\t\t\telif objectType == ObjectType.Text:\n",
    "\t\t\t\t\t\t\tassert line[-4:] == \"\\\\001\"\n",
    "\t\t\t\t\t\t\tcurrentObject, subLineExpected = _readText(\n",
    "\t\t\t\t\t\t\t\tparams[1:], (\n",
    "\t\t\t\t\t\t\t\tline.split(None, 12)[-1]).split(\" \", 1)[1][:-4])\n",
    "\t\t\t\t\t\t\tcurrentObject.comment = currentComment\n",
    "\t\t\t\t\t\t\tcurrentComment = \"\"\n",
    "\t\t\t\t\t\telif objectType == ObjectType.Ellipse:\n",
    "\t\t\t\t\t\t\tcurrentObject, subLineExpected = _readEllipseBase(params[1:])\n",
    "\t\t\t\t\t\t\tcurrentObject.comment = currentComment\n",
    "\t\t\t\t\t\t\tcurrentComment = \"\"\n",
    "\t\t\t\t\t\telif objectType == ObjectType.CompoundBegin:\n",
    "\t\t\t\t\t\t\tstack.append(_readCompound(params[1:]))\n",
    "\t\t\t\t\t\t\tstack[-1].comment = currentComment\n",
    "\t\t\t\t\t\t\tcurrentComment = \"\"\n",
    "\t\t\t\t\t\telif objectType == ObjectType.CompoundEnd:\n",
    "\t\t\t\t\t\t\tcurrentObject = stack.pop()\n",
    "\t\t\t\t\t\telse:\n",
    "\t\t\t\t\t\t\traise ValueError(\n",
    "\t\t\t\t\t\t\t\t\"Unhandled object type %s!\" % (objectType, ))\n",
    "\t\t\t\t\tif currentObject != None and not subLineExpected:\n",
    "\t\t\t\t\t\tif stack:\n",
    "\t\t\t\t\t\t\tstack[-1].append(currentObject)\n",
    "\t\t\t\t\t\telse:\n",
    "\t\t\t\t\t\t\tself.append(currentObject)\n",
    "\t\t\t\t\t\tcurrentObject = None\n",
    "\t\t\t\t  except ValueError:\n",
    "\t\t\t\t\t  sys.stderr.write(\"Parse error in %s, line %i:\\n%s\\n\\n\" %\n",
    "\t\t\t\t\t\t\t\t\t   (filename, lineIndex + extraLineCount + 1, line))\n",
    "\t\t\t\t\t  raise\n",
    "\t\t\t\tlineIndex += 1\n",
    "\t\t\tassert lineIndex > 7, \".fig File truncated (header incomplete)\"\n",
    "\t\t\tif not self:\n",
    "\t\t\t\tsys.stderr.write(\"WARNING: File empty (no objects read)!\\n\")\n",
    "\n",
    "\tdef append(self, object):\n",
    "\t\t\"\"\"Adds the object to this document.  `object` is supposed to\n",
    "\t\tbe a `fig.Object`-derived object.  `CustomColor` objects are\n",
    "\t\tappended to self.colors as if `addColor()` was called.\"\"\"\n",
    "\n",
    "\t\tif isinstance(object, CustomColor):\n",
    "\t\t\tself.addColor(object)\n",
    "\t\telse:\n",
    "\t\t\tContainer.append(self, object)\n",
    "\n",
    "\tdef addColor(self, hexCode):\n",
    "\t\t\"\"\"Adds a custom color to this document.  hexCode may be\n",
    "\t\teither a hex code like #ffee00 or a CustomColor instance.\n",
    "\t\tReturns the new `CustomColor` object.\n",
    "\t\tSee `getColor`, too.\"\"\"\n",
    "\n",
    "\t\tassert len(self.colors) < 512, \\\n",
    "\t\t\t   \".fig file format does not allow more than 512 custom colors!\"\n",
    "\t\tif isinstance(hexCode, str):\n",
    "\t\t\tresult = CustomColor(Color.Custom0 + len(self.colors), hexCode)\n",
    "\t\telif isinstance(hexCode, CustomColor):\n",
    "\t\t\tresult = hexCode\n",
    "\t\t\thexCode = result.hexCode\n",
    "\t\telse:\n",
    "\t\t\traise TypeError(\"addColor() should be called with a hexCode (e.g. #ffee00) or a CustomColor instance\")\n",
    "\t\tself.colors.append(result)\n",
    "\t\tself._colorhash[hexCode] = result\n",
    "\t\treturn result\n",
    "\n",
    "\tdef getColor(self, color, similarity = None):\n",
    "\t\t\"\"\"Return a color object for the given color, adding a new\n",
    "\t\tcustom color to this document if it does not yet exist.  The\n",
    "\t\tcolor can be given as tuple of R,G,B values or as hex string\n",
    "\t\t(e.g. (0, 255, 0) or '#00ff00' for green).  The range of valid\n",
    "\t\tR,G,B values depends on the type: integer values are expected\n",
    "\t\tto be in the range 0..255, while float values are interpreted\n",
    "\t\tas percentage values in the closed interval [0.0, 1.0].\n",
    "\n",
    "\t\tIf a `CustomColor` object with the given color is already\n",
    "\t\tpresent, it will be returned.  Otherwise, `addColor` will be\n",
    "\t\tcalled, and the new object is returned.\n",
    "\n",
    "\t\tIf the optional parameter `similarity` is > 0.0, getColor()\n",
    "\t\twill return the first color found whose RGB difference's\n",
    "\t\tmagnitude is < `similarity`, if any (otherwise, it will call\n",
    "\t\t`addColor()`, exactly as if similarity was not used).  This is\n",
    "\t\tuseful if you expect many thousands of slightly different\n",
    "\t\tcolors, which are not supported by XFig (the current format\n",
    "\t\tsupports 512 custom colors).\n",
    "\n",
    "\t\tIf `similarity` is given, but not > 0.0, `addColor()` will\n",
    "\t\t*not* be called, but a `KeyError` will be raised, if the exact\n",
    "\t\tcolor cannot be returned.\"\"\"\n",
    "\n",
    "\t\tinputGiven = color\n",
    "\n",
    "\t\t# convert grayvalues to RGB triples:\n",
    "\t\tif isinstance(color, (float, int)):\n",
    "\t\t\tcolor = (color, color, color)\n",
    "\n",
    "\t\t# accept colors as 3-tuples of (0..255)\n",
    "\t\tif isinstance(color, tuple):\n",
    "\t\t\t# convert 0..1 floats to 0..255 integers:\n",
    "\t\t\tif isinstance(color[0], float):\n",
    "\t\t\t\tcolor = (int(round((color[0]*255))),\n",
    "\t\t\t\t\t\t int(round((color[1]*255))),\n",
    "\t\t\t\t\t\t int(round((color[2]*255))))\n",
    "\t\t\tcolor = \"#%02x%02x%02x\" % color\n",
    "\n",
    "\t\t# accept any iterable RGB color objects, too:\n",
    "\t\tif not isinstance(color, str):\n",
    "\t\t\tcolor = \"#%02x%02x%02x\" % tuple(color)\n",
    "\n",
    "\t\tassert len(color) == 7, \\\n",
    "\t\t\t   \"too large values given for red, green, or blue: %s\" % (inputGiven, )\n",
    "\n",
    "\t\tresult = self._colorhash.get(color, None)\n",
    "\t\tif result != None:\n",
    "\t\t\treturn result\n",
    "\n",
    "\t\tif similarity == None:\n",
    "\t\t\treturn self.addColor(color)\n",
    "\n",
    "\t\tif not similarity > 0.0:\n",
    "\t\t\traise KeyError(\"getColor(%s): no similar color found\" % color)\n",
    "\n",
    "\t\tif self.colors: # don't choke when there are no colors yet\n",
    "\t\t\tdef rgbDiffSortTuple(otherRGB,\n",
    "\t\t\t\t\t\t\t\t searchRGB = CustomColor(None, color)):\n",
    "\t\t\t\treturn sum(map(lambda x: x*x, searchRGB-otherRGB)), otherRGB\n",
    "\t\t\tmatches = map(rgbDiffSortTuple, self.colors)\n",
    "\t\t\tmatches.sort()\n",
    "\t\t\tbestSqDiff, bestColor = matches[0]\n",
    "\t\t\tif bestSqDiff < similarity*similarity:\n",
    "\t\t\t\treturn bestColor\n",
    "\n",
    "\t\treturn self.addColor(color)\n",
    "\n",
    "\tdef colorRGB(self, colorIndex):\n",
    "\t\t\"\"\"Return a the R,G,B tuple for the given color index.\n",
    "\t\t(With values from the range 0..255.)\"\"\"\n",
    "\t\t\n",
    "\t\tassert colorIndex >= 0 and colorIndex < Color.Custom0 + len(self.colors), \\\n",
    "\t\t\t   \"invalid color index %d\" % colorIndex\n",
    "\t\tif colorIndex < Color.Custom0:\n",
    "\t\t\treturn standardColors[colorIndex]\n",
    "\t\telse:\n",
    "\t\t\treturn self.colors[colorIndex - Color.Custom0].rgb()\n",
    "\n",
    "\tdef gray(self, grayLevel):\n",
    "\t\t\"\"\"Return a color representing the given graylevel (see\n",
    "\t\tgetColor).  grayLevel can be a float in the range 0.0 - 1.0 or\n",
    "\t\ta 0 - 255 integer.\"\"\"\n",
    "\t\t\n",
    "\t\treturn self.getColor((grayLevel, grayLevel, grayLevel))\n",
    "\n",
    "\tdef headerStr(self):\n",
    "\t\t\"\"\"Return the first lines of the XFig file output, which contain\n",
    "\t\tglobal document information like orientation / units / ...\"\"\"\n",
    "\t\t\n",
    "\t\tresult = \"#FIG 3.2\\n\"\n",
    "\t\tif self.landscape:\n",
    "\t\t\tresult += \"Landscape\\n\"\n",
    "\t\telse:\n",
    "\t\t\tresult += \"Portrait\\n\"\n",
    "\t\tif self.centered:\n",
    "\t\t\tresult += \"Center\\n\"\n",
    "\t\telse:\n",
    "\t\t\tresult += \"Flush Left\\n\"\n",
    "\t\tif self.metric:\n",
    "\t\t\tresult += \"Metric\\n\"\n",
    "\t\telse:\n",
    "\t\t\tresult += \"Inches\\n\"\n",
    "\t\tresult += self.paperSize + \"\\n\"\n",
    "\t\tresult += str(self.magnification) + \"\\n\"\n",
    "\t\tif self.singlePage:\n",
    "\t\t\tresult += \"Single\\n\"\n",
    "\t\telse:\n",
    "\t\t\tresult += \"Multiple\\n\"\n",
    "\t\tresult += str(self.transparentColor) + \"\\n\"\n",
    "\t\tresult += _formatComment(self.comment)\n",
    "\t\tresult += str(self.ppi) + \" 2\\n\" # (2: only used coordinate system)\n",
    "\t\treturn result\n",
    "\n",
    "\tdef objectsStr(self):\n",
    "\t\t\"\"\"figfile.objectsStr()\n",
    "\n",
    "\t\tReturns the part of the XFig file containing all objects\n",
    "\t\t(but not the custom colors).  This is the same as str(object)\n",
    "\t\tconcatenated for each object in `figfile`.\"\"\"\n",
    "\t\t\n",
    "\t\treturn \"\".join(map(str, self))\n",
    "\n",
    "\tdef __str__(self):\n",
    "\t\t\"\"\"Return the contents of this file as string in the XFig file format.\n",
    "\t\tSee save().\"\"\"\n",
    "\t\t\n",
    "\t\tassert len(self.colors) < 512, \\\n",
    "\t\t\t   \".fig file format does not allow more than 512 custom colors!\"\n",
    "\t\tresult = self.headerStr() + \\\n",
    "\t\t\t\t \"\".join(map(repr, self.colors)) + \\\n",
    "\t\t\t\t self.objectsStr()\n",
    "\t\treturn result\n",
    "\n",
    "\tdef save(self, filename = None, fig2dev = None):\n",
    "\t\t\"\"\"figfile.save(filename = None)\n",
    "\n",
    "\t\tSaves the contents of this file in the XFig file format to\n",
    "\t\tthe file 'filename'.  Equivalent to::\n",
    "\t\t\n",
    "\t\t  file(filename, \"w\").write(str(figfile))\n",
    "\n",
    "\t\tIf filename is not given, and figfile was constructed from an\n",
    "\t\texisting file, that one is overwritten (-> figfile.filename).\n",
    "\t\tIf the filename does not end in '.fig', the extension is\n",
    "\t\tappended.\n",
    "\t\t\n",
    "\t\tAfter saving, the filename becomes the new figfile.filename\n",
    "\t\tand would be used for the next save() without filename.\n",
    "\n",
    "\t\tThe return value is the output file written last, i.e. it\n",
    "\t\tdepends on whether fig2dev was given:\n",
    "\n",
    "\t\t- if fig2dev == None (default), figfile.filename is returned\n",
    "\t\t- otherwise, the exported filename is returned (e.g. basename.eps)\"\"\"\n",
    "\n",
    "\t\tif filename != None:\n",
    "\t\t\tif not filename.endswith(\".fig\"):\n",
    "\t\t\t\tfilename += \".fig\"\n",
    "\t\t\tself.filename = filename\n",
    "\t\tassert self.filename, \"figfile.save() needs a filename!\"\n",
    "\n",
    "\t\t# construct whole string in memory for exception safety:\n",
    "\t\toutput = str(self)\n",
    "\t\t# everything's fine, *now* write to file:\n",
    "\t\tfile(self.filename, \"w\").write(output)\n",
    "\n",
    "\t\tif fig2dev:\n",
    "\t\t\treturn self.fig2dev(lang = fig2dev)\n",
    "\n",
    "\t\treturn self.filename\n",
    "\n",
    "\tdef fig2dev(self, input = None, output = None, lang = \"eps\"):\n",
    "\t\t\"\"\"figfile.fig2dev(input = None, output = None, lang = \"eps\")\n",
    "\t\t\n",
    "\t\tCalls fig2dev on the file `input` to produce the file `output`.\n",
    "\t\t(Both default to the current figfile's filename and the same\n",
    "\t\tfilename with the extension changed to `lang`.)\n",
    "\t\tNote that `output` must be a path *relative to the `input` path*!\n",
    "\t\tReturns the filename of the resulting file.\n",
    "\n",
    "\t\tUsually, you just call sth. like ::\n",
    "\n",
    "\t\t   figfile = fig.File(\"myfigfile.fig\")\n",
    "\t\t   ...\n",
    "\t\t   figfile.save()\n",
    "\t\t   figfile.fig2dev(lang = \"pdf\")\n",
    "\n",
    "\t\tto produce myfigfile.pdf.  It is now even easier to use the\n",
    "\t\tfollowing convenience shortcut::\n",
    "\n",
    "\t\t   figfile.save(fig2dev = \"pdf\")\n",
    "\t\t\"\"\"\n",
    "\t\t\n",
    "\t\tif input == None:\n",
    "\t\t\tinput = self.filename\n",
    "\n",
    "\t\tpath, basename = os.path.split(input)\n",
    "\n",
    "\t\tif not output:\n",
    "\t\t\toutput = basename\n",
    "\t\t\tif output.endswith(\".fig\"):\n",
    "\t\t\t\toutput = output[:-4]\n",
    "\t\t\toutput += \".\" + lang\n",
    "\t\t\n",
    "\t\toldcwd = None\n",
    "\t\tif path:\n",
    "\t\t\toldcwd = os.path.abspath(\".\")\n",
    "\t\t\tos.chdir(path)\n",
    "\n",
    "\t\ttry:\n",
    "\t\t\toutFile = file(output, \"w\")\n",
    "\t\t\ttry:\n",
    "\t\t\t\timport subprocess\n",
    "\t\t\texcept ImportError:\n",
    "\t\t\t\tcin, cout = os.popen4(\"fig2dev -L %s '%s'\" % (lang, basename))\n",
    "\t\t\t\tcin.close()\n",
    "\t\t\t\toutFile.write(cout.read())\n",
    "\t\t\t\tcout.close()\n",
    "\t\t\telse:\n",
    "\t\t\t\tsubprocess.call([\"fig2dev\", \"-L\", lang, basename],\n",
    "\t\t\t\t\t\t\t\tstdout = outFile)\n",
    "\t\t\toutFile.close()\n",
    "\t\tfinally:\n",
    "\t\t\tif oldcwd:\n",
    "\t\t\t\tos.chdir(oldcwd)\n",
    "\n",
    "\t\treturn os.path.normpath(os.path.join(path, output))\n",
    "\n",
    "# --------------------------------------------------------------------\n",
    "\n",
    "def copyObjects(fileA, fileB):\n",
    "\tcolorMap = {}\n",
    "\tfor color in fileA.colors:\n",
    "\t\tcolorMap[int(color)] = fileB.getColor(color.hexCode)\n",
    "\n",
    "\tfor o in fileA.allObjects():\n",
    "\t\to = copy.deepcopy(o)\n",
    "\t\tif o.penColor >= Color.Custom0:\n",
    "\t\t\to.penColor = colorMap[int(o.penColor)]\n",
    "\t\tif o.fillColor >= Color.Custom0:\n",
    "\t\t\to.fillColor = colorMap[int(o.fillColor)]\n",
    "\t\tfileB.append(o)\n",
    "\n",
    "# --------------------------------------------------------------------\n",
    "#                              TESTING:\n",
    "# --------------------------------------------------------------------\n",
    "\n",
    "if __name__ == \"__main__\":\n",
    "\tif len(sys.argv) > 1:\n",
    "\t\tdef normalize(text):\n",
    "\t\t\tresult = []\n",
    "\t\t\tfor line in text.split(\"\\n\"):\n",
    "\t\t\t\t# canonical float representation:\n",
    "\t\t\t\tresult.append(re.sub(r\"(\\.[0-9]+?)0*\\b\", r\"\\1\", line.strip()))\n",
    "\t\t\treturn result\n",
    "\t\t\n",
    "\t\timport difflib, re\n",
    "\t\tfor fn in sys.argv[1:]:\n",
    "\t\t\tinput = normalize(file(fn).read())\n",
    "\t\t\toutput = normalize(str(File(fn)))\n",
    "#           for line in difflib.unified_diff(input, output):\n",
    "#               print line\n",
    "\t\t\tsm = difflib.SequenceMatcher(None, input, output)\n",
    "\t\t\tfor code, b1, e1, b2, e2 in sm.get_opcodes():\n",
    "\t\t\t\tif code == 'equal':\n",
    "\t\t\t\t\tcontinue\n",
    "\t\t\t\tfor li in range(b1, e1):\n",
    "\t\t\t\t\tprint \"-\", input[li]\n",
    "\t\t\t\tfor li in range(b2, e2):\n",
    "\t\t\t\t\tprint \"+\", output[li]\n",
    "\t\t\t\n",
    "\telse:\n",
    "\t\timport doctest\n",
    "\t\tdoctest.testfile('index.rst')"
   ]
  },
  {
   "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.7.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}