Upload ring_dataset.ipynb

ring_dataset.ipynb

@@ -0,0 +1,367 @@
+{
+  "nbformat": 4,
+  "nbformat_minor": 0,
+  "metadata": {
+    "colab": {
+      "provenance": [],
+      "authorship_tag": "ABX9TyOqoPlJxEzXB/rGffrk47H3",
+      "include_colab_link": true
+    },
+    "kernelspec": {
+      "name": "python3",
+      "display_name": "Python 3"
+    },
+    "language_info": {
+      "name": "python"
+    }
+  },
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "view-in-github",
+        "colab_type": "text"
+      },
+      "source": [
+        "<a href=\"https://colab.research.google.com/github/jcandane/gym_rings/blob/main/ring_dataset.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "# Ring Dataset for Calibration of Classification & Manifold Models"
+      ],
+      "metadata": {
+        "id": "H-BUP1FKiX4R"
+      }
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "## defs"
+      ],
+      "metadata": {
+        "id": "PBkKn7m0ydvB"
+      }
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "### optional download from github repo"
+      ],
+      "metadata": {
+        "id": "t2ypmzGg6PaJ"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "try:\n",
+        "    from gym_rings import get_rings\n",
+        "except:\n",
+        "    !wget https://raw.githubusercontent.com/jcandane/gym_rings/main/gym_rings.py\n",
+        "    from gym_rings import get_rings"
+      ],
+      "metadata": {
+        "id": "0MWhz-V36ZjT"
+      },
+      "execution_count": 1,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "### raw code"
+      ],
+      "metadata": {
+        "id": "JiZ9NcKW6Xpi"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "import numpy as np\n",
+        "\n",
+        "def define_ring(A, radii):\n",
+        "    \"\"\"\n",
+        "    define a Boolean ring, such that the image is made from \"True\" or \"1\".\n",
+        "    A:np.ndarray (initial array)\n",
+        "    radius_range:tuple defined by (minimum radius, maximum radius)\n",
+        "    GET>\n",
+        "    A:np.ndarray (initial array with an additional ring with radius_range)\n",
+        "    \"\"\"\n",
+        "    height, width = A.shape\n",
+        "    radii  = radii.reshape(-1,2).T\n",
+        "\n",
+        "    center = np.array([width / 2, height / 2])\n",
+        "    I_xi   = np.indices((height, width)).reshape(2, -1) ## meshgrid -> flatten image\n",
+        "    I_xi   = np.vstack((I_xi[1], I_xi[0]))\n",
+        "\n",
+        "    ### RINGS\n",
+        "    mask_i  = (np.linalg.norm(I_xi-center[:,None], axis=0)[:,None] >= radii[0][None,:]) ##&\n",
+        "    mask_i &= (np.linalg.norm(I_xi-center[:,None], axis=0)[:,None] <  radii[1][None,:])\n",
+        "    mask_i  = np.any(mask_i, axis=-1)\n",
+        "\n",
+        "    A = A.reshape(-1)\n",
+        "    A[mask_i] = 1\n",
+        "    return A.reshape(height, width)\n",
+        "\n",
+        "def ring_notch(image_shape, θ:np.ndarray, radius_range, notch_width=5.):\n",
+        "    \"\"\"\n",
+        "    GIVEN>\n",
+        "    image_shape:tuple (The shape of the image (height, width))\n",
+        "    θ:np.ndarray[1d] (list of angles, θ.shape=(samples,))\n",
+        "    radius_range:np.ndarray (for a given ring, [R_min,R_max])\n",
+        "    notch_width:float (in degrees)\n",
+        "    GET>\n",
+        "    np.ndarray (A boolean mask for the notches)\n",
+        "    \"\"\"\n",
+        "    height, width      = image_shape\n",
+        "\n",
+        "    θ = (θ).astype(float)\n",
+        "    θ *= -1.\n",
+        "    #θ -= 1.*notch_width\n",
+        "    θ_min = np.deg2rad(θ - notch_width)\n",
+        "    θ_max = np.deg2rad(θ + notch_width)\n",
+        "\n",
+        "    # Create a grid of x and y coordinates\n",
+        "    y, x = np.ogrid[:height, :width]\n",
+        "\n",
+        "    # Calculate the distances and angles\n",
+        "    y = y - width / 2\n",
+        "    x = x - height / 2\n",
+        "    distance = np.sqrt(x**2 + y**2)\n",
+        "    angle    = np.arctan2(y, x) ## every pixel associated an angle\n",
+        "\n",
+        "    # Normalize angles to [0, 2*pi)\n",
+        "    angle = np.mod(angle, 2 * np.pi)\n",
+        "    θ_min = np.mod(θ_min, 2 * np.pi)\n",
+        "    θ_max = np.mod(θ_max, 2 * np.pi)\n",
+        "\n",
+        "    # Create the mask for the angle range\n",
+        "    R_min, R_max = radius_range\n",
+        "    R_min = float(R_min)-0.01\n",
+        "    R_max = float(R_max)+0.01\n",
+        "\n",
+        "    shifted_angle     = (angle[:,:,None] - θ_min[None,None,:]) % 360 ### why not % 2*np.pi ???\n",
+        "    shifted_end_angle = (θ_max - θ_min) % 360\n",
+        "    angle_mask        = (shifted_angle <= shifted_end_angle[None,None,:])\n",
+        "\n",
+        "    radius_mask = (distance <= R_max) & (distance > R_min)\n",
+        "    mask        = angle_mask & radius_mask[:,:,None]\n",
+        "    return mask.swapaxes(0,2).swapaxes(1,2) ### s.t. snapshots, pixels\n",
+        "\n",
+        "def get_rings(N:int, θs:np.ndarray, radii, notch_width=5.): ##\n",
+        "    \"\"\"\n",
+        "    GIVEN>\n",
+        "    N:int (image side size, such that image.shape=(N,N))\n",
+        "    θs:np.ndarray[2d] (list of angles for each ring, with θs.shape=(ring count, samples) )\n",
+        "    radii:np.ndarray[2] (with shape=(ring count, 2), i.e. axis=1 is the R_min, R_max for each ring)\n",
+        "    notch_width:float (notch angle, default=5 degrees, this can be generalized)\n",
+        "    GET>\n",
+        "    np.ndarray (dataset of shape=(θs.shape[1], N, N))\n",
+        "    \"\"\"\n",
+        "    img_shape = (N,N)\n",
+        "\n",
+        "    R    = define_ring(np.zeros(img_shape, dtype=bool), radii)\n",
+        "    mask = np.asarray([ ring_notch(img_shape, θs[r], radii[r], notch_width=notch_width) for r in range(len(radii))])\n",
+        "    mask = np.sum(mask, axis=0)\n",
+        "\n",
+        "    return R[None,:,:]*np.logical_not( mask )"
+      ],
+      "metadata": {
+        "id": "53embXj5iqV6"
+      },
+      "execution_count": 2,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "## Rings test"
+      ],
+      "metadata": {
+        "id": "Jm3p1JlLqxO5"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "import matplotlib.pyplot as plt\n",
+        "\n",
+        "### input\n",
+        "N      = 256\n",
+        "angles = np.array([[90,270,180.,0,360,65,182, 234], [45,86,243,360,97,12, 311, 34], [90,270,90,5,156,65,182, 211]])\n",
+        "radii  = np.array([[30,50],[70,90],[110,130]])\n",
+        "\n",
+        "### ouput\n",
+        "A    = get_rings(N, angles, radii)\n",
+        "\n",
+        "plt.imshow(A[-8], interpolation='none', cmap='Greys')\n",
+        "plt.axis(\"off\")\n",
+        "plt.show()"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 406
+        },
+        "id": "2by18XdLq1bh",
+        "outputId": "e71e882d-e45e-479b-fb72-bb49f74efe99"
+      },
+      "execution_count": 3,
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 640x480 with 1 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {}
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "import matplotlib.pyplot as plt\n",
+        "\n",
+        "### input\n",
+        "N      = 64\n",
+        "angles = 360*np.random.rand(3,100000)\n",
+        "radii  = np.array([[1,10],[15,30]]) #np.array([[30,50],[70,90],[110,130]])\n",
+        "\n",
+        "### ouput\n",
+        "A    = get_rings(N, angles, radii)\n",
+        "\n",
+        "\n",
+        "print(A.size/1024/1024, A.dtype)\n",
+        "plt.imshow(A[-8], interpolation='none', cmap='Greys')\n",
+        "plt.axis(\"off\")\n",
+        "plt.show()"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 424
+        },
+        "id": "9KT-Nq39oJw_",
+        "outputId": "27070a9b-8f0a-425b-c843-c28883e82282"
+      },
+      "execution_count": 4,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "390.625 bool\n"
+          ]
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 640x480 with 1 Axes>"
+            ],
+            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYUAAAGFCAYAAAASI+9IAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAHf0lEQVR4nO3dwW7bRhRAUarI//8yuyhwExRiFDm0ODM8Zxl0QVuULx7mlXzs+75vALBt2z9XXwAA4xAFACIKAEQUAIgoABBRACCiAEBEAYCIAgARBQAiCgBEFACIKAAQUQAgogBARAGAiAIAEQUAIgoARBQAiCgAEFEAIKIAQEQBgIgCAPlx9QVwH4/H4+pLWNK+71dfAgsxKQAQUQAgogBARAGAiAIAsX3ES7aGxnbW52OLiW0zKQDwC1EAIKIAQEQBgIgCALF9tDibQ/ypM+4VG0zzMykAEFEAIKIAQEQBgIgCALF9tAhbRozg6D60lTQPkwIAEQUAIgoARBQAiIPmQTk4ZiXv3M8Opa9lUgAgogBARAGAiAIAEQUAYvtoADaN4CePyriWSQGAiAIAEQUAIgoARBQAiO2jb2CbCM737vfKttLXmBQAiCgAEFEAIKIAQEQBgNg++gu2jGBcz76fNpJeMykAEFEAIKIAQEQBgIgCALF99IdsGsH8vNXtNZMCABEFACIKAEQUAIiD5v9xoAz34wD6J5MCABEFACIKAEQUAIgoAJDbbh/ZMgJeueNWkkkBgIgCABEFACIKAEQUAIgoABBRACCiAEBEAYCIAgARBQCy/LOPPOMIONvKz0QyKQAQUQAgogBARAGALHPQ7EAZuNqzv0OzHT6bFACIKAAQUQAgogBARAGAiAIAEQUAIgoARBQAiCgAEFEAIFM++8hzjtY32/NizuYeX8dsL+QxKQAQUQAgogBARAGAiAIAeeyjHoFvNjBWM/CtNjXfk7Vc/T0xKQAQUQAgogBARAGAiAIAmfLZR4zt6u2Juzn6fdtK4itMCgBEFACIKAAQUQAgDpp5ycHxnN793BxMs20mBQB+IQoARBQAiCgAEFEAIEO8ZMfWwxgGuBUYjO/mOD71/TQpABBRACCiAEBEAYCIAgDx7COmsto2jI0vRmNSACCiAEBEAYCIAgARBQBi++imRt96WW3L6MjRzznK53N0HXf5fO7IpABARAGAiAIAEQUAIgoA5KNvXrOx8HmjbLFsm8//u/iM7+s7PnuTAgARBQAiCgBEFACIKAAQUQAgogBARAGAiAIAEQUA4iU7i/Cog/sa6UU9XsozP5MCABEFACIKAEQUAIgoABDbR3yZjZKxjbSVxDxMCgBEFACIKAAQUQAgogBARAGAiAIAEQUAIgoARBQAiCgAEFEAIKIAQEQBgIgCABEFACIKAEQUAIgoABBRACCiAEBEAYD8uPoCYBT7vj/998fj8eErgeuYFACIKAAQUQAgogBARAGAiAIAEQUAIgoARBQAiCgAEFEAIKIAQEQBgIgCABEFACIKAEQUAIgoABBRACCiAEBEAYCIAgARBQAiCgBEFACIKAAQUQAgogBAflx9Acxr3/en//54PD58JTxz9PnA75gUAIgoABBRACCiAEBEAYDYPlrE0cbPFRsotpI+a4Yto3eu0X1yLZMCABEFACIKAEQUAIiDZm5nhoPZOzvr83Fg/TUmBQAiCgBEFACIKAAQUQAgj32AVQxbAp83wMf+W995T7z7s19xf876+Yx+3e8a6W/Tp363JgUAIgoARBQAiCgAEFEAIJ59dFPPtipG2hy5y4t6RvqdP/Pu7/ud/370n33b5thUO5tJAYCIAgARBQAiCgBEFACI7SOmcsXGygxbMjN6d1Nnhs/hjGu8eoPJpABARAGAiAIAEQUAIgoAZIg3rx25+hSe/wx8i3Ci1b5v7tuvMSkAEFEAIKIAQEQBgHjMBS+t+DiCO1jt4Phdo79IalQmBQAiCgBEFACIKAAQUQAgto843dHWi82P73H3LaN32KR7zaQAQEQBgIgCABEFACIKAGTol+wcsW2xvglvy1O5x+e0wn1rUgAgogBARAGAiAIAEQUAMuX20TO2NYARzfYn1qQAQEQBgIgCABEFACIKAEQUAIgoABBRACCiAEBEAYD8uPoCznL0v5J7/AXwKbM90uIZkwIAEQUAIgoARBQAiCgAkGW2j47YSgLOtsKW0RGTAgARBQAiCgBEFACIKAAQUQAgogBARAGAiAIAEQUAIgoAZPlnHx3xTCTglZWfcXTEpABARAGAiAIAEQUActuD5iMOoOF+7nigfMSkAEBEAYCIAgARBQAiCgDE9tEferadYCMJ5mLL6DWTAgARBQAiCgBEFACIKAAQ20d/wXOSYFw2jb7GpABARAGAiAIAEQUAIgoAxPbRN3h368G2Erxmm+gzTAoARBQAiCgAEFEAIKIAQGwfDcBb3eAnW0bXMikAEFEAIKIAQEQBgDhoHpRHZbASh8fzMCkAEFEAIKIAQEQBgIgCALF9tIij7Q5bSXySLaP5mRQAiCgAEFEAIKIAQEQBgNg+WtwZ2yA2mO7B5hDbZlIA4BeiAEBEAYCIAgARBQBi+4iXztpKscX0PWwNcSaTAgARBQAiCgBEFACIg2Y+xoEojM+kAEBEAYCIAgARBQAiCgBEFACIKAAQUQAgogBARAGAiAIAEQUAIgoARBQAiCgAEFEAIKIAQEQBgIgCABEFACIKAORfYbo0OJmrIksAAAAASUVORK5CYII=\n"
+          },
+          "metadata": {}
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "## Pendulum Data Set"
+      ],
+      "metadata": {
+        "id": "xIZtaQQp710J"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "### download numpy zip file for pendulum trajectory\n",
+        "try:\n",
+        "    angles = np.load(\"pendulum_L100m_1000s_90deg_a0_0014mss.npy\")[1]\n",
+        "except:\n",
+        "    !wget https://raw.githubusercontent.com/jcandane/gym_rings/main/pendulum_L100m_1000s_90deg_a0_0014mss.npy\n",
+        "    angles = np.load(\"pendulum_L100m_1000s_90deg_a0_0014mss.npy\")[1] ## for angles, [0] are real time-stamps\n",
+        "\n",
+        "angles=np.array([angles])-90\n",
+        "N      = 32\n",
+        "radii  = np.array([[5,15]])\n",
+        "\n",
+        "### ouput data_set\n",
+        "A    = get_rings(N, angles, radii)"
+      ],
+      "metadata": {
+        "id": "ppzst4Fjpje4"
+      },
+      "execution_count": 5,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "print(A.size/1024/1024, A.dtype)\n",
+        "plt.imshow(A[0], interpolation='none', cmap='Greys')\n",
+        "plt.axis(\"off\")\n",
+        "plt.show()\n",
+        "\n",
+        "plt.imshow(A[-1], interpolation='none', cmap='Greys')\n",
+        "plt.axis(\"off\")\n",
+        "plt.show()"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 813
+        },
+        "id": "AzxYEkL5AEGy",
+        "outputId": "26a585a7-41d6-47c3-b726-7ec69366cfa2"
+      },
+      "execution_count": 6,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "97.65625 bool\n"
+          ]
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 640x480 with 1 Axes>"
+            ],
+            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYUAAAGFCAYAAAASI+9IAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAGJElEQVR4nO3cwW4TMRhG0Rjl/V/Z7C6CBdQ0E09mzllHwqraXP0LvjHnnA8AeDweP3Y/AIDzEAUAIgoARBQAiCgAEFEAIKIAQEQBgIgCABEFACIKAEQUAIgoABBRACCiAEBEAYCIAgARBQAiCgBEFACIKAAQUQAgogBARAGAiAIAEQUAIgoARBQAiCgAEFEAIKIAQJ67H8D5jTF2P4FN5py7n8CbuRQAiCgAEFEAIKIAQEQBgIgCABEFACIKAEQUAIgoABBRACC2jy7CPhFHOPL3yq7SObkUAIgoABBRACCiAEBEAYCIAgARBQAiCgBEFACIKAAQMxcnZbaCq1v9HTeL8R4uBQAiCgBEFACIKAAQUQAgogBARAGAiAIAEQUAIgoARBQAiO2jb7BPBO9z5N+bXaVfXAoARBQAiCgAEFEAIKIAQEQBgIgCABEFACIKAEQUAIiZiz+YroD7Wf27v/IshksBgIgCABEFACIKAEQUAIgoABBRACCiAEBEAYCIAgARBQAiCgBEFACIKAAQUQAgogBARAGAiAIAEQUAIgoARBQAiCgAkOfuBxxtjLH7CcDFrHyvzDkPfMnruRQAiCgAEFEAIKIAQEQBgIgCABEFACIKAEQUAIgoABBRACAfuX1kzwj4FKvfV7u3klwKAEQUAIgoABBRACCiAEBEAYCIAgARBQAiCgBEFACIKAAQUQAgogBARAGAiAIAEQUAIgoARBQAiCgAEFEAIKIAQEQBgDx3P+DxeDzGGLufAHAKK9+Hc86X//suBQAiCgBEFACIKAAQUQAgogBARAGAiAIAEQUAIgoARBQAyCm2j+Crjth6OSN7YOziUgAgogBARAGAiAIAEQUAIgoARBQAiCgAEFEAIKIAQMxcsNVdZitWrfxcTGLwSi4FACIKAEQUAIgoABBRACCiAEBEAYCIAgARBQAiCgBEFACI7SNezp7Re63+vG0l8TcuBQAiCgBEFACIKAAQUQAgogBARAGAiAIAEQUAIgoAxMwFwKIrT7m4FACIKAAQUQAgogBARAGAiAIAEQUAIgoARBQAiCgAEFEAILaP4GauvNvD97kUAIgoABBRACCiAEBEAYCIAgARBQAiCgBEFACIKAAQUQAgto/gZsYYu5/w8a68H+VSACCiAEBEAYCIAgARBQAiCgBEFACIKAAQUQAgogBAzFwALDrLVMgRcxsuBQAiCgBEFACIKAAQUQAgogBARAGAiAIAEQUAIgoARBQAiO0jXm5lF+aI7Za7OcsOD9fgUgAgogBARAGAiAIAEQUAIgoARBQAiCgAEFEAIKIAQMxcsNXqRMNdZjFMV7CLSwGAiAIAEQUAIgoARBQAiCgAEFEAIKIAQEQBgIgCABEFAGL7iI9iEwiO5VIAIKIAQEQBgIgCABEFACIKAEQUAIgoABBRACCiAEBOMXMx51z6vKkD4KpWvw9fzaUAQEQBgIgCABEFACIKAEQUAIgoABBRACCiAEBEAYCIAgARBQAiCgBEFACIKAAQUQAgogBARAGAiAIAEQUAIgoARBQAyHP3A/7HnPPLnx1jHPgSgL9b+b46A5cCABEFACIKAEQUAIgoABBRACCiAEBEAYCIAgARBQAiCgDkI7ePVqzujthKAv7l0/aMVrgUAIgoABBRACCiAEBEAYCIAgARBQAiCgBEFACIKAAQUQAgogBARAGAiAIAEQUAIgoARBQAiCgAEFEAIKIAQEQBgIgCAHnufsDZzDm//NkxxoEvAd5l5e/+6lwKAEQUAIgoABBRACCiAEBEAYCIAgARBQAiCgBEFACIKAAQ20ffcOReil0l+J19ovdwKQAQUQAgogBARAGAiAIAEQUAIgoARBQAiCgAEFEAIGYuTmr1v/SbxeDTmK04J5cCABEFACIKAEQUAIgoABBRACCiAEBEAYCIAgARBQAiCgDE9tFFHLkjY1fpvuwT3Y9LAYCIAgARBQAiCgBEFACIKAAQUQAgogBARAGAiAIAMXPBP5k6gPtwKQAQUQAgogBARAGAiAIAEQUAIgoARBQAiCgAEFEAIKIAQEQBgIgCABEFACIKAEQUAIgoABBRACCiAEBEAYCIAgD5CVIkbTS2TJ6sAAAAAElFTkSuQmCC\n"
+          },
+          "metadata": {}
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 640x480 with 1 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {}
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [],
+      "metadata": {
+        "id": "W--VG00o83zE"
+      },
+      "execution_count": 6,
+      "outputs": []
+    }
+  ]
+}