From 143fad8669ea5e75d99458a5cbc78420541aaa64 Mon Sep 17 00:00:00 2001 From: sup39 Date: Fri, 4 Feb 2022 20:24:40 +0900 Subject: [PATCH] init --- LICENSE | 22 + README.md | 6 + shape.ipynb | 1127 +++++++++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 1155 insertions(+) create mode 100644 LICENSE create mode 100644 README.md create mode 100644 shape.ipynb diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..44700e0 --- /dev/null +++ b/LICENSE @@ -0,0 +1,22 @@ +Copyright (c) 2022 sup39[サポミク] + +Permission is hereby granted, free of charge, to any person +obtaining a copy of this software and associated documentation +files (the "Software"), to deal in the Software without +restriction, including without limitation the rights to use, +copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the +Software is furnished to do so, subject to the following +conditions: + +The above copyright notice and this permission notice shall be +included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES +OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT +HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, +WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR +OTHER DEALINGS IN THE SOFTWARE. \ No newline at end of file diff --git a/README.md b/README.md new file mode 100644 index 0000000..3c488bd --- /dev/null +++ b/README.md @@ -0,0 +1,6 @@ +# SMS-Shape-Notebook +多角形と多面体のクラスを実装したJupyter Notebookです。これを使って斜面をすり抜ける範囲を描画することができます。今後Dolphinと連携するといった機能を追加する予定です。 + +This is a Jupyter Notebook that implements Polygon and Polyhedron class. +You can use this notebook to plot the area that you can clip through a slope. +I will add some functions in the future such as accessing Dolphin's memory. \ No newline at end of file diff --git a/shape.ipynb b/shape.ipynb new file mode 100644 index 0000000..983f4a8 --- /dev/null +++ b/shape.ipynb @@ -0,0 +1,1127 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "62555b4e-5276-4457-a870-dc3d6edb65f9", + "metadata": {}, + "source": [ + "# SMS Shape Notebook" + ] + }, + { + "cell_type": "markdown", + "id": "7f65558a-315c-44cf-a3dc-17a92eefe171", + "metadata": {}, + "source": [ + "## 準備 Preparation" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1bba5694-e605-4c44-b263-aa9beb3ac116", + "metadata": {}, + "outputs": [], + "source": [ + "# 必要なパッケージをインストール\n", + "# Install the required packages\n", + "!pip install numpy matplotlib" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "bb2b194e-b451-4a35-ba17-f74619d658c5", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "from numpy import array\n", + "import matplotlib.pyplot as plt\n", + "from matplotlib.path import Path\n", + "from matplotlib import patches\n", + "import matplotlib.ticker as plticker\n", + "normalize = lambda x: x/np.linalg.norm(x)\n", + "tau = 2*np.pi" + ] + }, + { + "cell_type": "markdown", + "id": "00ec378c-11c0-48fa-b863-430c82d5b015", + "metadata": {}, + "source": [ + "### 日本語を含む図の作成
Making plot containing Japanese\n", + "日本語を含む図を作成する際に、次のパッケージをインストールしてimportする必要があります。 \n", + "If you are making plots containing Japanese, you have to install\n", + "and import the following package." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "cd3ea05f-666b-420c-a020-e53b01ade1ae", + "metadata": {}, + "outputs": [], + "source": [ + "!pip install japanize_matplotlib" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b4fa0f55-3570-47f6-9f5f-0da6bb6e9f7f", + "metadata": {}, + "outputs": [], + "source": [ + "import japanize_matplotlib" + ] + }, + { + "cell_type": "markdown", + "id": "528ea79d-13f4-4c98-a306-1fa55071f05c", + "metadata": {}, + "source": [ + "### class of shapes\n", + "多角形と凸多面体を実装したクラス \n", + "Classes that implement polygon and convex polyhedron" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "21603f5b-59ad-45d3-945e-58978b8b3099", + "metadata": {}, + "outputs": [], + "source": [ + "# 多角形\n", + "class Polygon():\n", + " def __init__(self, verts):\n", + " '''\n", + " * self.verts:\n", + " 頂点の配列\n", + " Array of vertices\n", + " '''\n", + " self.verts = np.array(verts)\n", + " def clipLine(self, p, n, c=0):\n", + " '''\n", + " 半平面 (x-p)・n >= c との共通部分の多角形を返す\n", + " Return the intersection polygon with half plane (x-p)・n >= c\n", + " * p:\n", + " 直線上の一点\n", + " Any point on the line\n", + " * n:\n", + " 直線の法線ベクトル\n", + " Normal vector of the line\n", + " * c:\n", + " 定数\n", + " Constant\n", + " '''\n", + " p, n, c = map(array, (p, n, c))\n", + " r = np.dot(self.verts-p, n)-c\n", + " verts = []\n", + " for i in range(len(r)):\n", + " v0, r0 = self.verts[i-1], r[i-1]\n", + " v1, r1 = self.verts[i], r[i]\n", + " if r1 >= 0:\n", + " if r0 < 0: # (- +)\n", + " verts.append((r1*v0-r0*v1)/(-r0+r1))\n", + " verts.append(v1)\n", + " elif r0 >= 0: # (+ -)\n", + " verts.append((-r1*v0+r0*v1)/(r0-r1))\n", + " return Polygon(array(verts).reshape(-1, self.verts.shape[1]))\n", + " def path(self, axis=(0, 1)):\n", + " '''\n", + " Get Path instance\n", + " * axis:\n", + " 用いる軸を指定(デフォルト:xとy)\n", + " - ``(0, 2)'': xとz\n", + " - ``(2, 1)'': zとy\n", + " The axes to use (Defaults: x, y)\n", + " - ``(0, 2)'': x and z\n", + " - ``(2, 1)'': z and y\n", + " '''\n", + " if self.verts.shape[0] == 0: return Path(np.zeros((0, 2)))\n", + " verts = self.verts[:, axis]\n", + " assert verts.shape[-1] == 2, 'verts should be 2D'\n", + " return Path([*verts, (0, 0)], [\n", + " Path.MOVETO,\n", + " *(Path.LINETO for _ in range(1, verts.shape[0])),\n", + " Path.CLOSEPOLY,\n", + " ])\n", + " def plot(self, axis=(0, 1), margin=0.05, facecolor='#2ee5b8', lw=1):\n", + " '''\n", + " この多角形を描画し、figとaxを返す\n", + " Plot this polygon and return ``fig'' and ``ax''\n", + " * axis:\n", + " self.pathを参照\n", + " See self.path\n", + " * margin:\n", + " Margin of the plot\n", + " * facecolor:\n", + " 面の色\n", + " Face color\n", + " * lw:\n", + " 線の太さ\n", + " Line width\n", + " '''\n", + " fig, ax = plt.subplots()\n", + " if self.verts.shape[0] == 0: return fig, ax\n", + " # path\n", + " path = self.path(axis)\n", + " patch = patches.PathPatch(path, facecolor=facecolor, lw=lw)\n", + " ax.add_patch(patch)\n", + " verts = self.verts[:, axis]\n", + " xMax, yMax = verts.max(axis=0)\n", + " xMin, yMin = verts.min(axis=0)\n", + " xMg, yMg = verts.ptp(axis=0)*margin\n", + " ax.set_xlim(xMin-xMg, xMax+xMg)\n", + " ax.set_ylim(yMin-yMg, yMax+yMg)\n", + " return fig, ax\n", + " def __repr__(self):\n", + " return f'Polygon with {len(self.verts)}vertices:\\n{self.verts}'\n", + "\n", + "# 多面体\n", + "class Polyhedron:\n", + " def __init__(self, verts, edges):\n", + " '''\n", + " * self.verts:\n", + " 頂点の配列\n", + " Array of vertices\n", + " * self.edges:\n", + " 辺(2頂点の番号)の配列\n", + " Array of edges (indices of 2 vertices)\n", + " '''\n", + " self.verts = np.array(verts)\n", + " self.edges = edges\n", + " def clipPlane(self, p, n, c=0):\n", + " '''\n", + " 半空間 (x-p)・n >= c との共通部分の多面体を返す\n", + " Return the intersection polyhedron with half space (x-p)・n >= c\n", + " * p:\n", + " 平面上の一点\n", + " Any point on the plane\n", + " * n:\n", + " 直線の法線ベクトル\n", + " Normal vector of the plane\n", + " * c:\n", + " 定数\n", + " Constant\n", + " '''\n", + " p, n, c = map(array, (p, n, c))\n", + " r = np.dot(self.verts-p, n)-c\n", + " rb = [s>=0 for s in r]\n", + " # map vertex indices old to new\n", + " io2n = {\n", + " iO: iN\n", + " for iN, iO in enumerate(iO for iO, sb in enumerate(rb) if sb)\n", + " }\n", + " # handle old vert\n", + " verts = [v for v, sb in zip(self.verts, rb) if sb]\n", + " edges = []\n", + " for i0, i1 in self.edges:\n", + " if rb[i0] and rb[i1]:\n", + " # remain\n", + " edges.append((io2n[i0], io2n[i1]))\n", + " elif rb[i0] or rb[i1]:\n", + " # new vert\n", + " v0, r0 = self.verts[i0], abs(r[i0])\n", + " v1, r1 = self.verts[i1], abs(r[i1])\n", + " vN = (r1*v0+r0*v1)/(r0+r1)\n", + " edges.append((io2n[i0 if rb[i0] else i1], len(verts)))\n", + " verts.append(vN)\n", + " # else drop edge\n", + " # add new face\n", + " nOld = len(io2n)\n", + " vNews = verts[nOld:]\n", + " if len(vNews):\n", + " assert len(vNews) >= 3\n", + " p0, p1 = vNews[:2]\n", + " # choose p1-p0 as e1\n", + " e1 = normalize(p1-p0)\n", + " # choose e2 that ⊥ n, e1\n", + " e2 = normalize(np.cross(n, e1))\n", + " # set (p0+p1)/2 as new origin, and use {e1, e2} as new basis\n", + " cNews = np.dot(vNews-(p0+p1)/2, array([e1, e2]).transpose())\n", + " # indices of new verts CCW\n", + " jNews = nOld+np.arctan2(cNews[:,0], cNews[:,1]).argsort()\n", + " # add to edge\n", + " for i in range(len(vNews)):\n", + " edges.append((jNews[i-1], jNews[i]))\n", + " # final\n", + " return Polyhedron(array(verts).reshape(-1, self.verts.shape[1]), edges)\n", + " def slicePlane(self, p, n):\n", + " '''\n", + " 平面 (x-p)・n=0 との共通部分(多角形)の頂点を返す\n", + " Return vertices of intersection(polygon) with plane (x-p)・n=0\n", + " * p:\n", + " 平面上の一点\n", + " Any point on the plane\n", + " * n:\n", + " 平面の法線ベクトル\n", + " Normal vector of the plane\n", + " '''\n", + " p, n = map(array, (p, n))\n", + " r = np.dot(self.verts-p, n)\n", + " vNews = []\n", + " # handle old verts\n", + " for i0, i1 in self.edges:\n", + " # two vertices on other side of the plane\n", + " if np.sign(r[i0]) != np.sign(r[i1]):\n", + " v0, r0 = self.verts[i0], abs(r[i0])\n", + " v1, r1 = self.verts[i1], abs(r[i1])\n", + " vN = (r1*v0+r0*v1)/(r0+r1)\n", + " vNews.append(vN)\n", + " # new verts\n", + " if len(vNews):\n", + " assert len(vNews) >= 2\n", + " p0, p1 = vNews[:2]\n", + " e1 = normalize(p1-p0)\n", + " e2 = normalize(np.cross(n, e1))\n", + " cNews = np.dot(vNews-(p0+p1)/2, array([e1, e2]).transpose())\n", + " jNews = np.arctan2(cNews[:,0], cNews[:,1]).argsort()\n", + " return array([vNews[j] for j in jNews])\n", + " else:\n", + " return array(np.zeros((0, self.verts.shape[-1])))\n", + " def __repr__(self):\n", + " return 'Polyhedron with %d vertices and %d edges:\\n%s'%(\n", + " len(self.verts), len(self.edges),\n", + " #'\\n'.join(line for line in str(\n", + " array([self.verts[[i0, i1]] for i0, i1 in self.edges])\n", + " #).split('\\n') if line)\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "a2316c48-2614-4f93-b152-f0d8ab379c9b", + "metadata": {}, + "outputs": [], + "source": [ + "# 等高線図\n", + "def contourMap(poly, ys, colors, margin=0.05, lw=1):\n", + " '''\n", + " 与えたy座標に対して多面体の等高線図を描画\n", + " Plot a contour map of polyhedron with given y\n", + " * poly:\n", + " 多面体\n", + " Polyhedron\n", + " * ys:\n", + " 等高線のy座標配列\n", + " Array of y coordinate of the contour map\n", + " * colors:\n", + " 各層の色の配列\n", + " Array of colors of each layer\n", + " * margin:\n", + " Margin of the plot\n", + " * lw:\n", + " 線の太さ\n", + " Line width\n", + " '''\n", + " fig, ax = plt.subplots()\n", + " xyMin = array([np.inf]*2)\n", + " xyMax = -xyMin\n", + " for y, color in zip(ys, colors):\n", + " verts = poly.slicePlane((0, y, 0), (0, 1, 0))\n", + " verts = verts[:, (0, 2)] # (x, z)\n", + " path = Polygon(verts).path()\n", + " ax.add_patch(patches.PathPatch(path, facecolor=color, lw=lw))\n", + " # update xyMin, xyMax\n", + " xyMin = np.min([xyMin, *verts], axis=0)\n", + " xyMax = np.max([xyMax, *verts], axis=0)\n", + " # 座標の範囲を設定\n", + " # set range of coordinate\n", + " xyRg = (xyMax-xyMin)*margin\n", + " xyMax += xyRg\n", + " xyMin -= xyRg\n", + " ax.set_xlim(xyMin[0], xyMax[0])\n", + " ax.set_ylim(xyMin[1], xyMax[1])\n", + " return fig, ax" + ] + }, + { + "cell_type": "markdown", + "id": "83b62be5-adad-43f4-af69-6a0895c4c6da", + "metadata": {}, + "source": [ + "## すり抜け可能領域の可視化
Visualization of the area that you can clip through" + ] + }, + { + "cell_type": "markdown", + "id": "05bb2811-1590-4315-8c74-1cf3643683c0", + "metadata": {}, + "source": [ + "### 三角形の座標\n", + "調べたい三角形の座標を入力しましょう。例としてシレナINの地面三角形を使います。 \n", + "Fill in the coordinates of the triangle that you want to research on.\n", + "I will use the floor triangle of Sirena IN as an example." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b6d717b7-2cb5-4843-850c-deefd755cac4", + "metadata": {}, + "outputs": [], + "source": [ + "tri = array([\n", + " (-331.148, 2064.531, 1757.190),\n", + " (174.367, 2357.666, 1443.628),\n", + " (-174.367, 2357.666, 1443.628),\n", + "])" + ] + }, + { + "cell_type": "markdown", + "id": "958256e5-ba48-4d89-a5d9-cfffedd2095c", + "metadata": {}, + "source": [ + "hex形式の座標データを使う場合、次のように配列に変換することができます。 \n", + "If you use the hex form of the coordinate data,\n", + "you can convert it to array as shown below." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "f0c3daf3-4b26-4a4e-a7bf-ad6a7e7e89a0", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[-331.14801025, 2064.53100586, 1757.18994141],\n", + " [ 174.36700439, 2357.66601562, 1443.62805176],\n", + " [-174.36700439, 2357.66601562, 1443.62805176]])" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "raw = 'C3 A5 92 F2 45 01 08 7F 44 DB A6 14 43 2E 5D F4 45 13 5A A8 44 B4 74 19 C3 2E 5D F4 45 13 5A A8 44 B4 74 19'\n", + "tri = np.frombuffer(bytes.fromhex(raw), '>f').astype('d').reshape(3, 3)\n", + "tri" + ] + }, + { + "cell_type": "markdown", + "id": "a59964d7-767e-49ee-b510-c9f9fafb62ce", + "metadata": {}, + "source": [ + "### すり抜け可能領域
The area that you can clip through\n", + "マリオの位置を`M`、水平速度を`vh`、鉛直速度を`vy`とし、三角形の境界は水平方向で`B`を通って`nB`を単位法線ベクトル(三角形外向き)とした直線とし、すり抜ける地面の高さを`yB`とすると、すり抜ける条件は次の通りです。 \n", + "1. `M`が三角形の上方にある\n", + "2. 1QF後マリオが地面の判定の下にいる:`M.y + vy/4 < yB-30`\n", + "3. 1QF後マリオが水平方向で境界を超える:`(M+vh/4-B)・nB > 0`\n", + "\n", + "Let `M` be Mario's position,\n", + "`vh` be his horizontal speed, and `vy` be his vertical speed,\n", + "the border of the triangle be a line passes `B`\n", + "with normalized normal vector `nB` (point outward from the triangle)\n", + "horizontally, and the height of the triangle Mario that clips though be `yB`,\n", + "he can clip through the floor if the following conditions are met.\n", + "1. `M` is above the triangle\n", + "2. Mario is below the hitbox of the floor triangle after 1 QF: `M.y + vy/4 < yB-30`\n", + "3. Mario cross the border horizontally after 1 QF: `(M+vh/4-B)・nB > 0`" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "4a7cc39b-1506-46ba-a6d9-2f9714d6b747", + "metadata": {}, + "outputs": [], + "source": [ + "def getClipThroughArea(vh, vy, B, nB, yB):\n", + " # 法線ベクトルを正規化\n", + " # normalize normal vector\n", + " nB = normalize(nB) \n", + " \n", + " # 条件1において、三角形以上の領域は無限に続く三角柱であるが、\n", + " # 無限の処理はややこしいため、ここでは適当な上限(yMax+75)を設けて\n", + " # 多面体である三角柱にする。\n", + " # For condition 1, the area above the triangle is a\n", + " # triangular prism that extends infinitely.\n", + " # However, it is difficult to deal with infinity,\n", + " # and therefore we choose an appropriate upper bound (yMax+75)\n", + " # and make the area a finite triangular prism.\n", + " poly = Polyhedron([\n", + " # 下の三角形 = 地面三角形\n", + " # the bottom triangle = the floor triangle\n", + " *tri,\n", + " # 上の三角形:xとz座標を固定してyをyMax+75とする\n", + " # the upper triangle: fix x and z coordinate and set y=yMax+75\n", + " *(\n", + " [v[0], tri[:,1].max()+75, v[2]]\n", + " for v in tri\n", + " )\n", + " ], [\n", + " e for i in range(3)\n", + " for e in [\n", + " # 下の三角形の辺\n", + " # the edge of the bottom triangle\n", + " (i, (i+1)%3),\n", + " # 上の三角形の辺\n", + " # the edge of the upper triangle\n", + " (3+i, 3+(i+1)%3),\n", + " # 下の三角形から上の三角形を繋ぐ辺\n", + " # the edge that connect the bottom triangle and the upper triangle\n", + " (i, 3+i),\n", + " ]\n", + " ])\n", + "\n", + " # 条件2において、M.y + vy/4 < yB-30より、\n", + " # For confition 2, since M.y + vy/4 < yB-30,\n", + " # -M.y > vy/4+30-yB\n", + " # (M-0)・(0, -1, 0) > vy/4+30-yB\n", + " poly = poly.clipPlane((0, 0, 0), (0, -1, 0), vy/4+30-yB)\n", + "\n", + " # 条件3において、(M-(B-vh/4))・nB > 0\n", + " # For condition 3, (M-(B-vh/4))・nB > 0\n", + " poly = poly.clipPlane(B-vh/4, nB)\n", + " \n", + " # 条件1~3を満たす領域はpolyとなる\n", + " # Now the area satisfies condition 1.~3. is exactly poly\n", + " return poly" + ] + }, + { + "cell_type": "markdown", + "id": "7f2c757f-995a-4075-9bf4-478a7377a713", + "metadata": {}, + "source": [ + "シレナINの例で定数は次のように与えられたとすると、上記の関数を用いれば、すり抜け可能領域が求まります。 \n", + "In the Sirena IN example, suppose the constants are given as below.\n", + "You can then simply use the function above to get the area\n", + "that you can clip though." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "2f14f7cf-0187-4fdb-9d18-0e9ef08ff423", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "poly = getClipThroughArea(\n", + " # 水平速度 horizontal speed\n", + " vh = array([0, 0, -50]),\n", + " # 鉛直速度 vertical speed\n", + " vy = -75,\n", + " # 境界上の一点 a point on the border\n", + " B = tri[1],\n", + " # 境界の法線ベクトル normal vector of the border\n", + " nB = array([0, 0, -1]),\n", + " # すり抜ける地面の高さ\n", + " # height of the triangle that Mario clips through\n", + " yB = tri[1][1],\n", + ")\n", + "\n", + "# x=0のときの断面図を描画。図の横軸をz軸(2)、縦軸をy軸(1)とする\n", + "# plot the cross section when x = 0\n", + "# use z(2) as horizontal axis and y(1) as vertical axis\n", + "fig, ax = Polygon(poly.slicePlane((0, 0, 0), (1, 0, 0))).plot(axis=(2, 1))\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "6ed1e86e-e805-4be4-acde-0446cdf4063c", + "metadata": {}, + "source": [ + "生成した図に関して、matplotlibで色々設定できます。 \n", + "You can configure the generated plot with matplotlib." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "0b64860d-b36b-4b5c-bb03-3e00daca9014", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = Polygon(poly.slicePlane((0, 0, 0), (1, 0, 0))[:,[2,1]]).plot()\n", + "\n", + "# 図のサイズを設定 resize figure\n", + "fig.set_size_inches(6, 6)\n", + "\n", + "# タイトルを設定\n", + "ax.set_title('SB Pipe (vy=-75, vz=-50)')\n", + "# x軸のラベルを設定\n", + "ax.set_xlabel('z')\n", + "# y軸のラベルを設定\n", + "ax.set_ylabel('y')\n", + "\n", + "# 0.05刻みにする\n", + "# set tick interval to 0.05\n", + "ax.xaxis.set_major_locator(plticker.MultipleLocator(base=0.05))\n", + "ax.yaxis.set_major_locator(plticker.MultipleLocator(base=0.05))\n", + "\n", + "# ラベルのフォーマットを設定(xは目盛の値、iは番号)\n", + "# set the format of the labels\n", + "# (x is the value of the tick, and i is the index)\n", + "ax.xaxis.set_major_formatter(lambda x, i: '%.2f'%x)\n", + "ax.yaxis.set_major_formatter(lambda x, i: '%.2f'%x)\n", + "\n", + "# x軸のラベルを30度回転\n", + "# rotate x label 30 deg\n", + "ax.xaxis.set_tick_params(rotation=30)\n", + "\n", + "# グリッドを表示 show grid\n", + "ax.grid()\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "efec5e1f-16d2-4d66-b596-11016f934f1d", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "id": "335e87c1-0a22-4b1c-8161-c684c3dd7105", + "metadata": {}, + "source": [ + "## 付録:本ライブラリによる図の描画
Appendix: Plot with this library" + ] + }, + { + "cell_type": "markdown", + "id": "19d9404c-fead-4a44-a188-6a62da53b932", + "metadata": {}, + "source": [ + "毎回`fig.set_size_inches`でサイズを設定する代わりに、次の命令で図のデフォルトサイズを設定することができます。 \n", + "Instead of using `fig.set_size_inches` every time,\n", + "you can use the following instruction to set the default figure size." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "38910dd9-8393-48e9-8856-9d38ce8ef7e0", + "metadata": {}, + "outputs": [], + "source": [ + "plt.rcParams[\"figure.figsize\"] = (5, 5)" + ] + }, + { + "cell_type": "markdown", + "id": "3cb0f6a6-9feb-457e-a093-7ccda1f36f7b", + "metadata": {}, + "source": [ + "### 多角形 Polygon" + ] + }, + { + "cell_type": "markdown", + "id": "6253eec4-a591-48b5-a4be-e791c14273ae", + "metadata": {}, + "source": [ + "例として、ある正七角形といくつかの半平面との共通部分の描画方法を示します。 \n", + "As an example, I will demonstrate how to draw the intersection polygon\n", + "of a regular heptagon (7-gon) and some half planes." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "7456018c-e8af-4ee7-b23c-4b7699d550f8", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAVgAAAFNCAYAAABFd3doAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8rg+JYAAAACXBIWXMAAAsTAAALEwEAmpwYAAA02ElEQVR4nO3dd3hUVf7H8fd3Jj0DCR2pQYUgSBVBFFj7ChZsq1ixoq4NV/2tvSAgCoQuiIBgRUUFlI5gWykGBZKACKJSFiRACgkhpJzfHzOwERNImzlTvq/nmYfJzCX3k9H55HLnnHvEGINSSqnq57AdQCmlgpUWrFJKeYkWrFJKeYkWrFJKeYkWrFJKeYkWrFJKeYkWrFJKeYkWrApoIpJzzK1IRMbZzqUUQJjtAEpVhTHGdeS+iLiA3cBH9hIp9T96BKuCyTXAHuCbsjYQkc4i8qOIHBCRj0TkAxEZXOL5u0Vki4jsF5G5ItKoxHNGRO4Vkc0ikikiE0REvPsjqUCmBauCSX/gLVPG/G8RiQA+BaYDtYH3gatKPH8+8DJwHXAS8Dsw85hvcxlwJtDes93fq/UnUEFFC1YFBRFpDvwNmHGczc7CfVpsrDGmwBjzCbC6xPM3AdOMMT8YY/KBJ4HuIpJQYpthxphMY8w2YDnQsRp/DBVktGBVsLgF+NYY8+uRB0RkQYkPv24CGgE7jznC3V7ifiPcR60AGGNygH1A4xLb7C5x/yDgQqky6IdcKljcCgwr+YAxpnfJr0Xkb0BjEZESJdsU+MVz/79A8xLbxwJ1gJ3eCq2Cmx7BqoAnImfjPso80eiBFUAR8ICIhIlIX6BrieffB24XkY4iEgkMBVYZY37zQmwVArRgVTDoD3xijDlwvI2MMYeBq4E7gUzgZuBzIN/z/FLgWeBjYBdwCtDPa6lV0BO94LYKZSKyCphkjHnTdhYVfPQIVoUUEfmbiDT0nCLoj3u41ULbuVRw0g+5VKhJBD4EYoGtwLXGmF12I6lgpacIlFLKS/QUgVJKeYkWrFJKeUlQnoOtW7euSUhIsB1DKRVk1qxZs9cYU6+82wdlwSYkJJCcnGw7hlIqyIjI7yfe6n/0FIFSSnmJFqxSSnmJFqxSSnmJFqxSSnmJFqxSSnmJtYIVkaYislxENohImog8XMo254pIlois9dyes5FVKaUqw+YwrULgUWPMDyJSA1gjIkuMMRuO2e4bY8xlFvIppVSVWDuCNcbsMsb84Ll/ANjIn5fmUEqpgOYX52A9i8p1AlaV8nR3EVnnWV+p7XG+xwARSRaR5PT0dG9FVUqpcrNesCLiwn0F+YHGmOxjnv4BaG6M6QCMA2aX9X2MMZONMV2MMV3q1Sv3TDalfKawsJCsrCzbMZQPWS1YEQnHXa7vepZQ/hNjTLZnZU+MMfOBcBGp6+OYSlWKMYaff/6ZCRMmcNEVlxFXtzYnNW/K2PHj0cuEhgZrH3KJiABTgY3GmKQytmkI/GGMMSLSFfcvhH0+jKlUhezdu5cvvviCzxYvZPGSJRwqLMDVsxNhF3eg+Us3U5SVw4sDk5g1dzbvvzmDxo31Y4dgZnMUwTm417JPEZG1nseeApoBGGMmAdcC94lIIZAH9DP6q1/5kUOHDvHtt9+yYPEiPl+yiG1bf6VWt/ZIz/bUevt5Ik9tivtYwi28Xi0afzqcreM+oE2njrw+dhz9+um6isEqKFc06NKli9GraSlvKC4uZv369SxevJjZixfyw6rV1GzdgrAeHYjp1YmYzq2R8PIdtxxcu4n0h5M4v0s3pr42iVq1ank5vaoqEVljjOlS7u21YJU6vu3bt7N06VLmLF7A8qXLcMbFEtWjIxG9OuLq3h5nnKvS37s47xD7hk6nYNEq3ntzBhdddFE1JlfVTQsWLVhVNdnZ2Xz55ZfMW7yIBUsWs2/vXuJ6dMLRsz01enUmokmDat/nga9/YO+jY7jx6mtJeuVVYmJiqn0fquq0YNGCVRVTWFjI6tWrWbh4MXMXL+SnlFRqdToNR8/2xPTsRPTppyAO7w+4Kcw8wP5nJhGR9juz3nmPM8880+v7VBWjBYsWrDq+I8OnlixZwpzFC/nu66+JbnoSET06ENWrI7Fd2+KIjrKWL3POV+x7fjID/3k/zz/9DOHh4dayqD/TgkULVv1Venr6n4ZP5RcV4urVmbCeHXD16Eh4Pf/6gKlg1172Pj6WBgcKmfXOeyQmJtqOpKh4wQblmlxK5eXl8e2337JwyWI+W7KI7Vt/Jf6sDjh6tqf2uy8SeUqTPw2f8jfhJ9Wl4dsvkjljHl3O6c6QFwbx4P33+3Vm9Vd6BKuCQnFxMevWrTs6fOrH1d8Td9rJOHu0dw+f6lT+4VP+Jv+XHewdmESbOifp5ATL9BQBWrChYvv27Z7zqAv48ovlOONcRPUsMXyqZqztiNXGFBaxf/wHHJg+n0ljxnLDDTfYjhSStGDRgg1W2dnZLF++/Ojwqf379xPXoxPOnu1x9epMROP6tiN63cF1P7P34STO7XwmU1+bRO3atW1HCilasGjBBouCgoI/DZ/alJpGrc5tkB7tiO3Viei2vhk+5W+K8/LZ9/J0Chau5N1p07n44ottRwoZWrBowQaqksOnZi9awIpvviGm2UmE9+joHj51Zlsc0ZG2Y/qNA1//wN7HxtKv71WMHj5CJyf4gBYsWrCBJD09naVLl/LZ4oUsWbqU/OIiXL06EdazAzV6dCKsbrztiH6tMPMA+56ZRKROTvAJHaal/NqR4VPzFy9i3pJFbP/1d2p174D0bE/t2/1/+JS/CYuvQYPxj5M592vOu7Q3D9/3T1545lmdnOAn9AhWeVVxcTFr1649Onxq7ffJxJ12Cs6enuFTHRMDdviUvynYvY+9j42hfnYBs955j9atW9uOFHT0CFZZt23btqPTUL/8YhlhtWoS1bMDEbeey6mvPRRUw6f8SXjDOu7JCW/No8s5ZzP4+Rd46IEHcITgB4H+Qo9gVZVlZWWxfPly5i9Z/L/hUz074ezZAVfPTiExfMrf5G/dyd6BSbSOr8/M6W/RpEkT25GCgh7BKq8rKChg1apV7uFTSxbyc+oG4ju3wdGzPa7xj3BKm5NDcviUP4k8uTGNPnmV3yZ8SNtOHZk4Ziw33nij7VghR49g1QkZY9i0aVOJ4VPfEtu8EeE9OxDVU4dP+buD6zez96GR/K1TF6ZNfF0nJ1SBDtNCC7Y67Nmz5+jwqaVLl3IYQ2yvToR7rj4VVifedkRVAcV5+ewbNoPD87/j3WnT+fvf/247UkDSgkULtjLy8vL45ptvjg6f2vHbNmqd3RHp2Y4aPTsTcXJjHT4VBA588yN7Hx1Dv75XMnr4SJ2cUEFasGjBlseR4VOLFi9mzpHhU21OwdmzAzE9OxHTKREJc9qOqbygKCuHfc++Tvj6rcx65z26du1qO1LA0IJFC7Ysv//++9GrT3217EvCa9cksmdHInt2JLZ7O5w1dPhUKMn8/Bv2PzuJB++5jxeffU4nJ5RDwBSsiDQF3gIaAAaYbIwZc8w2AowB+gAHgduMMT+c6HtrwbodGT41b/FCFixZQmZmJjWPDJ/q0YmIxvVsR1SWFfyxj72PjaV+1mGdnFAOgTRMqxB41Bjzg4jUANaIyBJjzIYS2/QGWnpu3YCJnj9VKQoKCli5cuXR4VOb0zZQq8vpOHq0I3bCo9Ru00KHT6k/CW9Qh4ZvvUDm2/M5s8fZDHr2eR5+8EGdnFBN/OYUgYjMAcYbY5aUeOx14EtjzPuerzcB5xpjdh3ve4XKEawxhp9++uno8KmV3/6H2ITGfx4+FRVhO6YKEDo54cQC6Qj2KBFJADoBq455qjGwvcTXOzyPHbdgg11ycjIjx49lyZIlFDjEPXzqsk60eOV2wmrH2Y6nAtT/Jid8RNtOHXlt9BhuvPFGHT1SBdYLVkRcwMfAQGNMdhW+zwBgAECzZs2qKZ3/KS4u5pqbbyT/iu7UnTlYh0+paiVhTuo83I/o88/ggYef5cM5n/LmpMk6OaGSrJ5oEZFw3OX6rjHmk1I22Qk0LfF1E89jf2GMmWyM6WKM6VKvXvB+eLNo0SJywqD+wzfopf2U18S0a0mTeaNJrgWt2rVl4cKFtiMFJGsF6xkhMBXYaIxJKmOzucCt4nYWkHWi86/BbuioEcTcdYUWq/I6R3QkdZ+/m7hRA7nu7tu56757yM3NtR0roNg8gj0HuAU4X0TWem59ROReEbnXs818YCuwBXgD+KelrH4hLS2NtevXE9/3b7ajqBDi6tGRZovHMy/9V1p3bM+qVcd+VKLKYu0crDHmW+C4h2HGPcThft8k8n+vjEqi5i19cETqyADlW844F/XHPkrm599wweWX8uA99zLoued1csIJ6GC3AJGens6sj2cRf0sf21FUCIu/rCfNFo1l6ndL6XhWVzZu3Gg7kl/Tgg0Qr02aRHyfHroIoLLuyOSEA9f1omvPc0gaPZri4mLbsfySFmwAyM/PZ8xrE3DdcbntKEoBICLUuqUPjeeMZOi7U+l50QVs3779xH8xxGjBBoAPPviA8FZNiT6the0oSv1JZItGNPr4FX4/swVtO3fi7bffxl9mh/oDLVg/Z4w5OjRLKX8kYU7qPHQ9Dd55gYeGPE/f665l3759tmP5BS1YP/f111/zR042Nc4r9/RnpayIadeSJvPHsKa20Krd6SxYsMB2JOu0YP3c0KQRxN5xuV4FSwUER1QEdZ+/m/gxj3D9gDu4494BIT05Qd+1fuyXX37h22+/pdY/LrQdRakKcZ3TgWZLJrBg/+8kdmjHypUrbUeyQgvWj40YM5q4G/6OIybKdhSlKsxZM5b6o/9F2L9v4qK+l/HEM09TUFBgO5ZPacH6qaysLN5+523ibrvMdhSlqiTu0h40XTSON1cuo0O3M9mwYcOJ/1KQ0IL1U29MmUKNc7sQ0Sh4rwymQkd4/do0mPE8Of3OpWuvHowcNSokJidowfqhwsJCho8djetOHZqlgoeIUOvm3jSZO5KX33+THheez7Zt22zH8iotWD80e/ZsTINaxHRKtB1FqWoXmdCIRh8PY1u3kzn9jM5BPTlBC9YPDUkaTrROLFBBTJxO6jx4PQ3fHcRDQ1/gin9cE5STE7Rg/czq1avZumM7cZecbTuKUl4XffopNJk3mh/qhgXl5AQtWD8zbNRIatx2GRLmtB1FKZ9wREVQ97k7iR/7CP3uuZPb77mbnJwc27GqhRasH9mxYwcLFy4i/sZLbEdRyudcZ3eg6eLxLMzcTuuO7VmxYoXtSFWmBetHRo8fR/w15+OsGWs7ilJWOGvGUn/UI4Q9cRMXX3k5/376KQ4fPmw7VqVpwfqJ3NxcJk+ZQk295qtSxPVxT06YvvrLgJ6coAXrJ2bMmEHMmW2ITGhkO4pSfiG8fm0aTH+O3BvPo2uvHoxISgq4yQlasH6guLiYYWNGEatDs5T6ExGh1k3uyQnDZk7nnAvOC6jJCVqwfmDhwoUcjHQSe1Y721GU8ktHJids734qp3fuxIwZMwJicoIWrB8YkjScmDsvR+S4q5grFdLE6aTOA9fR8L2XGDhsEJddcxV79+61Heu4rBasiEwTkT0iklrG8+eKSJaIrPXcnvN1Rm9LSUlhfVoacX3/ZjuKUgHhyOSEtfUjSGx/OvPmzbMdqUy2j2CnAyca9PmNMaaj5zbIB5l86pXRSdS8pQ+OiHDbUZQKGEcnJ4x7lBvvu5vbBtzll5MTrBasMeZrYL/NDDbt2bOHTz7+hPhbetuOolRAcnVvT9Ml41mUvYPWHdrx3Xff2Y70J7aPYMuju4isE5EFItLWdpjqNGHiROIv7UFYnXjbUZQKWM4asdRPeoSwp27h71f35f+eetJvJif4e8H+ADQ3xnQAxgGzy9pQRAaISLKIJKenp/sqX6Xl5+czbuJr1NChWUpVi7je59B00ThmrPmaDt3OJC0tzXYk/y5YY0y2MSbHc38+EC4idcvYdrIxposxpku9ev6/CsDMmTMJb92cqMQE21GUChrh9WrRYNqz5N50Ht3+1pPhI0danZzg1wUrIg3FM3ZJRLrizhvwF400xjAkaQQxevSqVLUTEWrd2JsmnyXxyodv0a//rdayhFnbMyAi7wPnAnVFZAfwPBAOYIyZBFwL3CcihUAe0M8EwujiE/jqq6/Ym5dDk3PPsB1FqaAV2fwk6rxyPyvuedVaBqsFa4y54QTPjwfG+yiOzwxJGkHsnZcjDr/+B4RSAc8RG8PBA/aGb+k73Me2bNnCd999R/y1F9iOolTQc7qiOZiTa23/WrA+NmLMaOJv/DuO6CjbUZQKeo7YaPJzD1q7boEWrA9lZmbyzjvvENf/MttRlAoJEuYkLDKC3Fw7R7FasD40+Y03qHHemYSfVOpIM6WUF0S4Yjlw4ICVfWvB+khhYSEjxo3BdbcOzVLKl8JdMVqwwe7TTz+FRnWJ6dDKdhSlQkqYFmzwG5w0nJi7dL0tpXzNGRutBRvMVq1axW//3UnNv3e3HUWpkON0acEGtZdHjaTG7ZcjTqftKEqFHj2CDV7bt29n8aLFxN9wse0oSoUmLdjgNWrcWOKvvQBnjVjbUZQKScYVpQUbjHJzc3lj6lRq3qEfbillS3FsFNnZ2Vb2rQXrRdOnT8d11ulENj/JdhSlQpbDFU3GAS3YoFJcXMyw0UnE3KkTC5SyyRGrBRt0FixYQF5MOLHdTrcdRamQ5nDFkKUFG1zcEwuuwLMgg1LKEmdsNFnZ+iFX0Fi/fj1pGzcSd3kv21GUCnkOVzQH9Ag2eAwbNZIat/TGERFuO4pSIc/hiiEnx86qBlqw1WzPnj3M/nQ28bf0sR1FKYX7FEGupWVjtGCr2bjXJhB/eS/CasfZjqKUwn2KwNa6XFqw1ejQoUOMnziRGnfqxAKl/IXDFUOeniIIfDNnziSibQuiWjW3HUUp5eGIiaIg/zCFhYW+37fP9xikjDHu5bjv0okFSvkTESEiNtrKB11WC1ZEponIHhFJLeN5EZGxIrJFRNaLSGdfZyyv5cuXsy//IK6/nWE7ilLqGLbW5bJ9BDsduOQ4z/cGWnpuA4CJPshUKUOTRhB75+U6sUApPxQea2fZGKsFa4z5Gth/nE36Am8Zt5VAvIj43ZVTNm/ezMpVq4i/5gLbUZRSpXBaWpfL9hHsiTQGtpf4eofnMb8yfHQScTddgiM60nYUpVQpbC0b4+8FW24iMkBEkkUkOT093Wf7zcjI4N333iPu1kt9tk+lVMU4LK1q4O8FuxNoWuLrJp7H/sIYM9kY08UY06VevXo+CQcw+Y03qHlBN8Ib1vHZPpVSFaRHsKWaC9zqGU1wFpBljNllO9QRhYWFjBw3BpcOzVLKr5lYO8vGhPl8jyWIyPvAuUBdEdkBPA+EAxhjJgHzgT7AFuAgcLudpKX7+OOPoUk9Ytq3tB1FKXUcxtIRrNWCNcbccILnDXC/j+JU2JBRI4i5W49elfJ3JjaKLAvrcvn7KQK/tXLlSrbt3kXNi8+yHUUpdQJOV4yVZWO0YCtpaNIIXLdfhjidtqMopU7A4YomIzvL9/v1+R6DwLZt2/hi6VLi+11sO4pSqhwcsdFk6SiCwDBq3Fji/nEhzhqxtqMopcrB6YohWwvW/+Xk5DBl2jTibtdrvioVKBw6DjYwTJ8+ndju7Yho1tB2FKVUOTlio8nJ0YL1a8XFxQwbM0onFigVYJyuGCvLxmjBVsC8efPId0USc2Zb21GUUhXgcEVzMNQuuB1ohiQNJ1qv+apUwHHERpN3INf3+/X5HgPUunXr2LBpE3GX9bQdRSlVQY7ICADy8/N9u1+f7i2ADRs1khr9L8UREW47ilKqEiIsXHRbC7Ycdu/ezZzZc4i/qbftKEqpSrKxLpcWbDmMn/ga8Vf0Iqx2TdtRlFKVFKZHsP7n0KFDTJg0iRp39bUdRSlVBWEWJhtowZ7Ae++9R2S7U4g6temJN1ZK+S2HhZVltWCPwxjD0FEjiblTp8UqFehEj2D9y7Jly9hfeAhXr862oyilqsrCsjFasMcxJGk4sTqxQKmgYGNdLi3YMmzatInVq78n/qrzbUdRSlWDYi1Y/zF8zCjibr4ER3Sk7ShKqWogrmgyfbyqgRZsKfbv38/7779P3K2X2o6ilKomDlc0+328LpcWbCkmTZ5MzQu7Ed6gju0oSqlq4oyN8fnKslYLVkQuEZFNIrJFRJ4o5fnbRCRdRNZ6bnd5O1NBQQGjxo+lxt06sUCpYOJw+X5drhMWrIg8KCK1qnvHIuIEJgC9gTbADSLSppRNPzDGdPTcplR3jmN9/PHHSPOGRJ9+qrd3pZTyIUdstM/X5SrPEWwD4HsR+dBzxFldY5a6AluMMVuNMYeBmYDVw0ZjDIOThhOjKxYoFXScrhhy/K1gjTHPAC2BqcBtwGYRGSoip1Rx342B7SW+3uF57FjXiMh6EZklIl6dr7py5Up2pO+h5oVdvbkbpZQFDpfv1+Uq1zlYY4wBdntuhUAtYJaIvOrFbACfAQnGmPbAEmBGWRuKyAARSRaR5PT09ErtbGjSCFx3XIY4nZVLq5TyW47YGHJ9vC5Xec7BPiwia4BXgf8A7Ywx9wFnANdUYd87gZJHpE08jx1ljNlnjDlyCfIpnn2Wyhgz2RjTxRjTpV69ehUO8/vvv7Psiy+Iv/7iCv9dpZT/c7qiycvx7bIxYeXYpjZwtTHm95IPGmOKReSyKuz7e6CliLTAXaz9gBtLbiAiJxljdnm+vALYWIX9HdeocWOJu+4inK4Yb+1CKWWRIzaaQzm5GGN8Nv39hAVrjHn+OM9VuvCMMYUi8gCwCHAC04wxaSIyCEg2xswFHhKRK3CfltiP+xxwtcvJyWHqm2/SZP4ob3x7pZQfkDAnYZERHDx4kNjYWJ/sszxHsF5jjJkPzD/msedK3H8SeNLbOaZNm4br7PZENG3o7V0ppSw6si6Xrwo25GdyFRUV8cqYUcTq0Cylgl64j9flCvmC3bJlC/v37SOmY6LtKEopL/P1ulwhX7CtWrWiU+fOZLy7wHYUpZSXOWN9u6pByBesiDBx1BgyRs+kMNO3g5CVUr7l8PGyMSFfsAAdOnTg6iv6kjn2Q9tRlFJeJHoEa8erg4eQ/dFS8n/9r+0oSilv0SNYOxo2bMi/H32MzKFv2o6ilPIS4/LtsjFasCU8+sgjkPorOd+tsx1FKeUFxbFRZPvwottasCVER0cz+pXhZA6ahikqsh1HKVXNHLExZPhw2Rgt2GNcf/31NI2NI3PWF7ajKKWqmcMVrQVrk4jw+uixZAx/h6LcPNtxlFLVyL1sjBasVd26dePic88j47VZtqMopaqRe+FD/ZDLulHDXiVrxjwO76zcxbuVUv7H4YomOzvLd/vz2Z4CTLNmzbj/vvvIHFbmIgpKqQDjXjbGd6saaMEex7NPPkX+dykc/HGT7ShKqWrg9PGyMVqwx+FyuRg+eAiZg6biXpZMKRXIHK5oDmrB+o/bbruNOvmGrM++sR1FKVVFTlcMeXqKwH84nU4mjhpD5svTKT502HYcpVQVSHQkBfmHKSws9Mn+tGDL4bzzzuOsjp3JmDLbdhSlVBWICJGuGJ990KUFW07jRySR8fonFKRn2I6ilKqCcB+uaqAFW04tW7bk9lv7kzniXdtRlFJVEB7ru3W5tGAr4KXnnid34QryNv5qO4pSqpLCfHhNWC3YCqhVqxaDnn1Oh20pFcAcoXKKQEQuEZFNIrJFRJ4o5flIEfnA8/wqEUmwEPNP/nnffcT8kcWBpattR1FKVYLDh8vGWCtYEXECE4DeQBvgBhFpc8xmdwIZxphTgVHAK75N+Vfh4eFMGDmKzMHTMAW+GeqhlKpGPlzVwOYRbFdgizFmqzHmMDAT6HvMNn2BIxcDmAVcICLiw4yl6tOnD20TTiHj7fm2oyilKioUjmCBxsD2El/v8DxW6jbGmEIgC6jjk3THISJMTBpNxhhd6lupQFMcGxpHsNVKRAaISLKIJKene/8Sg+3atePaq64iY/T7Xt+XUqr6mNgosny0LpfNgt0JNC3xdRPPY6VuIyJhQBywr7RvZoyZbIzpYozpUq9ePS/E/atXXhrCgY+Xk//LDp/sTylVdU6X79blslmw3wMtRaSFiEQA/YC5x2wzF+jvuX8tsMz40fioBg0a8OTj/0fm0Om2oyilysnhiibDRxfdtlawnnOqDwCLgI3Ah8aYNBEZJCJXeDabCtQRkS3Av4C/DOWy7V8DByI/bSPnP7rUt1KBwBEbTZaPzsGG+WQvZTDGzAfmH/PYcyXuHwL+4etcFREVFcXYV0dw74tPE7tgNOJ02o6klDoOpyuGbP2QK3Bce+21JMTVIfPDJbajKKVOwKFTZQOLiDBp9FgyRrxLUc5B23GUUsfhiI0mJ0cLNqCceeaZXHLBhbrUt1J+zumK8dmyMVqw1WjUsFfJems+h3fusR1FKVUGhyuag3rB7cDTpEkTHnrgATJf1qW+lfJXjtho8g7k+mZfPtlLCHnq//7N4ZVp5K7ZaDuKUqoUjsgIAPLz872/L6/vIcS4XC5GDBlK5otT9JqxSvmpCB9dE1YL1gv69+9PveIwsuZ+ZTuKUqoUES7fLBujBesFDoeD10ePJfPlGRTnef+fIUqpignTI9jA1qtXL87p0pWMN2bbjqKUOoav1uXSgvWisa+OIGPyJxTs2W87ilKqBEesHsEGvFNPPZU7b7+DzOHv2I6ilCpBfLRsjBaslw169jkOLllNXtpW21GUUkDxocPk/7Gfw4cPe31fWrBeFh8fz+DnX9ClvpXyA4X7MtnV72m6NzuVq6++2uv704L1gXvvuYfYvQfIXrLSdhSlQtahn39nx+WPctfFlzPnw1lER0d7fZ9asD4QFhbGa0mjyXzpTYoPF9iOo1TIOfBlMjv/8SRjBw1l2OAhOBy+qT4tWB/p3bs3HU5tReZb82xHUSqkZEz/nP2PjGHBJ7Ppf+utPt231RUNQs1rSaPpdm4val5zAWG1atiOo1RQM4VF7H3xDSL+k8aa71Zwyimn+DyDHsH6UNu2bbn+2mvJGPWe7ShKBbWiA7nsvn0Qp2zLZu3K1VbKFbRgfW7YoMEc+PRLDm3ZbjuKUkHp8Pbd7Lzq/7isZXuWzV9IfHy8tSxasD5Wr149nv73E2QOftN2FKWCTu6ajey48nGeHfAAUye+Tnh4uNU8WrAWPPLwwzi37OTA1z/YjqJU0Mic8yV77niJmVPe5F8DByIitiNpwdoQGRnJuOEjyRw8DVNUZDuOUgHNGMO+pPc49PLbfPvFci699FLbkY6yUrAiUltElojIZs+ftcrYrkhE1npuc32d05uuvvpqTqndgMyZi21HUSpgFR86zJ4HR1D76zTWrU6mffv2tiP9ia0j2CeAL4wxLYEvPF+XJs8Y09Fzu8J38bxPRJg0agwZI9+lyEfrAykVTAr3ZrLr+qfoFhbPqq++oWHDhrYj/YWtgu0LHFkZcAZwpaUcVp1xxhn0ufjvZIz/yHYUpQLKoZ9+Y8fl/+LuS/ry6cwPfTLttTJsFWwDY8wuz/3dQIMytosSkWQRWSkiV/ommm8lvfwKWe8u5PD23bajKBUQDixP5r/XP8W4wcN4+aXBPpv2Whlem8klIkuB0o7Zny75hTHGiEhZl5lqbozZKSInA8tEJMUY80sZ+xsADABo1qxZFZL7VuPGjXnkoYeY8vIM6r/2b9txlPJr+9+cS864WSycPZdzzjnHdpwTEhuX0BORTcC5xphdInIS8KUxJvEEf2c68LkxZtaJvn+XLl1McnJy9YT1gdzcXBISWxI34XFiz2xjO45SfscUFrH3hclErfyJpZ/P5+STT7aSQ0TWGGO6lHd7W8fWc4H+nvv9gTnHbiAitUQk0nO/LnAOsMFnCX0oNjaWkUOHkTloCqa42HYcpfxKUXYuu28bxKk7cvhxxSpr5VoZtgp2GHCRiGwGLvR8jYh0EZEpnm1OA5JFZB2wHBhmjAnKggW4+eabaSCRZM7+0nYUpfyGe9rr41yR2IFl8xcSFxdnO1KFWDlF4G2BdorgiG+++YZLb7iO5l9NwhEdZTuOUlblJm/gj3te5qUnn+HhBx/0i5lZgXKKQJWiZ8+e9DqrOxmvf2o7ilJWZX66nD13DuGDqdMZ+NBDflGulaHXg/UzY18dQbsuZ1Cz38WEN6xjO45SPnVk2mvRrOX8Z9ly2rVrZztSlegRrJ85+eSTueeuu8gY/rbtKEr5VPGhw+x5YDh1v93IutXJAV+uoAXrl55/+hkOLVvDwZTNtqMo5RMF6Rnsuu5JukfWYeWXX9OgQVlzjwKLFqwfiouLY8gLL5I1aJou9a2C3qGffmPnFY8yoM9VfPL+B3477bUytGD91IC776ZGZh7Zi1bYjqKU12Qv+57/Xv8U44e8wtBBLwXsh1ll0YL1U2FhYUwcNYbMwbrUtwpO+6fNJevxcSya8xm33Hyz7TheoQXrxy6++GI6t25Dxpuf2Y6iVLUxhUWkPz2R8Pe+YM13Kzn77LNtR/IaLVg/N2HkKDInfETh/izbUZSqMve01xdp+d9cflyxihYtWtiO5FVasH7utNNO48brrycjSZf6VoHt8Lbd7LzyMa48rTNfzFsQcNNeK0MLNgAMffElcuZ+w6HN22xHUapScr/fwI4rH+P5fw5k8oSJhIWFxhwnLdgAULduXZ598ikyX5pmO4pSFZb5yTL23DWED998i4EPPWQ7jk9pwQaIhx98kPDf/uDAV2tsR1GqXIwx7Bv+NodHvM93y7+kd+/etiP5nBZsgIiIiHAv9T1oKqZQl/pW/q04L589979K3RU/s3bV95x++um2I1mhBRtArrzySk6t34iM9xfajqJUmQr27GfX9U9xdnS9oJr2WhlasAFERHh99Fgykt6jKFuX+lb+J2/jr+y44lHuvewaPn5vJlFRoX1dYy3YANOpUyf69rmUjHEf2I6i1J9kf7GaXf2eZtKwEQx+4cWgm/ZaGaExViLIDB/yMq1Ob0uNm3sT2fwk23FUiDPGkDFtLrmvfcLiuZ/TvXt325H8hh7BBqBGjRrx6MCBZA6dbjuKCnGmoJC9T08kYuZyflixUsv1GFqwAerfjz1O8drN5K5OtR1FhaiirBx29X+BVrvz+HHFKhISEmxH8jtasAEqJiaGUcNeJfPFqbrUt/K5/N93sfPKx7n69K4s/Xw+NWvWtB3JL2nBBrAbbriBk8JjyPxkme0oKoTkrk5l51WP88IDj/D6+AkhM+21MrRgA5jD4eD10WPJfOVtig8esh1HhYDMj79gz90v89H0t3n4wQdtx/F7VgpWRP4hImkiUiwiZa4xLiKXiMgmEdkiIk/4MmOgOPvsszmvR08yJn1sO4oKYqa4mL3D3+bwyJms+PIrLrnkEtuRAoKtI9hU4Grg67I2EBEnMAHoDbQBbhCRNr6JF1jGvDKcjGmfUbBrr+0oKgi5p70Op/7KzaxbnUzbtm1tRwoYVgrWGLPRGLPpBJt1BbYYY7YaYw4DM4G+3k8XeBISErhvwAAyX9WlvlX1Ktizn13XPck5sfVZsfwr6tevbztSQPHnc7CNge0lvt7heaxUIjJARJJFJDk9Pd3r4fzNc089Td5XP3JwvS71rapH3oat7Lj8X9x3xT+Y9e77IT/ttTK8VrAislREUku5eeUo1Bgz2RjTxRjTpV69et7YhV+rWbMmwwa9ROaLU3Spb1Vl2UtXseuGZ3j91SReev4FnfZaSV4bX2GMubCK32In0LTE1008j6ky3HXnnYwYN4bs+f8h7tIetuOoAGSMIWPKbHInzWbJZ/M466yzbEcKaP58iuB7oKWItBCRCKAfMNdyJr/mdDrdS30PnU5x/mHbcVSAMQWF7H1yApEffc2PK1dpuVYDW8O0rhKRHUB3YJ6ILPI83khE5gMYYwqBB4BFwEbgQ2NMmo28geTCCy+kS9t2ZLypv4tU+RVl5bC7/4skph/mh+9W0rx5c9uRgoIE4/m6Ll26mOTkZNsxrNm0aRNnnNOd5ssnElYn3nYc5efyf/svf9w2iH6XXMa4pFE6M+s4RGSNMabMsfvH8udTBKqSEhMTueXGm8gYqUt9q+PLXeWe9jro4ceYOHaclms104INUkNeeJGcz7/lwPJkinLzbMdRfijzo6XsGfAys956lwfvv992nKCkv66CVO3atZk0fjwvvPIymzdtJqZ+HaJbJWASmxDeqhlRiQlEntoUR1SE7ajKx0xxMftHvEPxnG9Z+dXXtGmjEyS9Rc/BhoCioiK2bt1Kamoq61NSSE5bT2pqKju3/oarcUOiWidgWjYmIjGBqNbNiWzRGAnX373BqDjvEOkDR9Fo3yEWzfmMUBwzXhUVPQerBRvCDh8+zObNm93Fm5rK9ynrSEtLI33HTmq2aEpkYnOKWzYmsnUCUYkJRDRrgDidtmOrSir4Yx9/3DmYC9p05K0p03RmViVowaIFW1V5eXn89NNPpKamsi41heSU9WzcsIHM9L3Endqc8FbNMInuAo5KbE544/o608fP5aVtZfcdg3jk7nt54dnn9L9XJWnBogXrLQcOHGDDhg2kpaXxY8p61qSmsCktjdycHOISTyasVVNMq6ZEeYo3rH5tfSP7gezFK0l/bAxTxr9Gv379bMcJaBUtWD3RpsqtRo0adOvWjW7duv3p8YyMDNLS0khNTeWHlHX8sGw+P6emUWiKqZnYAkdiM6RVE6IS3acawmrr8iK+YIwhY/KnHHxjDl/MW/CX/27K+/QIVnmFMYY9e/YcLd41qev5MSWFLRs24oyKwJXYAklshqPEEa+zRqzt2EHDFBSS/sxEXGt/Zenn83VmVjXRI1jlF0SEBg0a0KBBA84///yjjxtj2LlzJ6mpqaSlpfF9ylrWzfyKLZt+JjK+JrGtW2BaNiEssRlRrROIatkUR7R+GFMRhZkH2HPvMNq76vLpf1bogoQW6RGs8gvFxcX89ttvpKamkuoZ0ZCSlsa2zVuIPak+0a2aY1o1Ibx1c6JaNSfylCY4InUM77Hyf/svu/u/yE2X9mXsyCScOuqjWumHXGjBBpPCwkK2bNlCWloa61NS3EPJNqSx67dt1GjWiKjE5phWTd2TJ1onEJnQCAkLzVLJWZnCnvuGMeyFQdx/3z9txwlKWrBowYaC/Px8fv75Z/dQspQUklPXsyEtjb27dhN3clMiEptT3KqJZyhZAhFNGyCO4J0ZnvnhEjKGTOfj997noosush0naGnBogUbyg4ePMjGjRv/PIY3LY3sjEziWiYQntgM4xnREJnYnPCT6gb0UDJTXMy+V9+Cz1ew5PP5Ou3Vy/RDLhXSYmJiOOOMMzjjjDP+9HhWVhYbNmwgNTWVH1NTWDN1CT9v2MChvEPUTGyBs1VTJLHp0eINqxvv98VbnHeIPQ8n0TSzgAWrvtdpr35Ij2BVSNu7dy9paWmkpaWxJmUdP6am8nNaGsbhoGbrFkjLpjgSmxGV2NxdvPE1bEcGPNNe7xjMBW078vbUN4mMjLQdKSToKQK0YFXVGGPYvXv30TG836esY11qKr9s/IlwVwyxrRKQxKY4E5u5RzS0aobTFeOzfHmpv7D7jpd49N5/8tzTz/j9kXYw0YJFC1Z5hzGG7du3k5qaSkpKCsmpKaxPS+G3TZuJrluLmMQEz4iGpu4RDac0xRFdvUeWWYtXsO+xsUx9bRLXXXddtX5vdWJasGjBKt8qKiri119/PTqGd3XqOlJSU9n5y6+4GjcgKjEB07IJEYnNiWrdnIgWjXFEhFdoH8YYMl7/lINT5rJg9hy6du3qpZ9GHY8WLFqwyj8UFBT85XKQGzak8ce2HdRMcA8hMy2bENHaM5SsecNSLwdpCgrZ+/REXOt/Y+nn82nWrJmFn0aBFiygBav826FDh/jpp59IS0tjreeqZBvS0tj/xx7iT23uGUrmvhxkRNMG7H9uMh3jGvDJ+x9Qo4Z/fMgWqrRg0YJVgSknJ+foGN4jl4P8eeNGbrjueka9OlynvfqBgChYEfkH8AJwGtDVGFNqG4rIb8ABoAgoLO8PpgWrlPKGQJlokApcDbxejm3PM8bs9XIepZSqdlYK1hizEdDxe0qpoObvV78wwGIRWSMiA2yHUUqpivDaEayILAUalvLU08aYOeX8Nj2MMTtFpD6wRER+MsZ8Xcb+BgADAB3GopTyC14rWGPMhdXwPXZ6/twjIp8CXYFSC9YYMxmYDO4Puaq6b6WUqiq/PUUgIrEiUuPIfeBi3B+OKaVUQLBSsCJylYjsALoD80RkkefxRiIy37NZA+BbEVkHrAbmGWMW2sirlFKVYWsUwafAp6U8/l+gj+f+VqCDj6MppVS18dtTBEopFei0YJVSyku0YJVSykuC8mIvIpIO/F6Bv1IXsD0dVzNoBs3g/xmaG2PKvfhZUBZsRYlIckUu4KAZNINm0AzloacIlFLKS7RglVLKS7Rg3SbbDoBmOEIzuGkGt4DOoOdglVLKS/QIVimlvCQkC1ZEaovIEhHZ7PmzVhnbFYnIWs9tbjXt+xIR2SQiW0TkiVKejxSRDzzPrxKRhOrYbwUz3CYi6SV+9ruqef/TRGSPiJR68R5xG+vJt15EOlfn/suZ4VwRySrxGjznhQxNRWS5iGwQkTQRebiUbbz6WpQzg1dfCxGJEpHVIrLOk+HFUrbx6vuinBkq/r4wxoTcDXgVeMJz/wnglTK2y6nm/TqBX4CTgQhgHdDmmG3+CUzy3O8HfGAhw23AeC++/r2AzkBqGc/3ARYAApwFrLKQ4Vzgcy//f3gS0Nlzvwbwcyn/Lbz6WpQzg1dfC8/P5vLcDwdWAWcds4233xflyVDh90VIHsECfYEZnvszgCt9tN+uwBZjzFZjzGFgpidLWdlmARdI9a6tU54MXmXcF03ff5xN+gJvGbeVQLyInOTjDF5njNlljPnBc/8AsBFofMxmXn0typnBqzw/W47ny3DP7dgPh7z6vihnhgoL1YJtYIzZ5bm/G/elEUsTJSLJIrJSRK6shv02BraX+HoHf/2f+eg2xphCIAuoUw37rkgGgGs8/ySdJSJNq3H/5VHejN7W3fNPxgUi0tabO/L8k7cT7iOnknz2WhwnA3j5tRARp4isBfYAS4wxZb4OXnpflCcDVPB9EbQFKyJLRSS1lNufjtaM+9i/rN9UzY17BseNwGgROcXbuf3EZ0CCMaY9sIT/HTmEkh9w//fvAIwDZntrRyLiAj4GBhpjsr21nypk8PprYYwpMsZ0BJoAXUXk9OreRzVkqPD7ImgL1hhzoTHm9FJuc4A/jvwzy/PnnjK+x5Ela7YCX+L+7V4VO4GSv/WaeB4rdRsRCQPigH1V3G+FMhhj9hlj8j1fTgHOqMb9l0d5XievMsZkH/knozFmPhAuInWrez8iEo672N41xnxSyiZefy1OlMFXr4Xn+2cCy4FLjnnK2++LE2aozPsiaAv2BOYC/T33+wN/WYRRRGqJSKTnfl3gHGBDFff7PdBSRFqISATuk/XHjk4ome1aYJnnKLu6nDDDMef4rsB9Xs6X5gK3ej5BPwvIKnFKxydEpOGRc3wi0hX3e6Va39Ce7z8V2GiMSSpjM6++FuXJ4O3XQkTqiUi85340cBHw0zGbefV9UZ4MlXpfVOcncYFyw33u5gtgM7AUqO15vAswxXP/bCAF96fsKcCd1bTvPrg/qf0F9wq7AIOAKzz3o4CPgC24l8o52Qs//4kyvAykeX725UDrat7/+8AuoAD3OcU7gXuBez3PCzDBky8F6OKF1+BEGR4o8RqsBM72QoYeuE9PrQfWem59fPlalDODV18LoD3woydDKvCcr98X5cxQ4feFzuRSSikvCdVTBEop5XVasEop5SVasEop5SVasEop5SVasEop5SVasEop5SVasEop5SVasCrkiMiZngt2RIlIrOf6nz6f+66Cn040UCFJRAbjnh0UDewwxrxsOZIKQlqwKiR5rsPwPXAI99TPIsuRVBDSUwQqVNUBXLiv4h9lOYsKUnoEq0KSuNdYmwm0AE4yxjxgOZIKQmG2AyjlayJyK1BgjHlPRJzAdyJyvjFmme1sKrjoEaxSSnmJnoNVSikv0YJVSikv0YJVSikv0YJVSikv0YJVSikv0YJVSikv0YJVSikv0YJVSikv+X9KkiOZ1I3nbQAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# (1.5, 0.5)を中心とし、外接円半径2、-0.4 radだけ回転した正七角形\n", + "# A heptagon with center (1, 0.5), circumradius 2, rotated 0.05 rad\n", + "poly0 = Polygon(array([\n", + " [f(tau/7*i-0.4) for f in (np.cos, np.sin)]\n", + " for i in range(7)\n", + "])*2+(1.5, 0.5))\n", + "\n", + "# 描画 plot\n", + "fig, ax = poly0.plot()\n", + "# 図のサイズを設定 resize figure\n", + "fig.set_size_inches(5, 5)\n", + "# タイトルを設定\n", + "ax.set_title('7-gon')\n", + "# x軸のラベルを設定\n", + "ax.set_xlabel('x')\n", + "# y軸のラベルを設定\n", + "ax.set_ylabel('y')\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "81c98984-dbab-4111-8769-673c40c047e9", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# x+y>=1 との共通部分を取る\n", + "# Take the intersection with x+y>=1\n", + "## P=(1, 0) n=(1, 1)\n", + "poly1 = poly0.clipLine((1, 0), (1, 1))\n", + "fig, ax = poly1.plot()\n", + "fig.set_size_inches(5, 5)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "daad4079-a225-4665-84fc-cd84be429871", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAUsAAAEvCAYAAADM0uPSAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8rg+JYAAAACXBIWXMAAAsTAAALEwEAmpwYAAAt60lEQVR4nO3dfZzM5f7H8ddn9v4m1s3K2ihFpyIUuU+60cE5h2503FSoDt3oRql0UCklKYVSUslNwhJCq7W3bqPo1C9SHXXqFMuuXcti7djd6/eH6Zw9WmvYmblmZj/Px2Mfzc5+d663ybx9v/Od63uJMQallFKVc9gOoJRSgUDLUiml3KBlqZRSbtCyVEopN2hZKqWUG7QslVLKDaG2A5xM3bp1zXnnnWc7hlIqyGzdunWfMSb+dH/Pb8vyvPPOY8uWLbZjKKWCjIj8fCa/p4fhSinlBi1LpZRyg5alUkq5QctSKaXcoGWplFJu0LJUSik3aFkqpZQbtCyVUsoNWpZKKeUGLUulAkB+fj66qoFdWpZK+aGcnBySkpK44+4hNLywCfUS6vPH3n8hLy/PdrRqS8tSKT+wf/9+li1bxr0PPsD5zS/m3KZNGP7uVFYnOIiaNoKLd3zI9gbRXNyqBevXr7cdt1ry2wtpKBXMCgsLWb9+PSnpaXySmc5P3/+TWm2a4+jYnOgX76XppU2Q0JD/+Z26T93FwY7N6XHzDTz6wEOM+fsoQkJCTjKC8jSp6vsgItIQmAOcDRhghjFmygnbCDAF6AkcAQYbY76o7HHbtGlj9KpDKlgUFRWxceNGUjPSSc5I47uvt1Or5R+Ol2OnlkS1+gOO8DC3Hsu5O5d9D07iD9G1WPz+B9SvX9/L6YOLiGw1xrQ53d/zxJ5lCTDCGPOFiJwFbBWRVGPMN+W26QE0dX21A950/VepoOR0Ovnss89ITT9ejl9v/YKal1xASPvmRA6/iQvbjMERFXFGjx3eIJ6EBc/z0+T5XHJZKxbOmUu3bt08/CdQJ6pyWRpjsoFs1+1CEdkBJALly7I3MMcc343dJCJxIpLg+l2lAl5JSQn/+Mc/SE9PZ0V6Kl9s/ozYxucQ1vFSIv52PU3efoSQ2GiPjSehIdR59DYi2jfnpkG3cs+gO3lh3HOEhuo7a97i0WdWRM4DLgM2n/CjROCXct//6rpPy1IFpLKyMr7++msyMjJYmZ7KpvXriWpQj/AOlxLevzPnT7mX0LizvJ4jtnMrIj95jdnDXyG9S2eWLUiiUaNGXh+3OvJYWYpILPAhMNwYc/AMH2MoMBTQ/+HKrxhj+O6778jIyGBF+mo2ZK0ltNZZRHZsSdifWnHu8wMJi69lJVto3TjqzxlLzvQlXNqmNXPefofevXtbyRLMqnyCB0BEwoCVQIox5pUKfv4WkGWMme/6/juga2WH4XqCR9n2r3/96/ieY1oqa7IyKQ0NIaZTS0I7NiemY0vCG5z2Mi5ed3jrDnLvf4kBvW9i8ksvExFxZu+LBrMzPcHjibPhAswG8o0xw0+yzZ+A+zl+NrwdMNUY07ayx9WyVL7266+/kpmZSXJGGhkZGRwpPspZnVrh6NCM2E6tCG9Un+N/3f1bSUEheY9NpXb2QT5auIimTZvajuRXbJ4N7wTcDnwtIl+67hsFNAIwxkwHkjlelDs5/tGhOzwwrlJVkpOTQ1ZWFqvSU0nLzCQ/L4+aHVsiHZoTN/gpzm7SMCDK8UShcWdRb8YoCmav5PIO7Zk+ZSq33nqr7VgBzyOH4d6ge5bK0/bv38+aNWtIyUgnJSON7F92Uat9C6RDM2I6tSLy4vMQR3BNaiva9gM5973IX666lrdee53oaM+dkQ9U1g7DvUXLUlVVpbNkOrYkqoJZMsGo9NAR8ka/SdT2f7M8aTHNmze3Hckqm4fhSvmFoqIiPv30U1anp/1+lsyTt9P0NGbJBJOQ2GjqTRlBQVIqHbp24eXxExg6ZEhAvsVgk+5ZqoD12yyZtIwMPk5P/d9ZMp1aENPmkjOeJROsjv7z3+TeN5EuzVsx5+13qVGjhu1IPqeH4SroVTpLpuOlxLRr7tFZMsGqrKiYvGffwbH+a5YtXESbNqfdGwFND8NV0DnlLJnJ9xJay/uzZIKNIyqC+BeGcWDFWrr2+CPPjBrDI8OH62H5KeiepfIb5WfJrMxIZX3WWkLjYo/PkunQnJiOLazNkglWxT9nkztsIpcnNmbBrDnUqVPHdiSv0z1LFZBOOkumS3MSn7jZL2fJBJOIcxNosGQi30yYw8WtWrBk/kI6d+5sO5Zf0rJUPrVr1y4yMzP5OD31d7Nk6j34YsDMkgkmjvAwvbCwG/QwXHlVZbNkYju1JCJAZ8kEq98uLHxhVBwfzpsflBcW1sNw5Rf279/P2rVr+SQ97b+zZNpdinRsTsy0EVwQhLNkgoleWPjktCxVlZxslox0aE7MSdaSUf5NQkOo++htHOpwKTcPuo27B93B+GfHERZW/T7QX54ehqvT8tssmdT0dD7OSK3SWjLK/5XsKyB3+Kucc5SgubCwfihdecX/zJLJSOXrLTpLproxZWXsf2sJB99axuwZb3PDDTfYjlQlWpbKI8rPklmZkcbWTZt1lowC/nth4f69bmTKy5MC9sLCWpbqjFQ0SyYyoR4RHS8lvFMLYtpdqrNk1H+UFBSS9/hr1N59IGAvLKxnw5VbKp0lY3ktGeX/QuPOot5bf6dg9sfV7sLCWpbVwG+zZD5OSyVLZ8moKhIRag3+M5FtLmbYfaNYlZ7KW69NIyYmxnY0r9LD8CBU4SyZji1xdGweUGvJKP9XeriIvFFvBNSFhfUwvBr7bZbMJxlppGZklJsl0yyg15JR/i8kJqraXFhY9ywDUKWzZIJ0LRnl/47u/IXc+16kSzP/vrCwng0PYocOHWLdunWszkhnVUba/86S6VR91pJR/q+sqJj8ce8i6/7Pby8srIfhQaTSWTJjbqdpqwtxRITbjqnU7ziiIqg7/j4OrFxH1x5/ZOzfRzPi4YeD4rBc9yz9wG+zZNJdH+fRWTIqGDj/vYfcYRO5rMF5fnVhYT0MDyClpaV88cUXOktGBb0y5zHyX5zDsZUb+PCDBVx55ZW2I+lhuD/73SyZDRuIrB9/fJZMv06c/+o9OktGBSVHeBh1n7yLgx0vpWefGxlx/4M8OWp0QF5YWPcsveB3s2Qy1xBa6ywiO7QgrOOlupaMqpaOZe8j98GXuTAyjsXvf0BCQoKVHLpnaZnOklGqcmEJdV0XFl5As8svY8HsOVx//fW2Y7lNy/IM/TZLJjk9lfQTZsnoWjJKVUxCQqg74lYOdWhOn8G3M3TgYF4Y91xAXFjYI4fhIjIT+DOQY4z53XwnEekKfAT8y3XXEmPMs5U9pr8dhp84SyZv3z7iOrVCOjQjtlMrXUtGqdNUklfAvuGvklgES+cv5Nxzz/XJuLYPw2cBrwNzKtlmnTHmzx4az+sKCgpYs2YNn6SnsToznd3//vW/s2Ref4QmlzTWWTJKVUFonTjOnv00uW8tocUVbfz+wsIeKUtjzFoROc8Tj2VLpbNkJtyja8ko5QXicFD73j5EtG3GoPuH0T89zW8vLOzL9yw7iMhXwG7gUWPMdh+O/TvlZ8kkZ6Tx7dfbdJaMUpbEtL6YyE+msuyxqaxp35blSYv97sLCHvvokGvPcuVJ3rOsAZQZYw6JSE9gijHmd8+EiAwFhgI0atSo9c8//+yRbOUtXbaM8ZMn8fWWL6hx8fmEdrjUNUvmYhxRkR4fTynlPmMMBXM+Zv+kD7x2YWHrM3gqK8sKtv0JaGOM2XeybbxxgsfpdHJ2o4bUePouzrr2Cp0lo5SfKtr+Izn3TuDPXa72+IWFz7QsfXKGQkTqi+tUsYi0dY2b54uxy1u2bBnhTc4hrvdVWpRK+bGoZudzzqoppB/Kpnmby9m2bZvtSJ55z1JE5gNdgboi8ivwNBAGYIyZDvQB7hWREqAI6GcsTB16adpUIm/v7uthlVJnICQminqTH6FgURrtu3Rm5zffUr9+fWt5PHU2vP8pfv46xz9aZM327dv59rvvaNz97zZjKKVOU9wt11E0cyW7du2yWpbV5oOCU998gxr9/4iE6aQlpQJNSEwUhw4dspqhWpTloUOHmPfBPGoM0ENwpQKRI1bL0ifmzZtHbPsWhCfqxSyUCkQSHall6W3GGCa98RrRemJHqYBlYiIpLCy0miHoy3LTpk3kHjpI7JWX2Y6ilDpDRvcsve+Vaa8Rc1sPveiFUgHMREdoWXrTvn37+Hjlx9T8azfbUZRSVRETyYHCg1YjBHVZvvPuu8R176jr2ygV4ByxURQc0vcsvaKsrIwp098g5vYetqMoparIER1FwUEtS69ISUmhpGY0Ua0utB1FKVVFITFRHNQ9S++YNO01Im/vrks9KBUEHDGRFOoJHs/76aef+HTjRuJu6Go7ilLKAxwxURzSPUvPm/bWdGrefK1ezFepIOGIieLw4cN2M1gd3QuKi4t5Z+ZMztITO0oFDUdMFIcL9TDco5YsWUL4HxoR2aSh7ShKKQ8JiYmi6JDuWXrUy2+8RpTuVSoVVBwxkRzVw3DP+frrr/nnDz9Q4/r2tqMopTxIIiM4VuyktLTUWoagKsupb07jrP7X6wV+lQoyIkJEbLTVkzxBU5aFhYXMX7CAmnqBX6WCUlhMtNXLtAVNWX722WdIdCSOs3TVRqWCUZjlpSWCpiyvvvpqbuz+J/YOfpayI0dtx1FKeVhItJalRzgcDmbNeJvrmjZn753jKCsqth1JKeVBthctC5qyhOOF+f7MWVyZeAF7h4ynrNhpO5JSykMcMXavlh5UZQkQEhLCwrnzaFsrgZx7JlDmPGY7klLKA0T3LD0vNDSUpQuSuCyyNjnDJmKOldiOpJSqItuLlgVlWQKEhYXxUdJimptoch6ahCmx92FWpVTV2V60LGjLEiAiIoKPlyyj6WEhd8RkjMVP/yulqsb2omVBXZYAkZGRpHy0gnNzj5I78nVMWZntSEqpM2F50TKPlKWIzBSRHBHZdpKfi4hMFZGdIvJ/InK5J8Z1V3R0NGkrk2nw8372jX4TY4wvh1dKeYDtRcs8tWc5C6hsnmEPoKnrayjwpofGdVtsbCyZq1KI/zabfU/P0MJUKsDYXrTMI2VpjFkL5FeySW9gjjluExAnIgmeGPt01KhRgzUpqdT6x7/Ie26mFqZSAcT2omW+es8yEfil3Pe/uu7zubi4ONalphO7cQd5E+doYSoVIGwvWuZXJ3hEZKiIbBGRLbm5uV4bp3bt2qxPyyAy7R/kT57vtXGUUp5je9EyX5XlLqD8Og/nuO77H8aYGcaYNsaYNvHx8V4NFB8fz4b0TEKXbyT/9SSvjqWUqjpHtN1Fy3xVlsuBga6z4u2BA8aYbB+NfVL169dnY+YaSMok/60ltuMopSrhiLW7aJlHLikuIvOBrkBdEfkVeBoIAzDGTAeSgZ7ATuAIcIcnxvWEBg0asDFzDe26dCY/PJTad/SyHUkpVQHbi5Z5pCyNMf1P8XMDDPPEWN7QsGFDNmRk0f6qKykICyPuNl3wTCl/Y3vRMl2sxqVx48ZsyMiiQ9cuEBZKXN9utiMppcopv2hZSEiIz8f3q7PhtjVp0oR1aRkcemkeBUsybMdRSpUjIoTH2DvJo2V5gosuuoi1qWkcfG4WB1astR1HKVVOeGyMtcu06WF4BZo1a0ZWymquur4bhIVSs3tH25GUUthdtEzL8iRatmxJevIqrunRHQkNocZ17WxHUqras7lomR6GV6J169asXrGSvBFTKVyz1XYcpao9m4uWaVmeQrt27UheuozcByZxaP2XtuMoVa3ZXLRMy9INnTt3ZsXiD8m570UOb67wkp1KKR+QmChrJ3i0LN3UtWtXli5IYu/Q8Rze8o3tOEpVS0b3LAPDddddR9Kc99lz13Mc+ep723GUqnZsLlqmZXmaevTowQfvvkf2oGco2vaD7ThKVSs2Fy3TsjwDvXr1YtYb08ke+DRHv/3Jdhylqg+Li5ZpWZ6hPn368NYrU9h965Mc3fnLqX9BKVVljpgo9lsqS/1QehUMGDCAYqeTh/qNpEHSC0Scb2WlDKWqDUdMFAcK91gZW8uyiu4YPJhjx47xaL/RNFj0AhHn+nwdNqWqDZuLlmlZesDQIUModjoZ4yrM8HPOth1JqaBkc9EyLUsPeWDYMJxOJ8/2G03iogmEJdS1HUmpoGNz0TI9weNBIx5+mJF338/uvqM4tjfPdhylgo5DL6QRPEaNHMnwQXeR3X8MJfsKbMdRKqg4YqM4YmkdHi1LLxj75FPcc8sAsvuPpiTfzscclApGNhct07L0kvHPjmPwn24ke8AYSgrsLQyvVDCxuWiZlqWXiAiTXpxI/2u6s+e2pyg9aG9VOqWCRflFy3xNy9KLRITXX53MTe2vYs/AsZQeOmI7klIB7bdFy2yc5NGy9DIR4a3Xp9GzxRXsHfwsZUeO2o6kVEALj43RsgxWDoeDWTPe5rqmzdlz5zjKioptR1IqYNlatEzL0kccDgfvz5xFl8QL2DtkPGXFTtuRlApIthYt07L0oZCQEBbOnUfbWgnk3DOBMucx25GUCji2Fi3TsvSx0NBQli5IolVELXLufwlzrMR2JKUCiiMm0so6PB4pSxHpLiLfichOEXmigp8PFpFcEfnS9fU3T4wbqMLCwli+6EOalUaSM/wVTInvPwahVMAK1MNwEQkBpgE9gEuA/iJySQWbLjTGtHJ9vVPVcQNdREQEyUs/oukhyB0xGWPhc2NKBaRYO+vweGLPsi2w0xjzozHGCSwAenvgcYNeZGQkKR+t4Nzco+Q+MQ1TVmY7klJ+z9aiZZ4oy0Sg/LoKv7ruO9HNIvJ/IrJYRBp6YNygEB0dTdrKZBr8lE/u6DcxxtiOpJRfs7Voma9O8KwAzjPGtABSgdkVbSQiQ0Vki4hsyc3N9VE0+2JjY8lclUK9b7PZ9/QMLUylKhMTScHBAz4f1hNluQsov6d4juu+/zDG5Bljfvsk9jtA64oeyBgzwxjTxhjTJj4+3gPRAkeNGjVYk5JK3Bc/kvfcTC1MpU7CERNFgYULAHuiLD8HmopIYxEJB/oBy8tvICLlF6bpBezwwLhBJy4ujvVpGcRu3EH+S3Ntx1HKLx1ftCwAD8ONMSXA/UAKx0swyRizXUSeFZFers0eFJHtIvIV8CAwuKrjBqvatWuzPi2DiNQvyJs833YcpfyOrUXLPLIGjzEmGUg+4b6nyt3+O/B3T4xVHcTHx7MhPZP2V11JfmgIte//q+1ISvkNW4uW6QweP1W/fn02ZGRhFmaQP2Op7ThK+Q1bi5ZpWfqxxMRENmauoXT2KvbPWmE7jlJ+wdaiZVqWfq5Ro0ZsyMiiePoyCt5fZTuOUtY5YiKtLFqm64YHgMaNG7MhI4sOXbtAWChxfbvZjqSUNSGx0VYWLdOyDBBNmjRhXVoGna65GsJCiLvpGtuRlLLC1qJlWpYB5KKLLmJtahqdr70GCQul5l+62I6klM+VX7QsJCTEZ+Pqe5YBplmzZmSlrKbgqbc58MlG23GU8jlbi5ZpWQagli1bkp68iv1PvMHBtM224yjlc+Ex0VqWyj2tW7dm9YqV5I2YSuGarbbjKOVTobFaluo0tGvXjuSly8h94GUObfjKdhylfCbUwmcttSwDXOfOnVmxeAk5907g8OZttuMo5RM2Fi3TsgwCXbt2Zcn8hewdOp7DW76xHUcpr7OxaJmWZZDo1q0bSXPeZ89dz3Hkq+9tx1HKu/QwXFVFjx49+ODd98ge9AxF236wHUcp77GwaJmWZZDp1asXs96YTvbApzn67U+24yjlFTYWLdMZPEGoT58+OJ1O7r51OA0Wjieyia4Pp4KLjUXLtCyD1IABAyh2Onmo30gaJL1AxPkVLbipVICysGiZlmUQu2PwYI4dO8aj/UaTuHgC4Y3q246klEc4YqIo2OXbs+FalkFu6JAhFDudjOk7igaLJxCeWM92JKWqzBEdyYHCPT4dU8uyGnhg2DCcTifP9h1F4qIJhCXUtR1JqSoJiY3moJ4NV94w4uGHGXn3/ezuO4pjOfm24yhVJTYWLdOyrEZGjRzJ8EF3kd1vNCX7CmzHUeqMOWKidAaP8q6xTz7F3X36k91/NCX5B23HUeqMOKKjOHxY9yyVl70w7jkG/+lGsgeMoaTA90uKKlVVNhYt07KshkSESS9OpP813dlz+9OUFvp+PROlqsLGomValtWUiPD6q5O5qV0X9tw+ltLDRbYjKeU2G4uWaVlWYyLCW69Po2eLK9g76BnKjhy1HUkpt/y2aFlJSYnPxtSyrOYcDgezZrzNtU2asefOcZQVFduOpNQp/bZo2WEf7l16pCxFpLuIfCciO0XkiQp+HiEiC10/3ywi53liXOUZDoeDee/N5srEC9g7ZDxlxU7bkZQ6pTAfL1pW5bIUkRBgGtADuAToLyKXnLDZXcB+Y0wT4FXgxaqOqzwrJCSEpLnzaFsrgZx7JlDmPGY7klKVCvPxomWe2LNsC+w0xvxojHECC4DeJ2zTG5jtur0YuFZExANjKw8KDQ1l6YIkWkXUIuf+lzDHfPd+kFKny9eLlnmiLBOBX8p9/6vrvgq3McaUAAeAOh4YW3lYWFgYyxd9SLPSSHKGv4IpLbUdSakKhfh4Fo9fneARkaEiskVEtuTm5tqOU21FRESQvPQjmhQach+ZrIWp/JIjxrdXS/dEWe4Cyl+K+xzXfRVuIyKhQE0g78QHMsbMMMa0Mca0iY+P90A0daYiIyNZvXwl5+YeJfeJaZiyMtuRlPpfAXgY/jnQVEQai0g40A9YfsI2y4FBrtt9gAxjjPHA2MqLoqOjSVuZTIOf8tk3Zjr6v0z5lRjfLi1R5bJ0vQd5P5AC7ACSjDHbReRZEenl2uxdoI6I7AQeAX738SLln2JjY8lclUL8jt3sG/u2FqbyGybGt3uWHrn4rzEmGUg+4b6nyt0+CtziibGU79WoUYM1Kal0vKYrec+/R53Rd6AfZlC2meiI6nuCR/mvuLg41qdlELN+O/kvv287jlIQE8mBQt9dZlDLUrmtdu3abEjPJDxlC3mT59uOo6o5R0wUBYd0z1L5qfj4eDZmZBHy0Qbypy2yHUdVY8cXLdOyVH6sfv36bMzIwixIJ3/GUttxVDXl60XLtCzVGUlMTGRj5hpKZ69i/6wVtuOoasgRE8lB3bNUgaBRo0ZsyMiiePoyCuatsh1HVTOOQPzokKq+GjduzIaMLNpf1QVCQ4nr2812JFVN+HrRMi1LVWVNmjRhfXoGna7pioSHUvPGq21HUtWArxct07JUHnHRRRexNjWdztdeA6Eh1PxLF9uRVJBzxET5dNEyLUvlMc2aNSMrZTVXXd8NwsOo+ccOtiOpIBYSG0WRvmepAlXLli1JT17FNT26I6Eh1Li2re1IKkhJZAQlzmOUlJQQGur9KtOz4crjWrduzeoVK8l7ZAqFa7bajqOClK8XLdOyVF7Rrl07kpcuI/eBlzm04SvbcVSQ8uWiZVqWyms6d+7MisVLyLl3Aoc3b7MdRwWhMB9+1lLLUnlV165dWTJ/IXuHjufw1h2246ggE6p7liqYdOvWjYWz57LnznEc+ep723FUkDDGUAY+u6allqXyiZ49ezLvnZlkD3qGom0/2I6jApwpKWXfyNepHxbF5Zdf7pMxtSyVz/Tu3ZtZb0wne+DTHP32J9txVIAqKypm79DxNMk5yqastdSoUcMn42pZKp/q06cPb70yhd23PsnRnb+c+heUKqdkfyHZA8ZwZZ2GpK1MJjY21mdja1kqnxswYABTX5hIdr/RFP944qrJSlXMuTuX3Tc/zoDO15E0dx7h4eE+HV/LUllxx+DBvPzMc+zuNxrnv/fYjqP83NHvf2bXjY8x8q57mTrpFRwO31eXTndU1gwdMoRip5MxfUfRYPEEwhPr2Y6k/NDhz79h79Dnef2lVxg0cKC1HFqWyqoHhg3D6XTybN9RJC6aQFhCXduRlB85uHoTeY9NZdHceXTv3t1qFi1LZd2Ihx+m2OlkomsPM6xebduRlB8oWLCagxPfJ+3jVbRta/+CLFqWyi+MGjkSp7OYKf1G02DRC4TWibMdSVlijGH/60mUzE9j89p1XHjhhbYjAVqWyo+MffIpjhYXM6P/GBIWjCe0tm8+P6f8hyktZd/TMzhr6w9kfbqZhIQE25H+Q8+GK7/ywrjnGNzzBvbc+iSlB3x3YVdlX1mxk5xhL9Hox3w+W7ver4oStCyVnxERJr04kb5dryf7tqcoLfTdsgHKntKDh9lz+1iuCK9F1ierqVmzpu1Iv1OlshSR2iKSKiL/dP231km2KxWRL11fy6sypgp+IsK0yVO4se2V7Ll9LKWHi2xHUl50LCef3bf8nRtaXMGyhYuIjIy0HalCVd2zfAJIN8Y0BdJd31ekyBjTyvXVq4pjqmpARJgx7Q16triCvYOfoazoqO1IyguKf9zFrhsf48G/3sqMaW8SEhJiO9JJVbUsewOzXbdnAzdU8fGU+g+Hw8GsGW9z7QXN2HPnc5QVFduOpDzoyFffs6vPSF4a9TRjn3wKEbEdqVJVLcuzjTHZrtt7gLNPsl2kiGwRkU0ickMVx1TViMPhYN57s7mywfnsHTKesmKn7UjKAwrXbGXPwLHMm/EuQ4cMsR3HLacsSxFJE5FtFXz1Lr+dMcYA5iQPc64xpg0wAJgsIhecZKyhrlLdkpube7p/FhWkQkJCSJo7j7a1Esi5ZwJlzmO2I6kqKFiSQd5Dr/LJsuX06hU478rJ8Y47w18W+Q7oaozJFpEEIMsY84dT/M4sYKUxZnFl27Vp08Zs2bLljLOp4ON0OvlLn5v4sqyQs6c9joTpx4QDTf5bSyieuZLMT1bTrFkzKxlEZKtr5+20VPUwfDkwyHV7EPBRBcFqiUiE63ZdoBPwTRXHVdVQeHg4yxd9SLPSSHKGv4IpLbUdSbnJlJWxb9y7hCZlsXXjJmtFWRVVLcsJQDcR+Sdwnet7RKSNiLzj2uZiYIuIfAVkAhOMMVqW6oxERESQvPQjmhQach+ZrIUZAMyxEnKGv0K9L39m64ZPadiwoe1IZ6RKh+HepIfhqjJHjhzhmp7d+TnxLOJfvB+xcH1DdWqlh4vIufsFWkbX4aOkxURHR9uOZO0wXCkroqOjSVuZTIOf8tk3Zjr++o9+dVaSV0B231Fcf94lrFq23C+Ksiq0LFXAio2NJXNVCvE7drNv7NtamH7E+e897Lrxcf7W4wbmvjuT0NDAPxmnZakCWo0aNViTkkrc1h/Ie/49LUw/ULT9R3bd9DjPPPQoLz4/3u8/bO4uLUsV8OLi4liflkHM+u3kv/y+7TjV2qGNX7F7wBjefnUqDz3wgO04HqVlqYJC7dq12ZCeSXjKFvImz7cdp1o6sHIdufdOZEXSYvr27Ws7jscF/hsJSrnEx8ezMSOLdlddSX5YKLWH3WI7UrWxf9ZKDr++mLWpabRq1cp2HK/QslRBpX79+scLs0vn44U59EbbkYKaMYa8l9/HsfJTtmzYSOPGjW1H8hotSxV0EhMT2Zi5hvZXXcn+8FBqDf6L7UhByZSUkvv3adT5LpuMDZ9Sr15wL2WsZamCUqNGjdiQkUX7q66kICyUuFt72I4UVMqKiskZNpE/lEWSnLWW2NhY25G8Tk/wqKDVuHFjNmRkcXhyEgVJabbjBI2S/YVkD3iSK+s0JG1lcrUoStCyVEGuSZMmrE/P4NDEuRxYmmk7TsBz7spl982P07/TNSTNnUd4eLjtSD6jZamC3kUXXcSa1WkcGPceB1ausx0nYB39/md23fQYI++6l9deeRVHNZuPr+9ZqmqhefPmZKWs5qrru0FYKDX/2MF2pIBy+PNv2DPkeaa9/AqDBg60HccKLUtVbbRs2ZL05FVc06M7EhpCjWvb2o4UEA6u3sS+R6ew+P0P6N69u+041lSv/WhV7bVu3ZrVK1aS98gUCtdstR3H7xXMT6HgiTdIT/6kWhclaFmqaqhdu3YkL13GvgcncWjDV7bj+CVjDPlTF+B8bTGb166jbVvdC9eyVNVS586dWb7oQ3Lue5HDn22zHcevmNJS9j05najkz/ni081ceOGFtiP5BS1LVW117dqVJR8sYO+Q8RzeusN2HL9QVuwkZ9hLNPoxn8/XbSAhIcF2JL+hZamqtW7durFw9lz23DmOI199bzuOVaUHD7Pn9rFcEV6LrE9WU7NmTduR/IqWpar2evbsybx3ZpI96BmKtv1gO44Vx/bmsbvPE9zQ4gqWLVxEZGSk7Uh+R8tSKaB37968N+1Nsgc+zdFvf7Idx6eKf9zFrhsf58G+tzFj2puEhITYjuSX9HOWSrnccsstFDud3HvrwzRYOJ7IJoG5ZOvpOPLld+y5cxyTxo1n6JAhtuP4NS1Lpcq57dZbOXbsGA/2G0li0gtEnJ9oO5LXFGZtIefBScx79z169+5tO47f07JU6gR3DB6M85iTx/qNJnHxBMIb1bcdyeMKlmRQ8OxMUj5aQadOnWzHCQhalkpV4O4hQ3E6jzGm7ygaLJ5AeGLwXNg2f/qHFL/3MRszs2jWrJntOAFDy1Kpk3hg2DCcTifP9h1F4qIJhCXUtR2pSkxZGXnPvUf4mq/YuHETDRsG/3uynqRlqVQlRjz8MMXOYia69jDD6tW2HemMmGMl5IyYTMKug6Rv+JTatQPzz2GTfnRIqVMYNfIJHhp4J9n9RlOSV2A7zmkrPVzEnjue5dKjYWxIz9SiPENalkq54ZmnnubuPv3J7j+GkvyDtuO4rSSvgOy+o7j+vEtYtWw50dHRtiMFrCqVpYjcIiLbRaRMRNpUsl13EflORHaKyBNVGVMpW14Y9xyDe97AnlufpPTAIdtxTsn57z3suuFx/tbjBua+O5PQUH3XrSqqume5DbgJWHuyDUQkBJgG9AAuAfqLyCVVHFcpnxMRJr04kb5dryf7tqcoLTxsO9JJFW3/kV03Pc4zwx/lxefHIyK2IwW8KpWlMWaHMea7U2zWFthpjPnRGOMEFgD6CVgVkESEaZOncGPbzuy5fSylh4tsR/qdQxu/YveAMbz96lQeeuAB23GChi/es0wEfin3/a+u+35HRIaKyBYR2ZKbm+uDaEqdPhFhxrQ36dniCvYOfoayoqO2I/3HgZXryL13IiuSFtO3b1/bcYLKKctSRNJEZFsFXx7fOzTGzDDGtDHGtImPj/f0wyvlMQ6Hg1kz3ubaC5qx587nKDvqtB2J/bNWUDj2XdasTuXqq6+2HSfonLIsjTHXGWOaV/D1kZtj7ALKf/r1HNd9SgU0h8PBvPdmc2WD89k75HnKiu0UpjGGfRPnYGYm8/n6DVx22WVWcgQ7XxyGfw40FZHGIhIO9AOW+2BcpbwuJCSEpLnzaBuXwN57JlDmPObT8U1JKbmPT6XW+h1s3biJ888/36fjVydV/ejQjSLyK9AB+FhEUlz3NxCRZABjTAlwP5AC7ACSjDHbqxZbKf8RGhrKkvkLuSyiFjn3v4QpKfXJuGVFR9k7dDxNc51sylpLvXrBM3/dH4kxxnaGCrVp08Zs2bLFdgyl3FZcXEyPG3rxTWQJ9aaOQLx4Ed2S/YXsveNZujZtxgfvzSY8PNxrYwUbEdlqjDnp58JPRmfwKOUhERERfLxkGU0KDbkjpmDKyrwyjnNXLrtvfpz+na8lae48LUof0bJUyoOioqJYvXwl5+YUkTvydY8X5tHvf2bXTY8x8q57ee2VV3E49CXsK/pMK+Vh0dHRpK1MpsFP+ewbMx1PvdV1+PNv2PXXUbz2/Is88dhjHnlM5T4tS6W8IDY2lsxVKcTv2M2+sW9XuTAPrP6UvXeNY/Gc9xk0cKCHUqrToWWplJfUqFGDNSmpxG39gbzn3zvjwiyYn8KBkW+QnvwJ3bt393BK5S4tS6W8KC4ujnWp6cSs307ey++f1u8aY8ifugDna4vZvG49bdu29VJK5Q4tS6W8rE6dOmxIzyQiZQt5kz9w63dMaSn7xkwnKvlzvvh0MxdeeKGXU6pT0bJUygfi4+PZmJFFyEcbyZ+2qNJty4462XvfRBr+mMfn6zaQkJDgo5SqMlqWSvlI/fr12ZiRhVmQTv6MpRVuU3rwMHtuf5orwmuxJiWVmjVr+jilOhktS6V8KDExkY2ZayiZlcz+WSv+52fH9uaxu88T3NCyLR8lLSYyMtJSSlURLUulfKxRo0ZszFxD8fRlFMxbBUDxD7+y68bHebDvbcyY9iYhXpwqqc6MLsqhlAWNGzdmQ0YWHbp2oXhXDocXpDJp3HiGDhliO5o6Cd2zVMqSJk2asC4tg/qbdvL+W+9oUfo53bNUyqKLLrqILzd9ZjuGcoPuWSqllBu0LJVSyg1alkop5QYtS6WUcoOWpVJKuUHLUiml3KBlqZRSbtCyVEopN2hZKqWUG7QslVLKDVqWSinlBvHUMp2eJiK5wM8+GKousM8H47hL81RO81RO81SuLhBjjIk/3V/027L0FRHZYoxpYzvHbzRP5TRP5TRP5aqSRw/DlVLKDVqWSinlBi1LmGE7wAk0T+U0T+U0T+XOOE+1f89SKaXcoXuWSinlhmpRliLSXUS+E5GdIvJEBT+PEJGFrp9vFpHzLOcZLCK5IvKl6+tvXs4zU0RyRGTbSX4uIjLVlff/RORyy3m6isiBcs/PU17O01BEMkXkGxHZLiIPVbCNz54jN/P47DkSkUgR+UxEvnLleaaCbXz2GnMzz+m/xowxQf0FhAA/AOcD4cBXwCUnbHMfMN11ux+w0HKewcDrPnyOugCXA9tO8vOewCpAgPbAZst5ugIrffj8JACXu26fBXxfwf8znz1Hbubx2XPk+jPHum6HAZuB9ids48vXmDt5Tvs1Vh32LNsCO40xPxpjnMACoPcJ2/QGZrtuLwauFRGxmMenjDFrgfxKNukNzDHHbQLiRCTBYh6fMsZkG2O+cN0uBHYAiSds5rPnyM08PuP6Mx9yfRvm+jrxZIjPXmNu5jlt1aEsE4Ffyn3/K7//i/WfbYwxJcABoI7FPAA3uw7nFotIQy9lcZe7mX2pg+swa5WINPPVoK7Dx8s4vrdSnpXnqJI84MPnSERCRORLIAdINcac9PnxwWvMnTxwmq+x6lCWgWgFcJ4xpgWQyn//RVbHfQGca4xpCbwGLPPFoCISC3wIDDfGHPTFmFXI49PnyBhTaoxpBZwDtBWR5t4czwN5Tvs1Vh3KchdQ/l+Nc1z3VbiNiIQCNYE8W3mMMXnGmGLXt+8Arb2UxV3uPIc+Y4w5+NthljEmGQgTkbreHFNEwjheTPOMMUsq2MSnz9Gp8th4jlxjFQCZQPcTfuTL19gp85zJa6w6lOXnQFMRaSwi4Rx/c3n5CdssBwa5bvcBMozrXWAbeU54r6sXx9+Tsmk5MNB1xrc9cMAYk20rjIjU/+39LhFpy/G/x1574bnGehfYYYx55SSb+ew5ciePL58jEYkXkTjX7SigG/DtCZv57DXmTp4zeY2FejCjXzLGlIjI/UAKx89EzzTGbBeRZ4EtxpjlHP+LN1dEdnL8xEI/y3keFJFeQIkrz2Bv5QEQkfkcP3taV0R+BZ7m+JviGGOmA8kcP9u7EzgC3GE5Tx/gXhEpAYqAfl78xw2gE3A78LXrfTCAUUCjcpl8+Ry5k8eXz1ECMFtEQjheyknGmJW2XmNu5jnt15jO4FFKKTdUh8NwpZSqMi1LpZRyg5alUkq5QctSKaXcoGWplFJu0LJUSik3aFkqpZQbtCyVUsoN/w/4G3XNQIOqlgAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# 更に -x+4y<=6 との共通部分を取る\n", + "# Also take the intersection with -x+4y<=6\n", + "## P=(-6, 0) n=-(-1, 4)\n", + "poly2 = poly1.clipLine((-6, 0), (1, -4))\n", + "fig, ax = poly2.plot()\n", + "fig.set_size_inches(5, 5)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "8b749f43-a34f-4834-8b08-40e1c3bcb610", + "metadata": {}, + "source": [ + "### 多面体 Polyhedron\n", + "例として、立方体といくつかの半空間との共通部分の**断面図**と**等高線図**の描画方法を示します。 \n", + "As an example, I will demonstrate how to plot the **cross section** and\n", + "**contour map** of the intersection of a cube and some half-spaces." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "26cf21b3-2d63-4667-953d-f443f09ac658", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Polyhedron with 8 vertices and 12 edges:\n", + "[[[0 0 0]\n", + " [0 0 1]]\n", + "\n", + " [[0 0 0]\n", + " [1 0 0]]\n", + "\n", + " [[0 0 1]\n", + " [1 0 1]]\n", + "\n", + " [[0 1 1]\n", + " [1 1 1]]\n", + "\n", + " [[1 0 0]\n", + " [1 1 0]]\n", + "\n", + " [[1 0 1]\n", + " [1 1 1]]\n", + "\n", + " [[0 1 0]\n", + " [0 1 1]]\n", + "\n", + " [[1 1 0]\n", + " [1 1 1]]\n", + "\n", + " [[0 0 0]\n", + " [0 1 0]]\n", + "\n", + " [[1 0 0]\n", + " [1 0 1]]\n", + "\n", + " [[0 1 0]\n", + " [1 1 0]]\n", + "\n", + " [[0 0 1]\n", + " [0 1 1]]]" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "cube = Polyhedron([\n", + " (i>>2&1, i>>1&1, i&1) for i in range(8)\n", + "], list({\n", + " (i, j)\n", + " for i in range(8)\n", + " for j in (i^4, i^2, i^1)\n", + " if i < j\n", + "}))\n", + "\n", + "cube" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "ab435fc3-6818-498b-8abd-97a1bb6e0327", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Polyhedron with 10 vertices and 15 edges:\n", + "[[[0. 0. 0. ]\n", + " [0. 0. 1. ]]\n", + "\n", + " [[0. 0. 0. ]\n", + " [1. 0. 0. ]]\n", + "\n", + " [[0. 0. 1. ]\n", + " [0.5 0. 1. ]]\n", + "\n", + " [[1. 0. 0. ]\n", + " [1. 1. 0. ]]\n", + "\n", + " [[0. 1. 0. ]\n", + " [0. 1. 0.5 ]]\n", + "\n", + " [[1. 1. 0. ]\n", + " [1. 1. 0. ]]\n", + "\n", + " [[0. 0. 0. ]\n", + " [0. 1. 0. ]]\n", + "\n", + " [[1. 0. 0. ]\n", + " [1. 0. 0.75 ]]\n", + "\n", + " [[0. 1. 0. ]\n", + " [1. 1. 0. ]]\n", + "\n", + " [[0. 0. 1. ]\n", + " [0. 0.33333333 1. ]]\n", + "\n", + " [[0. 1. 0.5 ]\n", + " [0. 0.33333333 1. ]]\n", + "\n", + " [[0. 0.33333333 1. ]\n", + " [0.5 0. 1. ]]\n", + "\n", + " [[0.5 0. 1. ]\n", + " [1. 0. 0.75 ]]\n", + "\n", + " [[1. 0. 0.75 ]\n", + " [1. 1. 0. ]]\n", + "\n", + " [[1. 1. 0. ]\n", + " [0. 1. 0.5 ]]]" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# 2x+3y+4z<=5 との共通部分\n", + "# Intersection with x+y+z<=2\n", + "## P=(1,1,0), n=-(2,3,4)\n", + "poly3 = cube.clipPlane((1,1,0), (-2,-3,-4))\n", + "poly3" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "d3174a4e-0f45-4088-9c99-1f50e7591e35", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "vertices:\n", + "[[1. 0.5 0. ]\n", + " [1. 0.5 0.375]\n", + " [0. 0.5 0.875]\n", + " [0. 0.5 0. ]]\n", + "\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAUoAAAFNCAYAAABmLCa9AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8rg+JYAAAACXBIWXMAAAsTAAALEwEAmpwYAAAgRUlEQVR4nO3dfZyM9f7H8ddnd7Hub/YGrd1ZsrssEq2blEgSKnLcRKmcHJJUikqnOylHQkqI7f5OUkpbSCXs6fagG6d089uUg06ikJKQ7++P3c5jzx5ca+3sNTP7fj4e83jMXPPda97fx6y3a+a7M5c55xARkcOL8juAiEioU1GKiHhQUYqIeFBRioh4UFGKiHhQUYqIeFBRioh4UFFKuWJmqWa2wsz2mNnnZtb1CGMfM7N9ZvZzoUt0WeaV0KCilPLmGeBDIA64CXjezBKOMP5u51y1QpffyySlhBQVpYQEM7vOzBYW2TbDzO4rxcdIB1oDtznnfnXOLQT+CfQtrceQyKSilFDxFNDdzGoBmFkMMBB44lCDzewVM9t5mMsrh3mMZsAG59zuQts+Lth+OCPN7EczW2tmKtRyKsbvACIAzrl/m1ku0B94EOgObHfOrT3M+HNK8DDVgF1Ftu0Ckg4zfgYwpmBMN+BZM/vOOfd2CR5bwpiOKCWUPA4MLrg+GHiylPf/M1CjyLYawO5DjMU594Fz7gfn3AHn3BLgaeBPpZxJwoCKUkLJIuAEM2sOnEN+MR2SmS0tshpd+LL0MD/2KdDIzKoX2tayYHtxOMCKOVYiiOlr1iSUmNmDQDvyX3Z3CcL+3wPeAm4GegCPAmnOuW2HGNsPeBXYA3QFFgLnOudWlnYuCW06opRQ8zjQgtJ/2f2HgUAWsAO4C+j3R0ma2YVmVvjo8mpgC7ATmAIMU0mWTzqilJBiZinA50A959xPfucRAR1RSggxsyjgWmC+SlJCif48SEKCmVUFtgIbyf/TIJGQoZfeIiIe9NJbRMSDilJExEPYvUcZHx/vUlNT/Y4hIhFm7dq1251zh/wmqbArytTUVNasWeN3DBGJMGa28XD36aW3iIgHFaWIiAcVpYiIBxWliIgHFaWIiAcVpYiIBxWliIgHFaWIiAcVpYiIh4gvyoMHD3Lw4EG/Y4hIGIv4oux30YU0y2rNypUr/Y4iImEq4oty05bNbGudSu9LLqRbr3P4/PPP/Y4kImEm4osSoGa3k0lZMYf1LeuTdWoHhl9xOdu2/c9J90REDqlcFCVAVGxF4i7vR2DlHF7Z+x2NmmTwt7vuYu/evX5HE5EQV26K8g8xdWqScMcIkhZNYcbfl5Cakca8efO04CMih1XuivIPlY5vQN0Hb6Lq9Ku5asqdnNCuDX//+9/9jiUiIajcFuUfqrVvwXEvT+OnIWdy9gUD6NGnN19++aXfsUQkhJT7ogSwqChq9zmdwKps/pkZT6uT23H5VVeyfft2v6OJSAhQURYSFVuRuCsGkLpyDi/t3kSjJhlMnjJFCz4i5ZyK8hBi4mqRMPFy6r8wmenLX6Jhk3Tmz5+PzoEuUj6pKI8gtnEydR+5hSpTRnHFpPG0bN+Wt99+2+9YIlLGVJTFUO2UliQtns7OCzvT4/x+nN23D3l5eX7HEpEyoqIsJouKona/rgRWzeXjtNqc2K4NV4y+mh9//NHvaCISZCrKoxRVuRJxV51PypsP8OKOr0lNT2PKtGn89ttvfkcTkSBRUZZQhYTaJEy6gvrPT2Lashdo2DSD5557Tgs+IhFIRXmMYtMD1H3sVmInjWDEhJtp1aE97777rt+xRKQUqShLSfWOrUhaMp0fz+/IWf360GtAPzZs2OB3LBEpBSrKUmTR0dQecCaB3Ll8kFqNFlkncdWYa9mxY4ff0UTkGAS1KM2su5l9YWZ5ZjbuEPenmNkKM/vQzNaZWc9g5ikrUZVjiRs9iMCbs3n++/8jNT2Ne+69l3379vkdTURKIGhFaWbRwCygB5AJDDKzzCLDbgYWOOdaAQOB2cHK44cKiXVImDyKes9OZPIrz9KwaQYLFy7Ugo9ImAnmEWVbIM85t8E5tw+YD/QuMsYBNQqu1wS+DWIe38Q2SaXeE+OpNHE4w28bR1bHU/jHP/7hdywRKaZgFmUSsKnQ7c0F2wobDww2s83AEuDKIObxXfXTWpO09D6+/1N7zjjvXPoMHMA333zjdywR8eD3Ys4g4DHnXAOgJ/Ckmf1PJjMbbmZrzGxNuJ/rxqKjqTPwLFJzs1ndIJZmrVtxzXVj2blzp9/RROQwglmUW4DkQrcbFGwrbCiwAMA59y4QC8QX3ZFzLts5l+Wcy0pISAhS3LIVVSWWuGsvJPDGLOZ/+xmp6WncN2MG+/fv9zuaiBQRzKJcDaSZWUMzq0j+Yk1OkTH/As4AMLOm5BdleB8yHqUK9eJInHIVifMmMPGFp2iU2YRFixZpwUckhAStKJ1zB4BRwDLgM/JXtz81swlm1qtg2BhgmJl9DDwDDHHltCEqZzai/rw7qDD+Ui69cQxtO3VkzZo1fscSESAmmDt3zi0hf5Gm8LZbC11fD5wSzAzhpvrpWVTr2IqtC17j9HN7claXM5j2t7sIBAJ+RxMpt/xezJFDsJhoal/Qg0BuNu/WjSGz1YmMHXcDu3bt8juaSLmkogxh0VUrEz92MIHXZzJv4zoC6WnMnDVLCz4iZUxFGQYq1I8nYdpoEp8cz4RnHyWtRTNefvllLfiIlBEVZRip3Px46j1zJ3bTRVw89mpO7tKZDz74wO9YIhFPRRlmzIwaZ7Ql+fWZbOnekk49z2LARReyadMm7x8WkRJRUYYpi4mmzkVnE1g1l7fjoGnLE7j+rzeye/duv6OJRBwVZZiLrl6V+OsvJnnZ/TyZ9wEpaY2Z/cADHDhwwO9oIhFDRRkhKiYlkHjvtcQ/fgvjn3qQtBbNWLx4sRZ8REqBijLCVGmRRr0Ff4MbLmDw6Cs4tWsXPvroI79jiYQ1FWUEMjNqdGtP8huz+FfX5nQ8qyuDhlzMli1Fv5NERIpDRRnBrEIMdS45h8CqbHJr7CejRXNuvOVmfv75Z7+jiYQVFWU5EF2jKvHjhpC8bAaPrX+flLTGzM3O5vfff/c7mkhYUFGWIxWTEkm8fyxxj9zEzY89QEbLFrz66qt+xxIJeSrKcqhKy3TqPzeJA2MGMGjUZXTs1pV169b5HUskZKkoyykzo+ZZJ5O8fDbfdMqgQ9fTGXzpEL79NiLP7yZyTFSU5ZxViKHOn3uRuiqbFZV/Jb15M24Zfxu//PKL39FEQoaKUgCIrlmN+JsuJXnpvTy07m1S0o7n4Ycf1oKPCCpKKaJicj0SZ15HnewbGffg/TRp1ZLXX3/d71givlJRyiFVad2E+gvvYv9Vfeh/2VA6d+/GJ5984ncsEV+oKOWwzIyaPU8l+c3ZfNXheNqf3olLhg3lu+++8zuaSJlSUYqnqIoVqPOX8wismssb0btpnNmU2ybczp49e/yOJlImVJRSbDG1qhN/61AaLJ5O9tpVpKQdz6OPPqoFH4l4Kko5apUC9Ul84AZqPXA918++h8yTWrF8+XK/Y4kEjYpSSqxqVib1F01h78he9P3LEM44uwfr16/3O5ZIqVNRyjExM2qd05HkN2fzRZsAbTt15NIRw9m6davf0URKjYpSSkVUpYrEDe9DYOVclrkfaZzZlDsmTuTXX3/1O5rIMVNRSqmKqV2d+NuGkZQzjVnvvU4gvTFPPPEEBw8e9DuaSImpKCUoKjU8jrpzb6TGzDFcO+NummW1ZuXKlX7HEikRFaUEVdU2zTjupansGdaT3pdcyJnnns3nn3/udyyRo6KilKAzM2r17kTKijl81uo4sk7twLCRI9i2bZvf0USKRUUpZSYqtiJxI/oRWDmHxfu+p1GTDCZOmsTevXv9jiZyRCpKKXMxdWqSMOEykl6ayv1vLSWQkca8efO04CMhS0UpvqnUKIm6D95E9XtHc9XUiZzQrg25ubl+xxL5HypK8V3Vds05LmcqP/35TM4dPJDu5/Xiyy+/9DuWyH+oKCUkWFQUtc87nZSVc/mkeSKtTm7HiCtHsX37dr+jiagoJbRExVYkbmR/UlfOIefnzTRqksFdd9+tBR/xlYpSQlJMXC0SJl5O/Rcmc++bOTRsks78+fNxzvkdTcohFaWEtNjGydR95BaqTB3FFZPGc0K7Nrz11lt+x5JyRkUpYaFah5YkLZ7OTxd1oefA/vT803nk5eX5HUvKCRWlhA2LiqJW3zMIrJrLuow6tGzXhitGX82PP/7odzSJcCpKCTtRlSsRd+X5pK6Yw4s7vyE1PY0p06bx22+/+R1NIpSKUsJWTHwtEv42kvoL72Lqshdo2DSD5557Tgs+UupUlBL2YtNSqPfYrVS+63JG3HELrTq059133/U7lkQQFaVEjGqnnkjSkun8eH5HzurXh3P792XDhg1+x5IIoKKUiGJRUdQecCaB3Ll82LA6LbJO4sprr2HHjh1+R5MwpqKUiBRVOZa40YMIvDmbhdvySE1PY9r06ezbt8/vaBKGVJQS0Sok1iFh8ijqLZjI3YsX0LBpBgsXLtSCjxyVoBalmXU3sy/MLM/Mxh1mzAAzW29mn5rZvGDmkfIrNiOVek+Mp9LE4Qy7bRwnndqB999/3+9YEiaCVpRmFg3MAnoAmcAgM8ssMiYNuBE4xTnXDBgdrDwiANVPa02DpfexvV8HzuzTiz4DB/D111/7HUtCXDCPKNsCec65Dc65fcB8oHeRMcOAWc65HQDOue+DmEcEAIuOpvb53QjkZrM6uTLNT2rNNdeNZefOnX5HkxAVzKJMAjYVur25YFth6UC6mb1tZu+ZWfcg5hH5L1FVYom75gICy2fx7LefkZqexn0zZrB//36/o0mI8XsxJwZIAzoDg4AHzaxW0UFmNtzM1pjZGp25T0pbhbpxJEy5isR5E/jbi0/RKLMJixYt0oKP/Ecwi3ILkFzodoOCbYVtBnKcc/udc18DX5JfnP/FOZftnMtyzmUlJCQELbCUb5UzG1Hv6TuocPulXPrXsbTt1JHVq1f7HUtCQDCLcjWQZmYNzawiMBDIKTJmEflHk5hZPPkvxfVRCvFV9c5ZNFg2g629sujS62z6XjCQjRs3+h1LfBS0onTOHQBGAcuAz4AFzrlPzWyCmfUqGLYM+MHM1gMrgOuccz8EK5NIcVl0NLUv6EEgN5v36lUgs9WJjB13A7t27fI7mvggqO9ROueWOOfSnXPHO+cmFmy71TmXU3DdOeeudc5lOudaOOfmBzOPyNGKrlqZ+LGDCbw+k6c3riOQnsbMWbO04FPO+L2YIxIWKtSPJ3HaaBKfup0JCx6jcfNMcnJytOBTTqgoRY5C5WaNqDfvDqJuuYQh14+m/emdWLt2rd+xJMhUlCJHycyo0aUNDV6bybc9TqTz2d0ZcNGFbNq0yfuHJSypKEVKyGKiqXPR2QRys3k7Dpq2PIHr/3ojP/30k9/RpJSpKEWOUXS1KsRffzHJr93Pk3kfEEhPY/YDD3DgwAG/o0kpUVGKlJKKxyWQeO+1xD9+C+Offoi0Fs1YvHixFnwigIpSpJRVaZFGvWcnwrgLGXzNKE7p2oWPPvrI71hyDFSUIkFgZtQ4sx3Jb8xiU9fmnHpWVwYNuZgtW4p+ilfCgYpSJIgsJpo6l5xDam42uTX2k9GiOTfecjO7d+/2O5ocBRWlSBmIrl6V+HFDSF42g8c++weB9DTmZmdrwSdMqChFylDFpEQSZ4wh7pGbuPmxB8ho2YKlS5dqwSfEqShFfFClZTr1n5vE72PP54IrR9CxW1c+/vhjv2PJYagoRXxiZtQ862SSl89mY+cmnHJmFwZfOoRvv/3W72hShIpSxGdWIYY6f+5Fau6DrKj8K+nNm3Hzbbfyyy+/+B1NCqgoRUJEdI2qxN90KclL7+Xhf75DStrxPPTQQ/z+++9+Ryv3VJQiIaZicj0SZ15HnQf/yo0P3U+TE0/gtdde8ztWuaaiFAlRVVplUH/hZPaP7suAEX+hc/dufPLJJ37HKpdUlCIhzMyo2eMUkt+czVenNKZ9l85cMmwo3333nd/RyhUVpUgYiKpYgTpDexNYOYc3YnbTOLMpt024XQs+ZURFKRJGYmpVJ/6WoTRYPJ3sD1YRSG/Mo48+qgWfIFNRioShSoH6JM6+gVpzbuD6B6aTeVIrli9f7nesiKWiFAljVU9qSv0X72bvyF70/csQzji7B+vXr/c7VsRRUYqEOTOj1jkdSX5zNl+0CdC2U0f+fNkwtm7d6ne0iKGiFIkQUZUqEje8D4GVc3mNHTTObMqEO+9kz549fkcLeypKkQgTU7s68bcNI+nlacx+/w1SM9J4/PHHOXjwoN/RwpaKUiRCVUo9jrpzb6TGzLGMuX8qmSe1YsWKFX7HCksqSpEIV7VNJse9NIVfLzuH8/58EWeeezaff/6537HCiopSpBwwM2r1Oo2UFQ/wWasksk7twLCRI9i2bZvf0cKCilKkHImqVJG4EX0JrJzL4v3baNQkg4mTJvHrr7/6HS2kqShFyqGYOjVIuH04SS9N5f63XyU1I42nn35aCz6HoaIUKccqNUqibvZfqX7fNVw9bSIt2maRm5vrd6yQo6IUEaq2a85xOdPYfWk3zh08kO7n9eLLL7/0O1bIUFGKCAAWFUXt804nZeVcPmmeSKuT23HZqCvYvn2739F8p6IUkf8SFVuRuJH9SV01l5f3bKFRkwwmTZ7M3r17/Y7mGxWliBxSTJ2aJNx5OfVfmMx9K18htUk68+fPL5fnIFdRisgRxTZOpu7DN1N16ihG3XU7J7Rrw1tvveV3rDKlohSRYqnWoSXHvXIPuy7qQs+B/en5p/PIy8vzO1aZUFGKSLFZVBS1+55BYNVc1mXUoWW7Noy8+ip++OEHv6MFlYpSRI5aVOVKxF15Pqkr5rDop400zEjn7qlT+e233/yOFhQqShEpsZj4WiRMHEn9hXdxz+svktoknQULFkTcgk+xitLMlptZzyLbsoMTSUTCTWxaCnUfvZUqk0dy+Z23cuLJ7XjnnXf8jlVqintE2RC4wcxuK7QtKwh5RCSMVTv1RJKWTGfHoE507/8nzu3fl6+++srvWMesuEW5EzgDqGtmL5tZzeBFEpFwZlFR1O7flUDuXD5sVIOWbbO48tpr2LFjh9/RSqy4RWnOuQPOuZHAQuAtIDF4sUQk3EVVjiXu6oGkLJ/Nwu15pKanMW36dPbt2+d3tKNW3KKc88cV59xjwBDgtSDkEZEIUyGxDgl3jaLegoncvWQBDZtmsHDhwrBa8ClWUTrn5ha5vdY5d2lwIolIJIrNSKXe4+OpNHE4w24bx0mnduD999/3O1ax6M+DRKRMVT+tNQ2W3sf2fh04s08vzju/P19//bXfsY5IRSkiZc6io6l9fjcCudmsTqlC85NaM3rsGHbu3Ol3tEMKalGaWXcz+8LM8sxs3BHG9TUzZ2b6kyORciSqSizx11xAYPksFnz3Banpadx7330ht+ATtKI0s2hgFtADyAQGmVnmIcZVB64GwuPNChEpdRXqxpFw95UkPnMHk3Ke4fhmTXnxxRdDZsEnmEeUbYE859wG59w+YD7Q+xDj7gAmA+X3W0FFBIDKTRtS78nbqTBhKENvvp62nTqyevVqv2MFtSiTgE2Fbm8u2PYfZtYaSHbOLT7SjsxsuJmtMbM1Og+xSOSr3ukkGrx6H1t7t6FL73Poe8FANm7c6Fse3xZzzCwKuAcY4zXWOZftnMtyzmUlJCQEP5yI+M6io6k9qDuBVXN5r34FMludyJgbrmfXrl1lniWYRbkFSC50u0HBtj9UB5oDK83sG6A9kKMFHREpLLpqZeLHDCbw+kye2fQJgfQ07p85k/3795dZhmAW5WogzcwamllFYCCQ88edzrldzrl451yqcy4VeA/o5ZxbE8RMIhKmKtSPJ2Hq1SQ+dTt3PPc4jZtnkpOTUyYLPkErSufcAWAUsAz4DFjgnPvUzCaYWa9gPa6IRLbKzRpRb94dRN1yCUOuH0370zuxdu3aoD5mTDB37pxbAiwpsu3Ww4ztHMwsIhI5zIwaXdpQ/bTWfDt/GZ3P7k73rmdyz6TJJCcne+/gKOmTOSIStiwmmjqDexLIzeadhCiatjyB624cx08//VSqj6OiFJGwF12tCvHXXUTya/fz1P99QPvOp5Xq/lWUIhIxKh6XQO0bL2Hrd9+V6n5VlCIiHlSUIiIeVJQiIh5UlCIiHlSUIiIeVJQiIh5UlCIiHlSUIiIeVJQiIh5UlCIiHlSUIiIeVJQiIh5UlCIiHlSUIiIeVJQiIh5UlCIiHlSUIiIeVJQiIh5UlCIiHlSUIiIeVJQiIh5UlCIiHlSUIiIeVJQiIh5UlCIiHlSUIiIeVJQiIh5UlCIiHlSUIiIeVJQiIh5UlCIiHlSUIiIeVJQiIh5UlCIiHlSUIiIeVJQiIh5UlCIiHlSUIiIeVJQiIh5UlCIiHlSUIiIeVJQiIh5UlCIiHlSUIiIeglqUZtbdzL4wszwzG3eI+681s/Vmts7MlptZIJh5RERKImhFaWbRwCygB5AJDDKzzCLDPgSynHMnAM8Ddwcrj4hISQXziLItkOec2+Cc2wfMB3oXHuCcW+Gc21Nw8z2gQRDziIiUSDCLMgnYVOj25oJthzMUWBrEPCIiJRLjdwAAMxsMZAGdDnP/cGA4QEpKShkmExEJ7hHlFiC50O0GBdv+i5l1BW4CejnnfjvUjpxz2c65LOdcVkJCQlDCiogcTjCLcjWQZmYNzawiMBDIKTzAzFoBc8kvye+DmEVEpMSCVpTOuQPAKGAZ8BmwwDn3qZlNMLNeBcOmANWA58zsIzPLOczuRER8E9T3KJ1zS4AlRbbdWuh612A+vohIadAnc0REPKgoRUQ8qChFRDyoKEVEPKgoRUQ8qChFRDyoKEVEPKgoRUQ8qChFRDyoKEVEPKgoRUQ8qChFRDyoKEVEPKgoRUQ8qChFRDyoKEVEPKgoRUQ8qChFRDyoKEVEPKgoRUQ8qChFRDyoKEVEPKgoRUQ8qChFRDyoKEVEPKgoRUQ8qChFRDyoKEVEPKgoRUQ8qChFRDyoKEVEPKgoRUQ8qChFRDyoKEVEPKgoRUQ8qChFRDyoKEVEPKgoRUQ8qChFRDyoKEVEPKgoRUQ8qChFRDyoKEVEPKgoRUQ8qChFRDyoKEVEPKgoRUQ8qChFRDwEtSjNrLuZfWFmeWY27hD3VzKzZwvuf9/MUoOZR0SkJIJWlGYWDcwCegCZwCAzyywybCiwwznXGJgOTA5WHhGRkooJ4r7bAnnOuQ0AZjYf6A2sLzSmNzC+4PrzwEwzM+ecK80gB/fs5ffdv5TmLkUkRP3+y6+lvs9gFmUSsKnQ7c1Au8ONcc4dMLNdQBywvfAgMxsODAdISUk5qhAtmjXjmaumHtXPiEh4y2rftlT3F8yiLDXOuWwgGyArK+uojjYfmTWHR2bNCUouESkfgrmYswVILnS7QcG2Q44xsxigJvBDEDOJiBy1YBblaiDNzBqaWUVgIJBTZEwOcEnB9X7Am6X9/qSIyLEK2kvvgvccRwHLgGjgEefcp2Y2AVjjnMsBHgaeNLM84Efyy1REJKQE9T1K59wSYEmRbbcWur4X6B/MDCIix0qfzBER8aCiFBHxoKIUEfGgohQR8aCiFBHxoKIUEfGgohQR8WDh9kEYM9sGbDzKH4unyBdthKlImQdoLqEqUuZSknkEnHMJh7oj7IqyJMxsjXMuy+8cxypS5gGaS6iKlLmU9jz00ltExIOKUkTEQ3kpymy/A5SSSJkHaC6hKlLmUqrzKBfvUYqIHIvyckQpIlJiEVWUkXJ63GLM41ozW29m68xsuZkF/MhZHF5zKTSur5k5MwvZFdfizMXMBhQ8N5+a2byyzlgcxfj9SjGzFWb2YcHvWE8/chaHmT1iZt+b2SeHud/MbEbBXNeZWesSPZBzLiIu5H858FdAI6Ai8DGQWWTMSGBOwfWBwLN+5y7hPE4HqhRcvzwU51HcuRSMqw7kAu8BWX7nPobnJQ34EKhdcDvR79wlnEc2cHnB9UzgG79zH2E+pwGtgU8Oc39PYClgQHvg/ZI8TiQdUf7n9LjOuX3AH6fHLaw38HjB9eeBM8zMyjBjcXjOwzm3wjm3p+Dme+SfjygUFec5AbiD/HO67y3LcEepOHMZBsxyzu0AcM59X8YZi6M483BAjYLrNYFvyzDfUXHO5ZJ/doTD6Q084fK9B9Qys/pH+ziRVJSHOj1u0uHGOOcOAH+cHjeUFGcehQ0l/3/MUOQ5l4KXQsnOucVlGawEivO8pAPpZva2mb1nZt3LLF3xFWce44HBZraZ/DMUXFk20YLiaP89HVJYnK5WDs3MBgNZQCe/s5SEmUUB9wBDfI5SWmLIf/ndmfyj/Fwza+Gc2+lnqBIYBDzmnJtmZieTf16r5s65g34H80skHVFGyulxizMPzKwrcBPQyzn3WxllO1pec6kONAdWmtk35L+HlBOiCzrFeV42AznOuf3Oua+BL8kvzlBSnHkMBRYAOOfeBWLJ/+x0OCrWvycvkVSUkXJ6XM95mFkrYC75JRmK74P94Yhzcc7tcs7FO+dSnXOp5L/f2ss5t8afuEdUnN+vReQfTWJm8eS/FN9QhhmLozjz+BdwBoCZNSW/KLeVacrSkwNcXLD63R7Y5Zz791Hvxe9Vq1JeAetJ/v/iXwE3FWybQP4/Psh/wp8D8oB/AI38zlzCebwBbAU+Krjk+J25pHMpMnYlIbrqXcznxch/K2E98E9goN+ZSziPTOBt8lfEPwK6+Z35CHN5Bvg3sJ/8I/qhwAhgRKHnZFbBXP9Z0t8vfTJHRMRDJL30FhEJChWliIgHFaWIiAcVpYiIBxWliIgHFaWIiAcVpYiIBxWlRBwza1Pw3YOxZla14Lshm/udS8KX/uBcIpKZ3Un+J7EqA5udc5N8jiRhTEUpEangc8yryf+Oyw7Oud99jiRhTC+9JVLFAdXI/4aiWJ+zSJjTEaVEJDPLIf/buxsC9Z1zo3yOJGFMX9wrEcfMLgb2O+fmmVk08I6ZdXHOvel3NglPOqIUEfGg9yhFRDyoKEVEPKgoRUQ8qChFRDyoKEVEPKgoRUQ8qChFRDyoKEVEPPw/q20+tjnHyZwAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# y=0.5の時の断面図\n", + "# Cross section when y=0.5\n", + "## P=(0,0.5,0), n=(0,1,0)\n", + "cs3 = poly3.slicePlane((0, 0.5, 0), (0, 1, 0))\n", + "print('vertices:', cs3, sep='\\n', end='\\n\\n')\n", + "\n", + "# only use coordinate of x and z axis (0, 2)\n", + "fig, ax = Polygon(cs3[:, [0, 2]]).plot()\n", + "fig.set_size_inches(5, 5)\n", + "ax.set_title('y = 0.5')\n", + "ax.set_xlabel('x')\n", + "ax.set_ylabel('z')\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "dfb82844-c7a1-4cbd-a20c-6c92aaeba3c3", + "metadata": {}, + "source": [ + "等高線図は、複数の断面図の合成とみなせます。 \n", + "Contour map can be seen as composition of several cross sections." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "667bd35d-b3bd-4d52-a2de-144990e07377", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# y=0, 0.1, 0.2, ..., 1.0 とする\n", + "# Let y=0, 0.1, 0.2, ..., 1.0\n", + "ys = np.arange(11)/10\n", + "\n", + "# 各層の色\n", + "# Colors for each layer\n", + "colors = [\n", + " # red to yellow: 4\n", + " *('#FF%02X3F'%g for g in 0x3F+191*np.arange(4)//4),\n", + " # yellow to green: 1\n", + " *('#%02XFF3F'%r for r in 0xFF-191*np.arange(1)//1),\n", + " # green to cyan: 1\n", + " *('#3FFF%02X'%b for b in 0x3F+191*np.arange(1)//1),\n", + " # cyan to blue: 4\n", + " *('#3F%02XFF'%g for g in 0xFF-191*np.arange(4)//4),\n", + "][::-1] # reverse order\n", + "\n", + "# plot\n", + "fig, ax = contourMap(poly3, ys, colors)\n", + "fig.set_size_inches(6, 6)\n", + "\n", + "# 0.1刻みにする\n", + "# set tick interval to 0.1\n", + "ax.xaxis.set_major_locator(plticker.MultipleLocator(base=0.1))\n", + "ax.yaxis.set_major_locator(plticker.MultipleLocator(base=0.1))\n", + "\n", + "# グリッドを表示\n", + "# show grid\n", + "ax.grid()\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "5dfbf5df-68ca-415b-b9a3-5667403904b1", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# 更に 4x-y-z>=1 と 2x-y>=0.4 との共通部分を取る\n", + "# Also take the intersection with 4x-y-z>=1 and 2x-y>=0.4\n", + "poly4 = poly3.clipPlane((0, 0, -1), (4, -1, -1))\n", + "poly4 = poly4.clipPlane((0.2, 0, 0), (2, -1, 0))\n", + "\n", + "fig, ax = contourMap(poly4, ys, colors)\n", + "fig.set_size_inches(6, 6)\n", + "\n", + "# 0.1刻みにする\n", + "# set tick interval to 0.1\n", + "ax.xaxis.set_major_locator(plticker.MultipleLocator(base=0.1))\n", + "ax.yaxis.set_major_locator(plticker.MultipleLocator(base=0.1))\n", + "\n", + "# グリッドを表示\n", + "# show grid\n", + "ax.grid()\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a5222815-2553-46e7-a846-fb6d3c91d56c", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "id": "fb96d7a1-070a-4003-83f0-fb484d66603c", + "metadata": {}, + "source": [ + "## LICENSE" + ] + }, + { + "cell_type": "raw", + "id": "38626361-2823-4fd2-909e-200da839b233", + "metadata": {}, + "source": [ + "Copyright (c) 2022 sup39[サポミク]\n", + "\n", + "Permission is hereby granted, free of charge, to any person\n", + "obtaining a copy of this software and associated documentation\n", + "files (the \"Software\"), to deal in the Software without\n", + "restriction, including without limitation the rights to use,\n", + "copy, modify, merge, publish, distribute, sublicense, and/or sell\n", + "copies of the Software, and to permit persons to whom the\n", + "Software is furnished to do so, subject to the following\n", + "conditions:\n", + "\n", + "The above copyright notice and this permission notice shall be\n", + "included in all copies or substantial portions of the Software.\n", + "\n", + "THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND,\n", + "EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES\n", + "OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND\n", + "NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT\n", + "HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,\n", + "WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING\n", + "FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR\n", + "OTHER DEALINGS IN THE SOFTWARE." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "71e144f3-6bff-4901-81b2-eb54c66576cc", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.9.1" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +}