ReadData.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# read video frame\n",
    "import PIL.Image\n",
    "import io\n",
    "from IPython.display import clear_output, Image as PILIMAGE, display, HTML\n",
    "import numpy as np\n",
    "import cv2\n",
    "import time\n",
    "from cpsdriver.codec import DocObjectCodec\n",
    "import io\n",
    "import time\n",
    "from PIL import Image\n",
    "from IPython.display import clear_output, display, HTML\n",
    "from pymongo import MongoClient\n",
    "\n",
    "def showarray(a, fmt='jpeg'):\n",
    "    a = a.resize((1280,720))\n",
    "    a = np.uint8(a)\n",
    "#     a = a[:,:,[2,1,0]]\n",
    "    f = io.BytesIO()\n",
    "    PIL.Image.fromarray(a).save(f, fmt)\n",
    "    display(PILIMAGE(data=f.getvalue()))\n",
    "\n",
    "client = MongoClient('mongodb://localhost:27017')\n",
    "db = client['cps-test-20']\n",
    "frame_message = db['frame_message']\n",
    "\n",
    "# camera_id = 4 # gondola 5 closer\n",
    "camera_id = 8 # gondola 5\n",
    "# camera_id = 10 # middle view\n",
    "# camera_id = 12 # left view\n",
    "\n",
    "for item in frame_message.find():\n",
    "    if item['camera_id'] != camera_id:\n",
    "        continue\n",
    "        \n",
    "    rgb = DocObjectCodec.decode(doc=item, collection='frame_message')\n",
    "    imageStream = io.BytesIO(rgb.frame)\n",
    "    imageFile = Image.open(imageStream)\n",
    "    \n",
    "    showarray(imageFile)\n",
    "\n",
    "    print (item['date_time'],'camera_id',item['camera_id'])\n",
    "#     time.sleep(0.1)\n",
    "#     input(\"Press Enter to continue...\")\n",
    "    clear_output(wait=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from pymongo import MongoClient\n",
    "import numpy as np\n",
    "import cv2\n",
    "import base64\n",
    "\n",
    "# client = MongoClient('mongodb://cpsweek:localdb@localhost:27018')\n",
    "client = MongoClient('mongodb://localhost:27017')\n",
    "\n",
    "db = client['ALL-SIMPLE-CHIP-1']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# display a video\n",
    "# from IPython.display import Video\n",
    "\n",
    "# Video('https://archive.org/download/Sita_Sings_the_Blues/Sita_Sings_the_Blues_small.mp4')\n",
    "# Video('data/cps-test-videos/192.168.1.100_2020-01-28_22-24-06.mp4')\n",
    "# Video(‘path/to/video.mp4’, embed=True)\n",
    "# Video(b’raw-videodata’, embed=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# display your camera\n",
    "\n",
    "import PIL.Image\n",
    "import io\n",
    "from IPython.display import clear_output, Image, display, HTML\n",
    "import numpy as np\n",
    "import cv2\n",
    "import time\n",
    "\n",
    "def showarray(a, fmt='jpeg'):\n",
    "    a = np.uint8(a)\n",
    "    f = io.BytesIO()\n",
    "    PIL.Image.fromarray(a).save(f, fmt)\n",
    "    display(Image(data=f.getvalue()))\n",
    "\n",
    "def show_my_camera():\n",
    "    # cam = cv2.VideoCapture(0)\n",
    "    cam = cv2.VideoCapture('data/cps-test-videos/192.168.1.100_2020-01-28_22-24-06.mp4')\n",
    "    frame_count = 0\n",
    "    start_time = time.time()\n",
    "    try:\n",
    "        while(True):\n",
    "            # Capture frame-by-frame\n",
    "            ret, frame = cam.read()\n",
    "    # Convert the image from OpenCV BGR format to matplotlib RGB format\n",
    "            # to display the image\n",
    "            frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)\n",
    "            showarray(frame)\n",
    "            frame_count += 1\n",
    "            elapsed_time = time.time() - start_time # seconds\n",
    "            print (int(frame_count/elapsed_time), 'fps')\n",
    "    # Display the frame until new frame is available\n",
    "            clear_output(wait=True)\n",
    "\n",
    "\n",
    "    except KeyboardInterrupt:\n",
    "        cam.release()\n",
    "        print (\"Stream stopped\")\n",
    "\n",
    "# show_my_camera()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# db.products\n",
    "from IPython.display import Image, display\n",
    "\n",
    "class Product:\n",
    "    def __init__(self, barcode_type, id, name, thumbnail, price, weight):\n",
    "        self.barcode_type =barcode_type\n",
    "        self.id = id\n",
    "        self.name = name\n",
    "        self.thumbnail = thumbnail\n",
    "        self.price = price\n",
    "        self.weight = weight\n",
    "        self.plate_ids = None\n",
    "    \n",
    "    def __repr__(self):\n",
    "        return \"%s %s %s\\t%f %f %s %s\" % (self.barcode_type, self.id, self.name, self.price, self.weight, self.plate_ids, self.thumbnail)\n",
    "\n",
    "products_raw = db['products']\n",
    "products = {}\n",
    "\n",
    "print ('products', products_raw.count())\n",
    "item = products_raw.find_one()\n",
    "# print (item)\n",
    "\n",
    "for item in products_raw.find():\n",
    "    barcode_type = item['product_id']['barcode_type']\n",
    "    id = item['product_id']['id']\n",
    "    name = item['metadata']['name']\n",
    "    if 'thumbnail' in item['metadata']:\n",
    "        thumbnail = item['metadata']['thumbnail']\n",
    "    else:\n",
    "        thumbnail = None\n",
    "    if 'price' in item['metadata']:\n",
    "        price = item['metadata']['price']\n",
    "    else:\n",
    "        price = 0.0\n",
    "    \n",
    "    if 'weight' in item['metadata']:\n",
    "        weight = item['metadata']['weight']\n",
    "    else:\n",
    "        weight = 0.0\n",
    "    product = Product(barcode_type, id, name, thumbnail, price, weight)\n",
    "    products[id] = product\n",
    "    target_weight = 609\n",
    "    if weight < target_weight-50 or weight > target_weight + 50:\n",
    "        continue\n",
    "        \n",
    "    print (product)\n",
    "    if product.thumbnail is not None:\n",
    "        display(Image(url= product.thumbnail, width=200, height=100))\n",
    "print ('products', len(products))\n",
    "products[''] = Product('barcode_type', 'id', 'name', 'thumbnail', price=0, weight=0) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "planogram = db['planogram']\n",
    "\n",
    "print (planogram.count())\n",
    "item = planogram.find_one()\n",
    "# print (item)\n",
    "\n",
    "count = 0\n",
    "max_gondola = 6\n",
    "max_shelves = 7\n",
    "\n",
    "idx = 0\n",
    "plates = np.zeros((max_gondola,max_shelves))\n",
    "for item in planogram.find():\n",
    "#     print (item)\n",
    "#     print()\n",
    "#     print (len(item['plate_ids']))\n",
    "#     count += len(item['plate_ids'])\n",
    "    shelf_index = item['plate_ids'][0]['shelf_id']['shelf_index']\n",
    "    gondola_id = item['plate_ids'][0]['shelf_id']['gondola_id']['id']\n",
    "    plates[gondola_id][shelf_index] += len(item['plate_ids'])\n",
    "    if 'barcode_type' not in item['planogram_product_id']:\n",
    "        continue\n",
    "    product_barcode_type = item['planogram_product_id']['barcode_type']\n",
    "    product_barcode = item['planogram_product_id']['id']\n",
    "    product = products[product_barcode]\n",
    "    product.plate_ids = item['plate_ids']\n",
    "#     plate_ids = []\n",
    "#     for plate_id in item['plate_ids']:\n",
    "#         plate_ids.append(plate_id['plate_index'])\n",
    "#     print (products[product_barcode])\n",
    "    idx += 1\n",
    "#     if (idx >=2) :\n",
    "#         break\n",
    "    \n",
    "print (plates)\n",
    "# print (count)\n",
    "# print (item)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plate_data = db['plate_data']\n",
    "print (plate_data.count())\n",
    "item = plate_data.find_one()\n",
    "# print(item)\n",
    "\n",
    "from cpsdriver.codec import DocObjectCodec\n",
    "\n",
    "# Note: some shelves have only 9 plates, but still have 12 plates weight data, strange.\n",
    "max_gondola = 6\n",
    "max_shelves = 7\n",
    "for item in plate_data.find():\n",
    "    gondola_id = item['gondola_id']\n",
    "    shelf_index = item['shelf_index']\n",
    "    plate_index = item['plate_index']\n",
    "    if gondola_id == 5:\n",
    "        plate_data_item = DocObjectCodec.decode(doc=item, collection='plate_data')\n",
    "        np_plate = plate_data_item.data\n",
    "        np_plate = np.nan_to_num(np_plate, copy=True, nan=0)\n",
    "        np_plate = np_plate[:, 1:13, 1:13] # remove first line, which is always NaN elements\n",
    "    #     print (np_plate.shape) # [time,shelf,plate] (12, 7, 15)\n",
    "        print (np_plate[:,:,:]) # [time,shelf,plate]\n",
    "        break\n",
    "        print ('gondola_id',gondola_id, 'np_plate.shape', np_plate.shape)\n",
    "    \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# targets = db['targets']\n",
    "targets = db['full_targets']\n",
    "print (targets.count())\n",
    "item = targets.find_one()\n",
    "# print (item)\n",
    "\n",
    "for item in targets.find():\n",
    "    if item['document']['targets']:\n",
    "        target_count = len(item['document']['targets']['targets'])\n",
    "#         print (target_count)\n",
    "#         target_id = item['document']['targets']['targets'][0]['target_id']['id']\n",
    "#         target_state = item['document']['targets']['targets'][0]['target_state']\n",
    "#         head = item['document']['targets']['targets'][0]['head']\n",
    "#         print ('target_count',target_count,'target_id',target_id, 'target_state',target_state)\n",
    "#         print (head)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from cpsdriver.codec import DocObjectCodec\n",
    "database_name = \"cps-test-01\"\n",
    "frame_message = db['depth']\n",
    "print (frame_message.count())\n",
    "item = frame_message.find_one()\n",
    "# print (item)\n",
    "# print (len(item['document']['frame_message']['frames']))\n",
    "\n",
    "import io\n",
    "from PIL import Image\n",
    "from IPython.display import clear_output, display, HTML\n",
    "for item in frame_message.find():\n",
    "    item = DocObjectCodec.decode(doc=item, collection='depth')\n",
    "#     print (item) \n",
    "    timestamp = item.timestamp\n",
    "    camera_id = item.camera_id\n",
    "    rgb_frame = item.rgb_frame\n",
    "    depth_frame = item.depth_frame\n",
    "    print (timestamp,'camera_id',camera_id)\n",
    "\n",
    "    # rgb_frame\n",
    "    imageStream = io.BytesIO(rgb_frame.frame)\n",
    "    imageFile = Image.open(imageStream)\n",
    "    print('rgb frame', imageFile.size)\n",
    "    display(imageFile)\n",
    "    \n",
    "    # depth_frame \n",
    "#     print (depth_frame.frame[0])\n",
    "    imageFile = Image.fromarray(depth_frame.frame[0])\n",
    "    print ('depth_frame', imageFile.size)\n",
    "#     display(imageFile)\n",
    "#     break"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Shelves.json\n",
    "import json\n",
    "with open('data/meta/Shelves.json') as f:\n",
    "    shelves = json.load(f)\n",
    "print('shelves',len(shelves['shelves']))\n",
    "\n",
    "for i in range(len(shelves['shelves'])):\n",
    "    shelf = shelves['shelves'][i]\n",
    "    gondola_id = shelf['id']['gondola_id']['id']\n",
    "    shelf_id = shelf['id']['shelf_index']\n",
    "    z = shelf['coordinates']['transform']['translation']['z']\n",
    "    dim_z = shelf['coordinates']['dim_z']\n",
    "    bin_ids = []\n",
    "    for bin_id in shelf['bin_ids']:\n",
    "        bin_ids.append(bin_id['bin_index'])\n",
    "    bin_ids.sort()\n",
    "    if shelf_id != 6:\n",
    "        shelf_higher = shelves['shelves'][i+1]\n",
    "        diff_z = shelf_higher['coordinates']['transform']['translation']['z'] - z\n",
    "        diff_minus_dim = diff_z - dim_z\n",
    "        print(\"gondola=%d, shelf=%d, z=%.4f, dim_z=%.4f, diff_z=%.4f, diff_minus_dim=%.4f\" % (gondola_id, shelf_id, z, dim_z, diff_z, diff_minus_dim))\n",
    "    else:\n",
    "        diff_z = 2.0701 - z\n",
    "        print(\"gondola=%d, shelf=%d, z=%.4f, dim_z=%.4f, diff_z=%.4f\" % (gondola_id, shelf_id, z, dim_z, diff_z))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Plates.json\n",
    "import json\n",
    "with open('data/meta/Plates.json') as f:\n",
    "    plates = json.load(f)\n",
    "print('plates', len(plates['plates']))\n",
    "\n",
    "class Node:\n",
    "    def __repr__(self):\n",
    "        return \"Node: %s\" % id(self)\n",
    "    \n",
    "max_gondola = 6\n",
    "max_shelves = 7\n",
    "plates_count = np.zeros((max_gondola,max_shelves))\n",
    "\n",
    "for plate in plates['plates']:\n",
    "    gondola_id = plate['id']['shelf_id']['gondola_id']['id']\n",
    "    shelf_index = plate['id']['shelf_id']['shelf_index']\n",
    "    plate_index = plate['id']['plate_index']\n",
    "    plates_count[gondola_id][shelf_index] += 1\n",
    "    print(\"gondola\", gondola_id, 'shelf', shelf_index, 'plate', plate_index)\n",
    "print(plates_count)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Gondolas.json\n",
    "import json\n",
    "with open('data/meta/Gondolas.json') as f:\n",
    "    gondolas = json.load(f)\n",
    "print('gondolas',len(gondolas['gondolas']))\n",
    "\n",
    "for i in range(len(gondolas['gondolas'])):\n",
    "    gondola = gondolas['gondolas'][i]\n",
    "    gondola_id = gondola['id']['id']\n",
    "    x = gondola['coordinates']['transform']['translation']['x']\n",
    "    dim_x = gondola['coordinates']['dim_x']\n",
    "    if gondola_id != 5:\n",
    "        gondola_next = gondolas['gondolas'][i+1]\n",
    "        diff_x = gondola_next['coordinates']['transform']['translation']['x'] - x\n",
    "        print(\"gondola=%d, x=%.4f, dim_x=%.4f, diff_x=%.4f\" % (gondola_id, x, dim_x, diff_x))\n",
    "    else:\n",
    "        print(\"gondola=%d, x=%.4f, dim_x=%.4f\" % (gondola_id, x, dim_x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "env",
   "language": "python",
   "name": "env"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}