training_sample_generation.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "from copy import deepcopy\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "from pydrake.all import RigidTransform, StartMeshcat, MeshcatVisualizer\n",
    "\n",
    "from pydrake.multibody.parsing import Parser\n",
    "from pydrake.multibody.plant import AddMultibodyPlantSceneGraph\n",
    "from pydrake.perception import Concatenate\n",
    "from pydrake.systems.framework import DiagramBuilder\n",
    "\n",
    "from manipulation.scenarios import AddRgbdSensors\n",
    "from manipulation.utils import ConfigureParser\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:drake:Meshcat listening for connections at http://localhost:7001\n"
     ]
    }
   ],
   "source": [
    "# Start the visualizer.\n",
    "meshcat = StartMeshcat()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 202,
   "metadata": {},
   "outputs": [],
   "source": [
    "def BallExampleSystem():\n",
    "    builder = DiagramBuilder()\n",
    "\n",
    "    # Create the physics engine + scene graph.\n",
    "    plant, scene_graph = AddMultibodyPlantSceneGraph(builder, time_step=0.0)\n",
    "    parser = Parser(plant)\n",
    "    ConfigureParser(parser)\n",
    "    parser.package_map().AddPackageXml(filename=\"./package.xml\")\n",
    "    parser.AddModelsFromUrl(\"package://bot_shot/models/training.dmd.yaml\")\n",
    "    plant.Finalize()\n",
    "\n",
    "    # Add a visualizer just to help us see the object.\n",
    "    MeshcatVisualizer.AddToBuilder(builder, scene_graph, meshcat)\n",
    "        # meshcat = builder.AddSystem(MeshcatVisualizer(scene_graph))\n",
    "        # builder.Connect(\n",
    "        #     scene_graph.get_query_output_port(),\n",
    "        #     meshcat.get_geometry_query_input_port(),\n",
    "        # )\n",
    "\n",
    "    AddRgbdSensors(builder, plant, scene_graph)\n",
    "\n",
    "    diagram = builder.Build()\n",
    "    diagram.set_name(\"depth_camera_demo_system\")\n",
    "    return diagram"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 265,
   "metadata": {},
   "outputs": [],
   "source": [
    "class SimpleCameraSystem:\n",
    "    def __init__(self):\n",
    "        diagram = BallExampleSystem()\n",
    "        context = diagram.CreateDefaultContext()\n",
    "\n",
    "        # setup\n",
    "        meshcat.SetProperty(\"/Background\", \"visible\", False)\n",
    "\n",
    "        # getting data\n",
    "        self.point_cloud = diagram.GetOutputPort(\"camera0_point_cloud\").Eval(context)\n",
    "        self.depth_im_read = (\n",
    "            diagram.GetOutputPort(\"camera0_depth_image\").Eval(context).data.squeeze()\n",
    "        )\n",
    "        self.depth_im = deepcopy(self.depth_im_read)\n",
    "        self.depth_im[self.depth_im == np.inf] = 10.0\n",
    "        label_im = (\n",
    "            diagram.GetOutputPort(\"camera0_label_image\").Eval(context).data.squeeze()\n",
    "        )\n",
    "        self.rgb_im = diagram.GetOutputPort(\"camera0_rgb_image\").Eval(context).data\n",
    "        self.mask = label_im == 1\n",
    "\n",
    "        # draw visualization\n",
    "        meshcat.SetObject(\"point_cloud\", self.point_cloud)\n",
    "        diagram.ForcedPublish(context)\n",
    "\n",
    "        # camera specs\n",
    "        cam0 = diagram.GetSubsystemByName(\"camera0\")\n",
    "        cam0_context = cam0.GetMyMutableContextFromRoot(context)\n",
    "        self.X_WC = cam0.GetOutputPort(\"body_pose_in_world\").Eval(cam0_context)\n",
    "        self.X_WC = RigidTransform(self.X_WC)  # See drake issue #15973\n",
    "        self.cam_info = cam0.default_depth_render_camera().core().intrinsics()\n",
    "\n",
    "        # get points for mustard bottle\n",
    "        depth_mustard = self.mask * self.depth_im\n",
    "        u_range = np.arange(depth_mustard.shape[0])\n",
    "        v_range = np.arange(depth_mustard.shape[1])\n",
    "        depth_v, depth_u = np.meshgrid(v_range, u_range)\n",
    "        depth_pnts = np.dstack([depth_u, depth_v, depth_mustard])\n",
    "        depth_pnts = depth_pnts.reshape([depth_pnts.shape[0] * depth_pnts.shape[1], 3])\n",
    "        pC = self.project_depth_to_pC(depth_pnts)\n",
    "        p_C_mustard = pC[pC[:, 2] > 0]\n",
    "        self.p_W_mustard = self.X_WC.multiply(p_C_mustard.T).T\n",
    "\n",
    "    def get_color_image(self):\n",
    "        return deepcopy(self.rgb_im[:, :, 0:3])\n",
    "\n",
    "    def get_intrinsics(self):\n",
    "        # read camera intrinsics\n",
    "        cx = self.cam_info.center_x()\n",
    "        cy = self.cam_info.center_y()\n",
    "        fx = self.cam_info.focal_x()\n",
    "        fy = self.cam_info.focal_y()\n",
    "        return cx, cy, fx, fy\n",
    "\n",
    "    def project_depth_to_pC(self, depth_pixel):\n",
    "        \"\"\"\n",
    "        project depth pixels to points in camera frame\n",
    "        using pinhole camera model\n",
    "        Input:\n",
    "            depth_pixels: numpy array of (nx3) or (3,)\n",
    "        Output:\n",
    "            pC: 3D point in camera frame, numpy array of (nx3)\n",
    "        \"\"\"\n",
    "        # switch u,v due to python convention\n",
    "        v = depth_pixel[:, 0]\n",
    "        u = depth_pixel[:, 1]\n",
    "        Z = depth_pixel[:, 2]\n",
    "        cx, cy, fx, fy = self.get_intrinsics()\n",
    "        X = (u - cx) * Z / fx\n",
    "        Y = (v - cy) * Z / fy\n",
    "        pC = np.c_[X, Y, Z]\n",
    "        return pC\n",
    "\n",
    "\n",
    "def bbox(img):\n",
    "    a = np.where(img != 0)\n",
    "    bbox = ([np.min(a[0]), np.max(a[0])], [np.min(a[1]), np.max(a[1])])\n",
    "    return bbox\n",
    "\n",
    "meshcat.Delete()\n",
    "env = SimpleCameraSystem()\n",
    "X_WC = env.X_WC\n",
    "p_W_mustard = env.p_W_mustard\n",
    "K = env.cam_info.intrinsic_matrix()\n",
    "rgb_im = env.get_color_image()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 242,
   "metadata": {},
   "outputs": [],
   "source": [
    "def deproject_pW_to_image(p_W_mustard, cx, cy, fx, fy, X_WC):\n",
    "    \"\"\"\n",
    "    convert points in the world frame to camera pixels\n",
    "    Input:\n",
    "        - p_W_mustard: points of the mustard bottle in world frame (nx3)\n",
    "        - fx, fy, cx, cy: camera intrinsics\n",
    "        - X_WC: camera pose in the world frame\n",
    "    Output:\n",
    "        - mask: numpy array of size 480x640\n",
    "    \"\"\"\n",
    "    # Transfer bottle to camera frame\n",
    "    p_C_mustard = X_WC.inverse().multiply(p_W_mustard.T).T\n",
    "    X_c = p_C_mustard[:, 0]\n",
    "    Y_c = p_C_mustard[:, 1]\n",
    "    Z_c = p_C_mustard[:, 2]\n",
    "\n",
    "    # Deproject onto image plane\n",
    "    u = (X_c / Z_c) * fx + cx\n",
    "    v = (Y_c / Z_c) * fy + cy\n",
    "\n",
    "    # Convert to integer pixel coordinates\n",
    "    u = np.round(u).astype(int)\n",
    "    v = np.round(v).astype(int)\n",
    "\n",
    "    # Create an empty mask\n",
    "    depth_image_shape = [480, 640]\n",
    "    mask = np.zeros(depth_image_shape, dtype=np.uint8)\n",
    "    \n",
    "    # Filter points that lie within image boundaries\n",
    "    valid_indices = (u >= 0) & (u < depth_image_shape[1]) & (v >= 0) & (v < depth_image_shape[0])\n",
    "    u = u[valid_indices]\n",
    "    v = v[valid_indices]\n",
    "    \n",
    "    # Set mask pixels corresponding to the mustard bottle to 1\n",
    "    mask[v, u] = 1\n",
    "    \n",
    "    return mask"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 269,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x37f6f3110>"
      ]
     },
     "execution_count": 269,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.imshow(rgb_im)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 270,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x3a94774a0>"
      ]
     },
     "execution_count": 270,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "cx, cy, fx, fy = env.get_intrinsics()\n",
    "mask = deproject_pW_to_image(p_W_mustard, cx, cy, fx, fy, X_WC)\n",
    "plt.imshow(mask)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "! pip3 install keras\n",
    "! pip3 install tensorflow"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 273,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x3a94dff80>"
      ]
     },
     "execution_count": 273,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Importing necessary functions\n",
    "import os\n",
    "from PIL import Image\n",
    "import json\n",
    "from tensorflow.keras.preprocessing.image import ImageDataGenerator\n",
    "from tensorflow.keras.utils import array_to_img, img_to_array, load_img\n",
    "  \n",
    "# Initialising the ImageDataGenerator class.\n",
    "# We will pass in the augmentation parameters in the constructor.\n",
    "datagen = ImageDataGenerator(\n",
    "        rotation_range = 180,\n",
    "        zoom_range = 0.2,\n",
    "        horizontal_flip = True,\n",
    "        brightness_range = (0.5, 1.5))\n",
    "   \n",
    "# Loading a sample image \n",
    "img = np.concatenate([rgb_im, np.reshape(mask, [480, 640, 1])], axis=2)\n",
    "\n",
    "# Converting the input sample image to an array\n",
    "x = img_to_array(img)\n",
    "  \n",
    "# Generating and saving 5 augmented samples \n",
    "# using the above defined parameters. \n",
    "num_of_training = 119\n",
    "save_to_dir = \"./ball_training\"\n",
    "for i in range(num_of_training):\n",
    "    transformed = datagen.random_transform(x)\n",
    "    rgb_new = transformed[:, :, :3]\n",
    "    mask_new = transformed[:, :, 3]\n",
    "    base = 10179\n",
    "    label = {\"2\": \"012_ball\"}\n",
    "    img = Image.fromarray(rgb_new.astype('uint8'))\n",
    "    img.save(os.path.join(save_to_dir, f\"{base + i}.png\"))\n",
    "    np.save(os.path.join(save_to_dir, f\"{base + i}_mask.npy\"), mask_new)\n",
    "    with open(os.path.join(save_to_dir, f\"{base + i}.json\"), \"w\") as outfile:\n",
    "        json.dump(label, outfile) \n",
    "\n",
    "plt.imshow(mask_new)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 272,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x37f69fc80>"
      ]
     },
     "execution_count": 272,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.imshow(np.squeeze(np.load(os.path.join(save_to_dir, f\"{base + 117}_mask.npy\"))))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.12.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}